LCOV - code coverage report
Current view: top level - gcc/cp - tree.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 2434 2575 94.5 %
Date: 2020-03-28 11:57:23 Functions: 154 161 95.7 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Language-dependent node constructors for parse phase of GNU compiler.
       2                 :            :    Copyright (C) 1987-2020 Free Software Foundation, Inc.
       3                 :            :    Hacked by Michael Tiemann (tiemann@cygnus.com)
       4                 :            : 
       5                 :            : This file is part of GCC.
       6                 :            : 
       7                 :            : GCC is free software; you can redistribute it and/or modify
       8                 :            : it under the terms of the GNU General Public License as published by
       9                 :            : the Free Software Foundation; either version 3, or (at your option)
      10                 :            : any later version.
      11                 :            : 
      12                 :            : GCC is distributed in the hope that it will be useful,
      13                 :            : but WITHOUT ANY WARRANTY; without even the implied warranty of
      14                 :            : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15                 :            : GNU General Public License for more details.
      16                 :            : 
      17                 :            : You should have received a copy of the GNU General Public License
      18                 :            : along with GCC; see the file COPYING3.  If not see
      19                 :            : <http://www.gnu.org/licenses/>.  */
      20                 :            : 
      21                 :            : #include "config.h"
      22                 :            : #include "system.h"
      23                 :            : #include "coretypes.h"
      24                 :            : #include "tree.h"
      25                 :            : #include "cp-tree.h"
      26                 :            : #include "gimple-expr.h"
      27                 :            : #include "cgraph.h"
      28                 :            : #include "stor-layout.h"
      29                 :            : #include "print-tree.h"
      30                 :            : #include "tree-iterator.h"
      31                 :            : #include "tree-inline.h"
      32                 :            : #include "debug.h"
      33                 :            : #include "convert.h"
      34                 :            : #include "gimplify.h"
      35                 :            : #include "stringpool.h"
      36                 :            : #include "attribs.h"
      37                 :            : #include "flags.h"
      38                 :            : #include "selftest.h"
      39                 :            : 
      40                 :            : static tree bot_manip (tree *, int *, void *);
      41                 :            : static tree bot_replace (tree *, int *, void *);
      42                 :            : static hashval_t list_hash_pieces (tree, tree, tree);
      43                 :            : static tree build_target_expr (tree, tree, tsubst_flags_t);
      44                 :            : static tree count_trees_r (tree *, int *, void *);
      45                 :            : static tree verify_stmt_tree_r (tree *, int *, void *);
      46                 :            : 
      47                 :            : static tree handle_init_priority_attribute (tree *, tree, tree, int, bool *);
      48                 :            : static tree handle_abi_tag_attribute (tree *, tree, tree, int, bool *);
      49                 :            : 
      50                 :            : /* If REF is an lvalue, returns the kind of lvalue that REF is.
      51                 :            :    Otherwise, returns clk_none.  */
      52                 :            : 
      53                 :            : cp_lvalue_kind
      54                 :  283197000 : lvalue_kind (const_tree ref)
      55                 :            : {
      56                 :  353882000 :   cp_lvalue_kind op1_lvalue_kind = clk_none;
      57                 :  353882000 :   cp_lvalue_kind op2_lvalue_kind = clk_none;
      58                 :            : 
      59                 :            :   /* Expressions of reference type are sometimes wrapped in
      60                 :            :      INDIRECT_REFs.  INDIRECT_REFs are just internal compiler
      61                 :            :      representation, not part of the language, so we have to look
      62                 :            :      through them.  */
      63                 :  353882000 :   if (REFERENCE_REF_P (ref))
      64                 :   33948900 :     return lvalue_kind (TREE_OPERAND (ref, 0));
      65                 :            : 
      66                 :  319933000 :   if (TREE_TYPE (ref)
      67                 :  319933000 :       && TYPE_REF_P (TREE_TYPE (ref)))
      68                 :            :     {
      69                 :            :       /* unnamed rvalue references are rvalues */
      70                 :   35177200 :       if (TYPE_REF_IS_RVALUE (TREE_TYPE (ref))
      71                 :   12028800 :           && TREE_CODE (ref) != PARM_DECL
      72                 :    9496890 :           && !VAR_P (ref)
      73                 :    9489630 :           && TREE_CODE (ref) != COMPONENT_REF
      74                 :            :           /* Functions are always lvalues.  */
      75                 :   44666500 :           && TREE_CODE (TREE_TYPE (TREE_TYPE (ref))) != FUNCTION_TYPE)
      76                 :    9489220 :         return clk_rvalueref;
      77                 :            : 
      78                 :            :       /* lvalue references and named rvalue references are lvalues.  */
      79                 :            :       return clk_ordinary;
      80                 :            :     }
      81                 :            : 
      82                 :  284756000 :   if (ref == current_class_ptr)
      83                 :            :     return clk_none;
      84                 :            : 
      85                 :            :   /* Expressions with cv void type are prvalues.  */
      86                 :  284667000 :   if (TREE_TYPE (ref) && VOID_TYPE_P (TREE_TYPE (ref)))
      87                 :            :     return clk_none;
      88                 :            : 
      89                 :  284483000 :   switch (TREE_CODE (ref))
      90                 :            :     {
      91                 :            :     case SAVE_EXPR:
      92                 :            :       return clk_none;
      93                 :            : 
      94                 :            :       /* preincrements and predecrements are valid lvals, provided
      95                 :            :          what they refer to are valid lvals.  */
      96                 :   32631000 :     case PREINCREMENT_EXPR:
      97                 :   32631000 :     case PREDECREMENT_EXPR:
      98                 :   32631000 :     case TRY_CATCH_EXPR:
      99                 :   32631000 :     case REALPART_EXPR:
     100                 :   32631000 :     case IMAGPART_EXPR:
     101                 :   32631000 :     case VIEW_CONVERT_EXPR:
     102                 :   32631000 :       return lvalue_kind (TREE_OPERAND (ref, 0));
     103                 :            : 
     104                 :     675312 :     case ARRAY_REF:
     105                 :     675312 :       {
     106                 :     675312 :         tree op1 = TREE_OPERAND (ref, 0);
     107                 :     675312 :         if (TREE_CODE (TREE_TYPE (op1)) == ARRAY_TYPE)
     108                 :            :           {
     109                 :     667641 :             op1_lvalue_kind = lvalue_kind (op1);
     110                 :     667641 :             if (op1_lvalue_kind == clk_class)
     111                 :            :               /* in the case of an array operand, the result is an lvalue if
     112                 :            :                  that operand is an lvalue and an xvalue otherwise */
     113                 :        176 :               op1_lvalue_kind = clk_rvalueref;
     114                 :     667641 :             return op1_lvalue_kind;
     115                 :            :           }
     116                 :            :         else
     117                 :            :           return clk_ordinary;
     118                 :            :       }
     119                 :            : 
     120                 :         16 :     case MEMBER_REF:
     121                 :         16 :     case DOTSTAR_EXPR:
     122                 :         16 :       if (TREE_CODE (ref) == MEMBER_REF)
     123                 :            :         op1_lvalue_kind = clk_ordinary;
     124                 :            :       else
     125                 :          0 :         op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 0));
     126                 :         16 :       if (TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (ref, 1))))
     127                 :            :         op1_lvalue_kind = clk_none;
     128                 :         16 :       else if (op1_lvalue_kind == clk_class)
     129                 :            :         /* The result of a .* expression whose second operand is a pointer to a
     130                 :            :            data member is an lvalue if the first operand is an lvalue and an
     131                 :            :            xvalue otherwise.  */
     132                 :          0 :         op1_lvalue_kind = clk_rvalueref;
     133                 :            :       return op1_lvalue_kind;
     134                 :            : 
     135                 :   14918300 :     case COMPONENT_REF:
     136                 :   14918300 :       if (BASELINK_P (TREE_OPERAND (ref, 1)))
     137                 :            :         {
     138                 :        115 :           tree fn = BASELINK_FUNCTIONS (TREE_OPERAND (ref, 1));
     139                 :            : 
     140                 :            :           /* For static member function recurse on the BASELINK, we can get
     141                 :            :              here e.g. from reference_binding.  If BASELINK_FUNCTIONS is
     142                 :            :              OVERLOAD, the overload is resolved first if possible through
     143                 :            :              resolve_address_of_overloaded_function.  */
     144                 :        115 :           if (TREE_CODE (fn) == FUNCTION_DECL && DECL_STATIC_FUNCTION_P (fn))
     145                 :         36 :             return lvalue_kind (TREE_OPERAND (ref, 1));
     146                 :            :         }
     147                 :   14918200 :       op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 0));
     148                 :   14918200 :       if (op1_lvalue_kind == clk_class)
     149                 :            :         /* If E1 is an lvalue, then E1.E2 is an lvalue;
     150                 :            :            otherwise E1.E2 is an xvalue.  */
     151                 :            :         op1_lvalue_kind = clk_rvalueref;
     152                 :            : 
     153                 :            :       /* Look at the member designator.  */
     154                 :   14907600 :       if (!op1_lvalue_kind)
     155                 :            :         ;
     156                 :   14892900 :       else if (is_overloaded_fn (TREE_OPERAND (ref, 1)))
     157                 :            :         /* The "field" can be a FUNCTION_DECL or an OVERLOAD in some
     158                 :            :            situations.  If we're seeing a COMPONENT_REF, it's a non-static
     159                 :            :            member, so it isn't an lvalue. */
     160                 :            :         op1_lvalue_kind = clk_none;
     161                 :   14892800 :       else if (TREE_CODE (TREE_OPERAND (ref, 1)) != FIELD_DECL)
     162                 :            :         /* This can be IDENTIFIER_NODE in a template.  */;
     163                 :   14790700 :       else if (DECL_C_BIT_FIELD (TREE_OPERAND (ref, 1)))
     164                 :            :         {
     165                 :            :           /* Clear the ordinary bit.  If this object was a class
     166                 :            :              rvalue we want to preserve that information.  */
     167                 :      94170 :           op1_lvalue_kind &= ~clk_ordinary;
     168                 :            :           /* The lvalue is for a bitfield.  */
     169                 :      94170 :           op1_lvalue_kind |= clk_bitfield;
     170                 :            :         }
     171                 :   14696500 :       else if (DECL_PACKED (TREE_OPERAND (ref, 1)))
     172                 :       7429 :         op1_lvalue_kind |= clk_packed;
     173                 :            : 
     174                 :            :       return op1_lvalue_kind;
     175                 :            : 
     176                 :    2076760 :     case STRING_CST:
     177                 :    2076760 :     case COMPOUND_LITERAL_EXPR:
     178                 :    2076760 :       return clk_ordinary;
     179                 :            : 
     180                 :     353178 :     case CONST_DECL:
     181                 :            :       /* CONST_DECL without TREE_STATIC are enumeration values and
     182                 :            :          thus not lvalues.  With TREE_STATIC they are used by ObjC++
     183                 :            :          in objc_build_string_object and need to be considered as
     184                 :            :          lvalues.  */
     185                 :     353178 :       if (! TREE_STATIC (ref))
     186                 :            :         return clk_none;
     187                 :            :       /* FALLTHRU */
     188                 :   22837200 :     case VAR_DECL:
     189                 :   22837200 :       if (VAR_P (ref) && DECL_HAS_VALUE_EXPR_P (ref))
     190                 :      98296 :         return lvalue_kind (DECL_VALUE_EXPR (CONST_CAST_TREE (ref)));
     191                 :            : 
     192                 :   32746400 :       if (TREE_READONLY (ref) && ! TREE_STATIC (ref)
     193                 :    1135340 :           && DECL_LANG_SPECIFIC (ref)
     194                 :   22786600 :           && DECL_IN_AGGR_P (ref))
     195                 :          0 :         return clk_none;
     196                 :            :       /* FALLTHRU */
     197                 :            :     case INDIRECT_REF:
     198                 :            :     case ARROW_EXPR:
     199                 :            :     case PARM_DECL:
     200                 :            :     case RESULT_DECL:
     201                 :            :     case PLACEHOLDER_EXPR:
     202                 :            :       return clk_ordinary;
     203                 :            : 
     204                 :            :       /* A scope ref in a template, left as SCOPE_REF to support later
     205                 :            :          access checking.  */
     206                 :     658177 :     case SCOPE_REF:
     207                 :     658177 :       gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref)));
     208                 :     658177 :       {
     209                 :     658177 :         tree op = TREE_OPERAND (ref, 1);
     210                 :     658177 :         if (TREE_CODE (op) == FIELD_DECL)
     211                 :        124 :           return (DECL_C_BIT_FIELD (op) ? clk_bitfield : clk_ordinary);
     212                 :            :         else
     213                 :            :           return lvalue_kind (op);
     214                 :            :       }
     215                 :            : 
     216                 :          4 :     case MAX_EXPR:
     217                 :          4 :     case MIN_EXPR:
     218                 :            :       /* Disallow <? and >? as lvalues if either argument side-effects.  */
     219                 :          4 :       if (TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 0))
     220                 :          4 :           || TREE_SIDE_EFFECTS (TREE_OPERAND (ref, 1)))
     221                 :            :         return clk_none;
     222                 :          4 :       op1_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 0));
     223                 :          4 :       op2_lvalue_kind = lvalue_kind (TREE_OPERAND (ref, 1));
     224                 :          4 :       break;
     225                 :            : 
     226                 :    1123750 :     case COND_EXPR:
     227                 :    1123750 :       if (processing_template_decl)
     228                 :            :         {
     229                 :            :           /* Within templates, a REFERENCE_TYPE will indicate whether
     230                 :            :              the COND_EXPR result is an ordinary lvalue or rvalueref.
     231                 :            :              Since REFERENCE_TYPEs are handled above, if we reach this
     232                 :            :              point, we know we got a plain rvalue.  Unless we have a
     233                 :            :              type-dependent expr, that is, but we shouldn't be testing
     234                 :            :              lvalueness if we can't even tell the types yet!  */
     235                 :      65642 :           gcc_assert (!type_dependent_expression_p (CONST_CAST_TREE (ref)));
     236                 :      65642 :           goto default_;
     237                 :            :         }
     238                 :    1058110 :       {
     239                 :    1058110 :         tree op1 = TREE_OPERAND (ref, 1);
     240                 :    1058110 :         if (!op1) op1 = TREE_OPERAND (ref, 0);
     241                 :    1058110 :         tree op2 = TREE_OPERAND (ref, 2);
     242                 :    1058110 :         op1_lvalue_kind = lvalue_kind (op1);
     243                 :    1058110 :         op2_lvalue_kind = lvalue_kind (op2);
     244                 :    1058110 :         if (!op1_lvalue_kind != !op2_lvalue_kind)
     245                 :            :           {
     246                 :            :             /* The second or the third operand (but not both) is a
     247                 :            :                throw-expression; the result is of the type
     248                 :            :                and value category of the other.  */
     249                 :      83783 :             if (op1_lvalue_kind && TREE_CODE (op2) == THROW_EXPR)
     250                 :            :               op2_lvalue_kind = op1_lvalue_kind;
     251                 :      83753 :             else if (op2_lvalue_kind && TREE_CODE (op1) == THROW_EXPR)
     252                 :         28 :               op1_lvalue_kind = op2_lvalue_kind;
     253                 :            :           }
     254                 :            :       }
     255                 :            :       break;
     256                 :            : 
     257                 :        162 :     case MODOP_EXPR:
     258                 :            :       /* We expect to see unlowered MODOP_EXPRs only during
     259                 :            :          template processing.  */
     260                 :        162 :       gcc_assert (processing_template_decl);
     261                 :            :       return clk_ordinary;
     262                 :            : 
     263                 :     417049 :     case MODIFY_EXPR:
     264                 :     417049 :     case TYPEID_EXPR:
     265                 :     417049 :       return clk_ordinary;
     266                 :            : 
     267                 :     430934 :     case COMPOUND_EXPR:
     268                 :     430934 :       return lvalue_kind (TREE_OPERAND (ref, 1));
     269                 :            : 
     270                 :   14700000 :     case TARGET_EXPR:
     271                 :   14700000 :       return clk_class;
     272                 :            : 
     273                 :       1372 :     case VA_ARG_EXPR:
     274                 :       1372 :       return (CLASS_TYPE_P (TREE_TYPE (ref)) ? clk_class : clk_none);
     275                 :            : 
     276                 :   13396200 :     case CALL_EXPR:
     277                 :            :       /* We can see calls outside of TARGET_EXPR in templates.  */
     278                 :   13396200 :       if (CLASS_TYPE_P (TREE_TYPE (ref)))
     279                 :    1129630 :         return clk_class;
     280                 :            :       return clk_none;
     281                 :            : 
     282                 :   15898800 :     case FUNCTION_DECL:
     283                 :            :       /* All functions (except non-static-member functions) are
     284                 :            :          lvalues.  */
     285                 :   15898800 :       return (DECL_NONSTATIC_MEMBER_FUNCTION_P (ref)
     286                 :   15898800 :               ? clk_none : clk_ordinary);
     287                 :            : 
     288                 :        130 :     case BASELINK:
     289                 :            :       /* We now represent a reference to a single static member function
     290                 :            :          with a BASELINK.  */
     291                 :            :       /* This CONST_CAST is okay because BASELINK_FUNCTIONS returns
     292                 :            :          its argument unmodified and we assign it to a const_tree.  */
     293                 :        130 :       return lvalue_kind (BASELINK_FUNCTIONS (CONST_CAST_TREE (ref)));
     294                 :            : 
     295                 :    2917880 :     case NON_DEPENDENT_EXPR:
     296                 :    2917880 :     case PAREN_EXPR:
     297                 :    2917880 :       return lvalue_kind (TREE_OPERAND (ref, 0));
     298                 :            : 
     299                 :    1540580 :     case TEMPLATE_PARM_INDEX:
     300                 :    1540580 :       if (CLASS_TYPE_P (TREE_TYPE (ref)))
     301                 :            :         /* A template parameter object is an lvalue.  */
     302                 :         21 :         return clk_ordinary;
     303                 :            :       return clk_none;
     304                 :            : 
     305                 :  118492000 :     default:
     306                 :  118492000 :     default_:
     307                 :  118492000 :       if (!TREE_TYPE (ref))
     308                 :            :         return clk_none;
     309                 :  118492000 :       if (CLASS_TYPE_P (TREE_TYPE (ref))
     310                 :  236790000 :           || TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE)
     311                 :     218213 :         return clk_class;
     312                 :            :       return clk_none;
     313                 :            :     }
     314                 :            : 
     315                 :            :   /* If one operand is not an lvalue at all, then this expression is
     316                 :            :      not an lvalue.  */
     317                 :    1058110 :   if (!op1_lvalue_kind || !op2_lvalue_kind)
     318                 :            :     return clk_none;
     319                 :            : 
     320                 :            :   /* Otherwise, it's an lvalue, and it has all the odd properties
     321                 :            :      contributed by either operand.  */
     322                 :     143719 :   op1_lvalue_kind = op1_lvalue_kind | op2_lvalue_kind;
     323                 :            :   /* It's not an ordinary lvalue if it involves any other kind.  */
     324                 :     143719 :   if ((op1_lvalue_kind & ~clk_ordinary) != clk_none)
     325                 :       1185 :     op1_lvalue_kind &= ~clk_ordinary;
     326                 :            :   /* It can't be both a pseudo-lvalue and a non-addressable lvalue.
     327                 :            :      A COND_EXPR of those should be wrapped in a TARGET_EXPR.  */
     328                 :     143719 :   if ((op1_lvalue_kind & (clk_rvalueref|clk_class))
     329                 :        965 :       && (op1_lvalue_kind & (clk_bitfield|clk_packed)))
     330                 :          0 :     op1_lvalue_kind = clk_none;
     331                 :            :   return op1_lvalue_kind;
     332                 :            : }
     333                 :            : 
     334                 :            : /* Returns the kind of lvalue that REF is, in the sense of [basic.lval].  */
     335                 :            : 
     336                 :            : cp_lvalue_kind
     337                 :   18699400 : real_lvalue_p (const_tree ref)
     338                 :            : {
     339                 :   18699400 :   cp_lvalue_kind kind = lvalue_kind (ref);
     340                 :   18699400 :   if (kind & (clk_rvalueref|clk_class))
     341                 :            :     return clk_none;
     342                 :            :   else
     343                 :   17547800 :     return kind;
     344                 :            : }
     345                 :            : 
     346                 :            : /* c-common wants us to return bool.  */
     347                 :            : 
     348                 :            : bool
     349                 :   18445800 : lvalue_p (const_tree t)
     350                 :            : {
     351                 :   18445800 :   return real_lvalue_p (t);
     352                 :            : }
     353                 :            : 
     354                 :            : /* This differs from lvalue_p in that xvalues are included.  */
     355                 :            : 
     356                 :            : bool
     357                 :   25043500 : glvalue_p (const_tree ref)
     358                 :            : {
     359                 :   25043500 :   cp_lvalue_kind kind = lvalue_kind (ref);
     360                 :   25043500 :   if (kind & clk_class)
     361                 :            :     return false;
     362                 :            :   else
     363                 :   24633200 :     return (kind != clk_none);
     364                 :            : }
     365                 :            : 
     366                 :            : /* This differs from glvalue_p in that class prvalues are included.  */
     367                 :            : 
     368                 :            : bool
     369                 :  136357000 : obvalue_p (const_tree ref)
     370                 :            : {
     371                 :  136357000 :   return (lvalue_kind (ref) != clk_none);
     372                 :            : }
     373                 :            : 
     374                 :            : /* Returns true if REF is an xvalue (the result of dereferencing an rvalue
     375                 :            :    reference), false otherwise.  */
     376                 :            : 
     377                 :            : bool
     378                 :     392861 : xvalue_p (const_tree ref)
     379                 :            : {
     380                 :     392861 :   return (lvalue_kind (ref) == clk_rvalueref);
     381                 :            : }
     382                 :            : 
     383                 :            : /* True if REF is a bit-field.  */
     384                 :            : 
     385                 :            : bool
     386                 :   24459500 : bitfield_p (const_tree ref)
     387                 :            : {
     388                 :   24459500 :   return (lvalue_kind (ref) & clk_bitfield);
     389                 :            : }
     390                 :            : 
     391                 :            : /* C++-specific version of stabilize_reference.  */
     392                 :            : 
     393                 :            : tree
     394                 :     616298 : cp_stabilize_reference (tree ref)
     395                 :            : {
     396                 :     616298 :   STRIP_ANY_LOCATION_WRAPPER (ref);
     397                 :     616298 :   switch (TREE_CODE (ref))
     398                 :            :     {
     399                 :            :     case NON_DEPENDENT_EXPR:
     400                 :            :       /* We aren't actually evaluating this.  */
     401                 :            :       return ref;
     402                 :            : 
     403                 :            :     /* We need to treat specially anything stabilize_reference doesn't
     404                 :            :        handle specifically.  */
     405                 :            :     case VAR_DECL:
     406                 :            :     case PARM_DECL:
     407                 :            :     case RESULT_DECL:
     408                 :            :     CASE_CONVERT:
     409                 :            :     case FLOAT_EXPR:
     410                 :            :     case FIX_TRUNC_EXPR:
     411                 :            :     case INDIRECT_REF:
     412                 :            :     case COMPONENT_REF:
     413                 :            :     case BIT_FIELD_REF:
     414                 :            :     case ARRAY_REF:
     415                 :            :     case ARRAY_RANGE_REF:
     416                 :            :     case ERROR_MARK:
     417                 :            :       break;
     418                 :        179 :     default:
     419                 :        179 :       cp_lvalue_kind kind = lvalue_kind (ref);
     420                 :        179 :       if ((kind & ~clk_class) != clk_none)
     421                 :            :         {
     422                 :        148 :           tree type = unlowered_expr_type (ref);
     423                 :        148 :           bool rval = !!(kind & clk_rvalueref);
     424                 :        148 :           type = cp_build_reference_type (type, rval);
     425                 :            :           /* This inhibits warnings in, eg, cxx_mark_addressable
     426                 :            :              (c++/60955).  */
     427                 :        148 :           warning_sentinel s (extra_warnings);
     428                 :        148 :           ref = build_static_cast (input_location, type, ref,
     429                 :            :                                    tf_error);
     430                 :            :         }
     431                 :            :     }
     432                 :            : 
     433                 :     603442 :   return stabilize_reference (ref);
     434                 :            : }
     435                 :            : 
     436                 :            : /* Test whether DECL is a builtin that may appear in a
     437                 :            :    constant-expression. */
     438                 :            : 
     439                 :            : bool
     440                 :   35156600 : builtin_valid_in_constant_expr_p (const_tree decl)
     441                 :            : {
     442                 :   35156600 :   STRIP_ANY_LOCATION_WRAPPER (decl);
     443                 :   35156600 :   if (TREE_CODE (decl) != FUNCTION_DECL)
     444                 :            :     /* Not a function.  */
     445                 :            :     return false;
     446                 :   19315800 :   if (DECL_BUILT_IN_CLASS (decl) != BUILT_IN_NORMAL)
     447                 :            :     {
     448                 :   16769800 :       if (fndecl_built_in_p (decl, CP_BUILT_IN_IS_CONSTANT_EVALUATED,
     449                 :            :                              BUILT_IN_FRONTEND)
     450                 :   16769800 :           || fndecl_built_in_p (decl, CP_BUILT_IN_SOURCE_LOCATION,
     451                 :            :                                 BUILT_IN_FRONTEND))
     452                 :            :         return true;
     453                 :            :       /* Not a built-in.  */
     454                 :   16733300 :       return false;
     455                 :            :     }
     456                 :    2546060 :   switch (DECL_FUNCTION_CODE (decl))
     457                 :            :     {
     458                 :            :       /* These always have constant results like the corresponding
     459                 :            :          macros/symbol.  */
     460                 :            :     case BUILT_IN_FILE:
     461                 :            :     case BUILT_IN_FUNCTION:
     462                 :            :     case BUILT_IN_LINE:
     463                 :            : 
     464                 :            :       /* The following built-ins are valid in constant expressions
     465                 :            :          when their arguments are.  */
     466                 :            :     case BUILT_IN_ADD_OVERFLOW_P:
     467                 :            :     case BUILT_IN_SUB_OVERFLOW_P:
     468                 :            :     case BUILT_IN_MUL_OVERFLOW_P:
     469                 :            : 
     470                 :            :       /* These have constant results even if their operands are
     471                 :            :          non-constant.  */
     472                 :            :     case BUILT_IN_CONSTANT_P:
     473                 :            :     case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE:
     474                 :            :       return true;
     475                 :    2370000 :     default:
     476                 :    2370000 :       return false;
     477                 :            :     }
     478                 :            : }
     479                 :            : 
     480                 :            : /* Build a TARGET_EXPR, initializing the DECL with the VALUE.  */
     481                 :            : 
     482                 :            : static tree
     483                 :    4066710 : build_target_expr (tree decl, tree value, tsubst_flags_t complain)
     484                 :            : {
     485                 :    4066710 :   tree t;
     486                 :    4066710 :   tree type = TREE_TYPE (decl);
     487                 :            : 
     488                 :    4066710 :   value = mark_rvalue_use (value);
     489                 :            : 
     490                 :    7264890 :   gcc_checking_assert (VOID_TYPE_P (TREE_TYPE (value))
     491                 :            :                        || TREE_TYPE (decl) == TREE_TYPE (value)
     492                 :            :                        /* On ARM ctors return 'this'.  */
     493                 :            :                        || (TYPE_PTR_P (TREE_TYPE (value))
     494                 :            :                            && TREE_CODE (value) == CALL_EXPR)
     495                 :            :                        || useless_type_conversion_p (TREE_TYPE (decl),
     496                 :            :                                                      TREE_TYPE (value)));
     497                 :            : 
     498                 :            :   /* Set TREE_READONLY for optimization, such as gimplify_init_constructor
     499                 :            :      moving a constant aggregate into .rodata.  */
     500                 :    4066710 :   if (CP_TYPE_CONST_NON_VOLATILE_P (type)
     501                 :     124938 :       && !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
     502                 :     108427 :       && !VOID_TYPE_P (TREE_TYPE (value))
     503                 :    4170200 :       && reduced_constant_expression_p (value))
     504                 :      59081 :     TREE_READONLY (decl) = true;
     505                 :            : 
     506                 :    4066710 :   if (complain & tf_no_cleanup)
     507                 :            :     /* The caller is building a new-expr and does not need a cleanup.  */
     508                 :            :     t = NULL_TREE;
     509                 :            :   else
     510                 :            :     {
     511                 :    3973000 :       t = cxx_maybe_build_cleanup (decl, complain);
     512                 :    3973000 :       if (t == error_mark_node)
     513                 :            :         return error_mark_node;
     514                 :            :     }
     515                 :    4066700 :   t = build4 (TARGET_EXPR, type, decl, value, t, NULL_TREE);
     516                 :    4066700 :   if (location_t eloc = cp_expr_location (value))
     517                 :    1163240 :     SET_EXPR_LOCATION (t, eloc);
     518                 :            :   /* We always set TREE_SIDE_EFFECTS so that expand_expr does not
     519                 :            :      ignore the TARGET_EXPR.  If there really turn out to be no
     520                 :            :      side-effects, then the optimizer should be able to get rid of
     521                 :            :      whatever code is generated anyhow.  */
     522                 :    4066700 :   TREE_SIDE_EFFECTS (t) = 1;
     523                 :            : 
     524                 :    4066700 :   return t;
     525                 :            : }
     526                 :            : 
     527                 :            : /* Return an undeclared local temporary of type TYPE for use in building a
     528                 :            :    TARGET_EXPR.  */
     529                 :            : 
     530                 :            : tree
     531                 :    4150980 : build_local_temp (tree type)
     532                 :            : {
     533                 :    4150980 :   tree slot = build_decl (input_location,
     534                 :            :                           VAR_DECL, NULL_TREE, type);
     535                 :    4150980 :   DECL_ARTIFICIAL (slot) = 1;
     536                 :    4150980 :   DECL_IGNORED_P (slot) = 1;
     537                 :    4150980 :   DECL_CONTEXT (slot) = current_function_decl;
     538                 :    4150980 :   layout_decl (slot, 0);
     539                 :    4150980 :   return slot;
     540                 :            : }
     541                 :            : 
     542                 :            : /* Return whether DECL is such a local temporary (or one from
     543                 :            :    create_tmp_var_raw).  */
     544                 :            : 
     545                 :            : bool
     546                 :      18299 : is_local_temp (tree decl)
     547                 :            : {
     548                 :      18299 :   return (VAR_P (decl) && DECL_ARTIFICIAL (decl)
     549                 :        228 :           && !TREE_STATIC (decl)
     550                 :      18520 :           && DECL_FUNCTION_SCOPE_P (decl));
     551                 :            : }
     552                 :            : 
     553                 :            : /* Set various status flags when building an AGGR_INIT_EXPR object T.  */
     554                 :            : 
     555                 :            : static void
     556                 :     912058 : process_aggr_init_operands (tree t)
     557                 :            : {
     558                 :     912058 :   bool side_effects;
     559                 :            : 
     560                 :     912058 :   side_effects = TREE_SIDE_EFFECTS (t);
     561                 :     912058 :   if (!side_effects)
     562                 :            :     {
     563                 :     912058 :       int i, n;
     564                 :     912058 :       n = TREE_OPERAND_LENGTH (t);
     565                 :    3958520 :       for (i = 1; i < n; i++)
     566                 :            :         {
     567                 :    3385990 :           tree op = TREE_OPERAND (t, i);
     568                 :    6771970 :           if (op && TREE_SIDE_EFFECTS (op))
     569                 :            :             {
     570                 :            :               side_effects = 1;
     571                 :            :               break;
     572                 :            :             }
     573                 :            :         }
     574                 :            :     }
     575                 :     912058 :   TREE_SIDE_EFFECTS (t) = side_effects;
     576                 :     912058 : }
     577                 :            : 
     578                 :            : /* Build an AGGR_INIT_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE,
     579                 :            :    FN, and SLOT.  NARGS is the number of call arguments which are specified
     580                 :            :    as a tree array ARGS.  */
     581                 :            : 
     582                 :            : static tree
     583                 :     912058 : build_aggr_init_array (tree return_type, tree fn, tree slot, int nargs,
     584                 :            :                        tree *args)
     585                 :            : {
     586                 :     912058 :   tree t;
     587                 :     912058 :   int i;
     588                 :            : 
     589                 :     912058 :   t = build_vl_exp (AGGR_INIT_EXPR, nargs + 3);
     590                 :     912058 :   TREE_TYPE (t) = return_type;
     591                 :     912058 :   AGGR_INIT_EXPR_FN (t) = fn;
     592                 :     912058 :   AGGR_INIT_EXPR_SLOT (t) = slot;
     593                 :    2536330 :   for (i = 0; i < nargs; i++)
     594                 :    1624270 :     AGGR_INIT_EXPR_ARG (t, i) = args[i];
     595                 :     912058 :   process_aggr_init_operands (t);
     596                 :     912058 :   return t;
     597                 :            : }
     598                 :            : 
     599                 :            : /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
     600                 :            :    target.  TYPE is the type to be initialized.
     601                 :            : 
     602                 :            :    Build an AGGR_INIT_EXPR to represent the initialization.  This function
     603                 :            :    differs from build_cplus_new in that an AGGR_INIT_EXPR can only be used
     604                 :            :    to initialize another object, whereas a TARGET_EXPR can either
     605                 :            :    initialize another object or create its own temporary object, and as a
     606                 :            :    result building up a TARGET_EXPR requires that the type's destructor be
     607                 :            :    callable.  */
     608                 :            : 
     609                 :            : tree
     610                 :    3707130 : build_aggr_init_expr (tree type, tree init)
     611                 :            : {
     612                 :    3707130 :   tree fn;
     613                 :    3707130 :   tree slot;
     614                 :    3707130 :   tree rval;
     615                 :    3707130 :   int is_ctor;
     616                 :            : 
     617                 :    3707130 :   gcc_assert (!VOID_TYPE_P (type));
     618                 :            : 
     619                 :            :   /* Don't build AGGR_INIT_EXPR in a template.  */
     620                 :    3707130 :   if (processing_template_decl)
     621                 :            :     return init;
     622                 :            : 
     623                 :    3706550 :   fn = cp_get_callee (init);
     624                 :    3706550 :   if (fn == NULL_TREE)
     625                 :    2008650 :     return convert (type, init);
     626                 :            : 
     627                 :    3609590 :   is_ctor = (TREE_CODE (fn) == ADDR_EXPR
     628                 :    1683790 :              && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
     629                 :    5065480 :              && DECL_CONSTRUCTOR_P (TREE_OPERAND (fn, 0)));
     630                 :            : 
     631                 :            :   /* We split the CALL_EXPR into its function and its arguments here.
     632                 :            :      Then, in expand_expr, we put them back together.  The reason for
     633                 :            :      this is that this expression might be a default argument
     634                 :            :      expression.  In that case, we need a new temporary every time the
     635                 :            :      expression is used.  That's what break_out_target_exprs does; it
     636                 :            :      replaces every AGGR_INIT_EXPR with a copy that uses a fresh
     637                 :            :      temporary slot.  Then, expand_expr builds up a call-expression
     638                 :            :      using the new slot.  */
     639                 :            : 
     640                 :            :   /* If we don't need to use a constructor to create an object of this
     641                 :            :      type, don't mess with AGGR_INIT_EXPR.  */
     642                 :     999629 :   if (is_ctor || TREE_ADDRESSABLE (type))
     643                 :            :     {
     644                 :     912058 :       slot = build_local_temp (type);
     645                 :            : 
     646                 :     912058 :       if (TREE_CODE (init) == CALL_EXPR)
     647                 :            :         {
     648                 :     848389 :           rval = build_aggr_init_array (void_type_node, fn, slot,
     649                 :     848389 :                                         call_expr_nargs (init),
     650                 :     848389 :                                         CALL_EXPR_ARGP (init));
     651                 :     848389 :           AGGR_INIT_FROM_THUNK_P (rval)
     652                 :     848389 :             = CALL_FROM_THUNK_P (init);
     653                 :            :         }
     654                 :            :       else
     655                 :            :         {
     656                 :     127338 :           rval = build_aggr_init_array (void_type_node, fn, slot,
     657                 :      63669 :                                         aggr_init_expr_nargs (init),
     658                 :      63669 :                                         AGGR_INIT_EXPR_ARGP (init));
     659                 :      63669 :           AGGR_INIT_FROM_THUNK_P (rval)
     660                 :      63669 :             = AGGR_INIT_FROM_THUNK_P (init);
     661                 :            :         }
     662                 :     912058 :       TREE_SIDE_EFFECTS (rval) = 1;
     663                 :     912058 :       AGGR_INIT_VIA_CTOR_P (rval) = is_ctor;
     664                 :     912058 :       TREE_NOTHROW (rval) = TREE_NOTHROW (init);
     665                 :    1887780 :       CALL_EXPR_OPERATOR_SYNTAX (rval) = CALL_EXPR_OPERATOR_SYNTAX (init);
     666                 :    1887780 :       CALL_EXPR_ORDERED_ARGS (rval) = CALL_EXPR_ORDERED_ARGS (init);
     667                 :    1887780 :       CALL_EXPR_REVERSE_ARGS (rval) = CALL_EXPR_REVERSE_ARGS (init);
     668                 :            :     }
     669                 :            :   else
     670                 :            :     rval = init;
     671                 :            : 
     672                 :            :   return rval;
     673                 :            : }
     674                 :            : 
     675                 :            : /* INIT is a CALL_EXPR or AGGR_INIT_EXPR which needs info about its
     676                 :            :    target.  TYPE is the type that this initialization should appear to
     677                 :            :    have.
     678                 :            : 
     679                 :            :    Build an encapsulation of the initialization to perform
     680                 :            :    and return it so that it can be processed by language-independent
     681                 :            :    and language-specific expression expanders.  */
     682                 :            : 
     683                 :            : tree
     684                 :    3493960 : build_cplus_new (tree type, tree init, tsubst_flags_t complain)
     685                 :            : {
     686                 :            :   /* This function should cope with what build_special_member_call
     687                 :            :      can produce.  When performing parenthesized aggregate initialization,
     688                 :            :      it can produce a { }.  */
     689                 :    3494150 :   if (BRACE_ENCLOSED_INITIALIZER_P (init))
     690                 :            :     {
     691                 :         33 :       gcc_assert (cxx_dialect >= cxx2a);
     692                 :         33 :       return finish_compound_literal (type, init, complain);
     693                 :            :     }
     694                 :            : 
     695                 :    3493930 :   tree rval = build_aggr_init_expr (type, init);
     696                 :    3493930 :   tree slot;
     697                 :            : 
     698                 :    3493930 :   if (init == error_mark_node)
     699                 :            :     return error_mark_node;
     700                 :            : 
     701                 :    3487500 :   if (!complete_type_or_maybe_complain (type, init, complain))
     702                 :          6 :     return error_mark_node;
     703                 :            : 
     704                 :            :   /* Make sure that we're not trying to create an instance of an
     705                 :            :      abstract class.  */
     706                 :    3487490 :   if (abstract_virtuals_error_sfinae (NULL_TREE, type, complain))
     707                 :          0 :     return error_mark_node;
     708                 :            : 
     709                 :    3487490 :   if (TREE_CODE (rval) == AGGR_INIT_EXPR)
     710                 :     738301 :     slot = AGGR_INIT_EXPR_SLOT (rval);
     711                 :    2749190 :   else if (TREE_CODE (rval) == CALL_EXPR
     712                 :    1962790 :            || TREE_CODE (rval) == CONSTRUCTOR)
     713                 :     786554 :     slot = build_local_temp (type);
     714                 :            :   else
     715                 :            :     return rval;
     716                 :            : 
     717                 :    1524860 :   rval = build_target_expr (slot, rval, complain);
     718                 :            : 
     719                 :    1524860 :   if (rval != error_mark_node)
     720                 :    1524860 :     TARGET_EXPR_IMPLICIT_P (rval) = 1;
     721                 :            : 
     722                 :            :   return rval;
     723                 :            : }
     724                 :            : 
     725                 :            : /* Subroutine of build_vec_init_expr: Build up a single element
     726                 :            :    intialization as a proxy for the full array initialization to get things
     727                 :            :    marked as used and any appropriate diagnostics.
     728                 :            : 
     729                 :            :    Since we're deferring building the actual constructor calls until
     730                 :            :    gimplification time, we need to build one now and throw it away so
     731                 :            :    that the relevant constructor gets mark_used before cgraph decides
     732                 :            :    what functions are needed.  Here we assume that init is either
     733                 :            :    NULL_TREE, void_type_node (indicating value-initialization), or
     734                 :            :    another array to copy.  */
     735                 :            : 
     736                 :            : static tree
     737                 :        673 : build_vec_init_elt (tree type, tree init, tsubst_flags_t complain)
     738                 :            : {
     739                 :        673 :   tree inner_type = strip_array_types (type);
     740                 :            : 
     741                 :        673 :   if (integer_zerop (array_type_nelts_total (type))
     742                 :       1169 :       || !CLASS_TYPE_P (inner_type))
     743                 :            :     /* No interesting initialization to do.  */
     744                 :        177 :     return integer_zero_node;
     745                 :        496 :   else if (init == void_type_node)
     746                 :         26 :     return build_value_init (inner_type, complain);
     747                 :            : 
     748                 :        514 :   gcc_assert (init == NULL_TREE
     749                 :            :               || (same_type_ignoring_top_level_qualifiers_p
     750                 :            :                   (type, TREE_TYPE (init))));
     751                 :            : 
     752                 :        470 :   releasing_vec argvec;
     753                 :        470 :   if (init)
     754                 :            :     {
     755                 :         44 :       tree init_type = strip_array_types (TREE_TYPE (init));
     756                 :         44 :       tree dummy = build_dummy_object (init_type);
     757                 :         44 :       if (!lvalue_p (init))
     758                 :         14 :         dummy = move (dummy);
     759                 :         44 :       argvec->quick_push (dummy);
     760                 :            :     }
     761                 :        470 :   init = build_special_member_call (NULL_TREE, complete_ctor_identifier,
     762                 :            :                                     &argvec, inner_type, LOOKUP_NORMAL,
     763                 :            :                                     complain);
     764                 :            : 
     765                 :            :   /* For a trivial constructor, build_over_call creates a TARGET_EXPR.  But
     766                 :            :      we don't want one here because we aren't creating a temporary.  */
     767                 :        470 :   if (TREE_CODE (init) == TARGET_EXPR)
     768                 :         18 :     init = TARGET_EXPR_INITIAL (init);
     769                 :            : 
     770                 :        470 :   return init;
     771                 :            : }
     772                 :            : 
     773                 :            : /* Return a TARGET_EXPR which expresses the initialization of an array to
     774                 :            :    be named later, either default-initialization or copy-initialization
     775                 :            :    from another array of the same type.  */
     776                 :            : 
     777                 :            : tree
     778                 :        670 : build_vec_init_expr (tree type, tree init, tsubst_flags_t complain)
     779                 :            : {
     780                 :        670 :   tree slot;
     781                 :        670 :   bool value_init = false;
     782                 :        670 :   tree elt_init = build_vec_init_elt (type, init, complain);
     783                 :            : 
     784                 :        670 :   if (init == void_type_node)
     785                 :            :     {
     786                 :        175 :       value_init = true;
     787                 :        175 :       init = NULL_TREE;
     788                 :            :     }
     789                 :            : 
     790                 :        670 :   slot = build_local_temp (type);
     791                 :        670 :   init = build2 (VEC_INIT_EXPR, type, slot, init);
     792                 :        670 :   TREE_SIDE_EFFECTS (init) = true;
     793                 :        670 :   SET_EXPR_LOCATION (init, input_location);
     794                 :            : 
     795                 :        670 :   if (cxx_dialect >= cxx11
     796                 :        670 :       && potential_constant_expression (elt_init))
     797                 :        261 :     VEC_INIT_EXPR_IS_CONSTEXPR (init) = true;
     798                 :        670 :   VEC_INIT_EXPR_VALUE_INIT (init) = value_init;
     799                 :            : 
     800                 :        670 :   return init;
     801                 :            : }
     802                 :            : 
     803                 :            : /* Give a helpful diagnostic for a non-constexpr VEC_INIT_EXPR in a context
     804                 :            :    that requires a constant expression.  */
     805                 :            : 
     806                 :            : void
     807                 :          3 : diagnose_non_constexpr_vec_init (tree expr)
     808                 :            : {
     809                 :          3 :   tree type = TREE_TYPE (VEC_INIT_EXPR_SLOT (expr));
     810                 :          3 :   tree init, elt_init;
     811                 :          3 :   if (VEC_INIT_EXPR_VALUE_INIT (expr))
     812                 :          3 :     init = void_type_node;
     813                 :            :   else
     814                 :          0 :     init = VEC_INIT_EXPR_INIT (expr);
     815                 :            : 
     816                 :          3 :   elt_init = build_vec_init_elt (type, init, tf_warning_or_error);
     817                 :          3 :   require_potential_constant_expression (elt_init);
     818                 :          3 : }
     819                 :            : 
     820                 :            : tree
     821                 :         22 : build_array_copy (tree init)
     822                 :            : {
     823                 :         22 :   return build_vec_init_expr (TREE_TYPE (init), init, tf_warning_or_error);
     824                 :            : }
     825                 :            : 
     826                 :            : /* Build a TARGET_EXPR using INIT to initialize a new temporary of the
     827                 :            :    indicated TYPE.  */
     828                 :            : 
     829                 :            : tree
     830                 :    1945100 : build_target_expr_with_type (tree init, tree type, tsubst_flags_t complain)
     831                 :            : {
     832                 :    1945100 :   gcc_assert (!VOID_TYPE_P (type));
     833                 :            : 
     834                 :    1945100 :   if (TREE_CODE (init) == TARGET_EXPR
     835                 :    1801920 :       || init == error_mark_node)
     836                 :            :     return init;
     837                 :    1278940 :   else if (CLASS_TYPE_P (type) && type_has_nontrivial_copy_init (type)
     838                 :       3672 :            && !VOID_TYPE_P (TREE_TYPE (init))
     839                 :       3672 :            && TREE_CODE (init) != COND_EXPR
     840                 :       3093 :            && TREE_CODE (init) != CONSTRUCTOR
     841                 :    1801790 :            && TREE_CODE (init) != VA_ARG_EXPR)
     842                 :            :     /* We need to build up a copy constructor call.  A void initializer
     843                 :            :        means we're being called from bot_manip.  COND_EXPR is a special
     844                 :            :        case because we already have copies on the arms and we don't want
     845                 :            :        another one here.  A CONSTRUCTOR is aggregate initialization, which
     846                 :            :        is handled separately.  A VA_ARG_EXPR is magic creation of an
     847                 :            :        aggregate; there's no additional work to be done.  */
     848                 :          0 :     return force_rvalue (init, complain);
     849                 :            : 
     850                 :    1801790 :   return force_target_expr (type, init, complain);
     851                 :            : }
     852                 :            : 
     853                 :            : /* Like the above function, but without the checking.  This function should
     854                 :            :    only be used by code which is deliberately trying to subvert the type
     855                 :            :    system, such as call_builtin_trap.  Or build_over_call, to avoid
     856                 :            :    infinite recursion.  */
     857                 :            : 
     858                 :            : tree
     859                 :    2451630 : force_target_expr (tree type, tree init, tsubst_flags_t complain)
     860                 :            : {
     861                 :    2451630 :   tree slot;
     862                 :            : 
     863                 :    2451630 :   gcc_assert (!VOID_TYPE_P (type));
     864                 :            : 
     865                 :    2451630 :   slot = build_local_temp (type);
     866                 :    2451630 :   return build_target_expr (slot, init, complain);
     867                 :            : }
     868                 :            : 
     869                 :            : /* Like build_target_expr_with_type, but use the type of INIT.  */
     870                 :            : 
     871                 :            : tree
     872                 :    1886550 : get_target_expr_sfinae (tree init, tsubst_flags_t complain)
     873                 :            : {
     874                 :    1886550 :   if (TREE_CODE (init) == AGGR_INIT_EXPR)
     875                 :      90226 :     return build_target_expr (AGGR_INIT_EXPR_SLOT (init), init, complain);
     876                 :    1796320 :   else if (TREE_CODE (init) == VEC_INIT_EXPR)
     877                 :          0 :     return build_target_expr (VEC_INIT_EXPR_SLOT (init), init, complain);
     878                 :            :   else
     879                 :            :     {
     880                 :    1796320 :       init = convert_bitfield_to_declared_type (init);
     881                 :    1796320 :       return build_target_expr_with_type (init, TREE_TYPE (init), complain);
     882                 :            :     }
     883                 :            : }
     884                 :            : 
     885                 :            : tree
     886                 :     454614 : get_target_expr (tree init)
     887                 :            : {
     888                 :     454614 :   return get_target_expr_sfinae (init, tf_warning_or_error);
     889                 :            : }
     890                 :            : 
     891                 :            : /* If EXPR is a bitfield reference, convert it to the declared type of
     892                 :            :    the bitfield, and return the resulting expression.  Otherwise,
     893                 :            :    return EXPR itself.  */
     894                 :            : 
     895                 :            : tree
     896                 :  125938000 : convert_bitfield_to_declared_type (tree expr)
     897                 :            : {
     898                 :  125938000 :   tree bitfield_type;
     899                 :            : 
     900                 :  125938000 :   bitfield_type = is_bitfield_expr_with_lowered_type (expr);
     901                 :  125938000 :   if (bitfield_type)
     902                 :       4467 :     expr = convert_to_integer_nofold (TYPE_MAIN_VARIANT (bitfield_type),
     903                 :            :                                       expr);
     904                 :  125938000 :   return expr;
     905                 :            : }
     906                 :            : 
     907                 :            : /* EXPR is being used in an rvalue context.  Return a version of EXPR
     908                 :            :    that is marked as an rvalue.  */
     909                 :            : 
     910                 :            : tree
     911                 :   26990600 : rvalue (tree expr)
     912                 :            : {
     913                 :   26990600 :   tree type;
     914                 :            : 
     915                 :   53981000 :   if (error_operand_p (expr))
     916                 :            :     return expr;
     917                 :            : 
     918                 :   26990400 :   expr = mark_rvalue_use (expr);
     919                 :            : 
     920                 :            :   /* [basic.lval]
     921                 :            : 
     922                 :            :      Non-class rvalues always have cv-unqualified types.  */
     923                 :   26990400 :   type = TREE_TYPE (expr);
     924                 :   27398700 :   if (!CLASS_TYPE_P (type) && cv_qualified_p (type))
     925                 :    2123720 :     type = cv_unqualified (type);
     926                 :            : 
     927                 :            :   /* We need to do this for rvalue refs as well to get the right answer
     928                 :            :      from decltype; see c++/36628.  */
     929                 :   26990400 :   if (!processing_template_decl && glvalue_p (expr))
     930                 :    3335950 :     expr = build1 (NON_LVALUE_EXPR, type, expr);
     931                 :   23654400 :   else if (type != TREE_TYPE (expr))
     932                 :    2112990 :     expr = build_nop (type, expr);
     933                 :            : 
     934                 :            :   return expr;
     935                 :            : }
     936                 :            : 
     937                 :            : 
     938                 :            : struct cplus_array_info
     939                 :            : {
     940                 :            :   tree type;
     941                 :            :   tree domain;
     942                 :            : };
     943                 :            : 
     944                 :            : struct cplus_array_hasher : ggc_ptr_hash<tree_node>
     945                 :            : {
     946                 :            :   typedef cplus_array_info *compare_type;
     947                 :            : 
     948                 :            :   static hashval_t hash (tree t);
     949                 :            :   static bool equal (tree, cplus_array_info *);
     950                 :            : };
     951                 :            : 
     952                 :            : /* Hash an ARRAY_TYPE.  K is really of type `tree'.  */
     953                 :            : 
     954                 :            : hashval_t
     955                 :    2609170 : cplus_array_hasher::hash (tree t)
     956                 :            : {
     957                 :    2609170 :   hashval_t hash;
     958                 :            : 
     959                 :    2609170 :   hash = TYPE_UID (TREE_TYPE (t));
     960                 :    2609170 :   if (TYPE_DOMAIN (t))
     961                 :    2325700 :     hash ^= TYPE_UID (TYPE_DOMAIN (t));
     962                 :    2609170 :   return hash;
     963                 :            : }
     964                 :            : 
     965                 :            : /* Compare two ARRAY_TYPEs.  K1 is really of type `tree', K2 is really
     966                 :            :    of type `cplus_array_info*'. */
     967                 :            : 
     968                 :            : bool
     969                 :    3401740 : cplus_array_hasher::equal (tree t1, cplus_array_info *t2)
     970                 :            : {
     971                 :    3711660 :   return (TREE_TYPE (t1) == t2->type && TYPE_DOMAIN (t1) == t2->domain);
     972                 :            : }
     973                 :            : 
     974                 :            : /* Hash table containing dependent array types, which are unsuitable for
     975                 :            :    the language-independent type hash table.  */
     976                 :            : static GTY (()) hash_table<cplus_array_hasher> *cplus_array_htab;
     977                 :            : 
     978                 :            : /* Build an ARRAY_TYPE without laying it out.  */
     979                 :            : 
     980                 :            : static tree
     981                 :     693192 : build_min_array_type (tree elt_type, tree index_type)
     982                 :            : {
     983                 :     693192 :   tree t = cxx_make_type (ARRAY_TYPE);
     984                 :     693192 :   TREE_TYPE (t) = elt_type;
     985                 :     693192 :   TYPE_DOMAIN (t) = index_type;
     986                 :     693192 :   return t;
     987                 :            : }
     988                 :            : 
     989                 :            : /* Set TYPE_CANONICAL like build_array_type_1, but using
     990                 :            :    build_cplus_array_type.  */
     991                 :            : 
     992                 :            : static void
     993                 :     693192 : set_array_type_canon (tree t, tree elt_type, tree index_type)
     994                 :            : {
     995                 :            :   /* Set the canonical type for this new node.  */
     996                 :     693192 :   if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
     997                 :    1209700 :       || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type)))
     998                 :     114217 :     SET_TYPE_STRUCTURAL_EQUALITY (t);
     999                 :     578975 :   else if (TYPE_CANONICAL (elt_type) != elt_type
    1000                 :     916093 :            || (index_type && TYPE_CANONICAL (index_type) != index_type))
    1001                 :     246548 :     TYPE_CANONICAL (t)
    1002                 :     194294 :       = build_cplus_array_type (TYPE_CANONICAL (elt_type),
    1003                 :            :                                 index_type
    1004                 :      71020 :                                 ? TYPE_CANONICAL (index_type) : index_type);
    1005                 :            :   else
    1006                 :     455701 :     TYPE_CANONICAL (t) = t;
    1007                 :     693192 : }
    1008                 :            : 
    1009                 :            : /* Like build_array_type, but handle special C++ semantics: an array of a
    1010                 :            :    variant element type is a variant of the array of the main variant of
    1011                 :            :    the element type.  */
    1012                 :            : 
    1013                 :            : tree
    1014                 :    6127980 : build_cplus_array_type (tree elt_type, tree index_type)
    1015                 :            : {
    1016                 :    6127980 :   tree t;
    1017                 :            : 
    1018                 :    6127980 :   if (elt_type == error_mark_node || index_type == error_mark_node)
    1019                 :            :     return error_mark_node;
    1020                 :            : 
    1021                 :    6127980 :   bool dependent = (uses_template_parms (elt_type)
    1022                 :    6127980 :                     || (index_type && uses_template_parms (index_type)));
    1023                 :            : 
    1024                 :    6127980 :   if (elt_type != TYPE_MAIN_VARIANT (elt_type))
    1025                 :            :     /* Start with an array of the TYPE_MAIN_VARIANT.  */
    1026                 :    2489240 :     t = build_cplus_array_type (TYPE_MAIN_VARIANT (elt_type),
    1027                 :            :                                 index_type);
    1028                 :    3638730 :   else if (dependent)
    1029                 :            :     {
    1030                 :            :       /* Since type_hash_canon calls layout_type, we need to use our own
    1031                 :            :          hash table.  */
    1032                 :     472975 :       cplus_array_info cai;
    1033                 :     472975 :       hashval_t hash;
    1034                 :            : 
    1035                 :     472975 :       if (cplus_array_htab == NULL)
    1036                 :       6124 :         cplus_array_htab = hash_table<cplus_array_hasher>::create_ggc (61);
    1037                 :            :       
    1038                 :     472975 :       hash = TYPE_UID (elt_type);
    1039                 :     472975 :       if (index_type)
    1040                 :     240718 :         hash ^= TYPE_UID (index_type);
    1041                 :     472975 :       cai.type = elt_type;
    1042                 :     472975 :       cai.domain = index_type;
    1043                 :            : 
    1044                 :     472975 :       tree *e = cplus_array_htab->find_slot_with_hash (&cai, hash, INSERT); 
    1045                 :     472975 :       if (*e)
    1046                 :            :         /* We have found the type: we're done.  */
    1047                 :     295471 :         return (tree) *e;
    1048                 :            :       else
    1049                 :            :         {
    1050                 :            :           /* Build a new array type.  */
    1051                 :     177504 :           t = build_min_array_type (elt_type, index_type);
    1052                 :            : 
    1053                 :            :           /* Store it in the hash table. */
    1054                 :     177504 :           *e = t;
    1055                 :            : 
    1056                 :            :           /* Set the canonical type for this new node.  */
    1057                 :     177504 :           set_array_type_canon (t, elt_type, index_type);
    1058                 :            :         }
    1059                 :            :     }
    1060                 :            :   else
    1061                 :            :     {
    1062                 :    3165760 :       bool typeless_storage
    1063                 :    3165760 :         = (elt_type == unsigned_char_type_node
    1064                 :    3139250 :            || elt_type == signed_char_type_node
    1065                 :    3137990 :            || elt_type == char_type_node
    1066                 :    4032520 :            || (TREE_CODE (elt_type) == ENUMERAL_TYPE
    1067                 :       2116 :                && TYPE_CONTEXT (elt_type) == std_node
    1068                 :          8 :                && !strcmp ("byte", TYPE_NAME_STRING (elt_type))));
    1069                 :    3165760 :       t = build_array_type (elt_type, index_type, typeless_storage);
    1070                 :            :     }
    1071                 :            : 
    1072                 :            :   /* Now check whether we already have this array variant.  */
    1073                 :    5832500 :   if (elt_type != TYPE_MAIN_VARIANT (elt_type))
    1074                 :            :     {
    1075                 :    5057070 :       tree m = t;
    1076                 :    5057070 :       for (t = m; t; t = TYPE_NEXT_VARIANT (t))
    1077                 :    4541380 :         if (TREE_TYPE (t) == elt_type
    1078                 :    1993210 :             && TYPE_NAME (t) == NULL_TREE
    1079                 :    6514940 :             && TYPE_ATTRIBUTES (t) == NULL_TREE)
    1080                 :            :           break;
    1081                 :    2489240 :       if (!t)
    1082                 :            :         {
    1083                 :     515688 :           t = build_min_array_type (elt_type, index_type);
    1084                 :     515688 :           set_array_type_canon (t, elt_type, index_type);
    1085                 :     515688 :           if (!dependent)
    1086                 :            :             {
    1087                 :     493770 :               layout_type (t);
    1088                 :            :               /* Make sure sizes are shared with the main variant.
    1089                 :            :                  layout_type can't be called after setting TYPE_NEXT_VARIANT,
    1090                 :            :                  as it will overwrite alignment etc. of all variants.  */
    1091                 :     493770 :               TYPE_SIZE (t) = TYPE_SIZE (m);
    1092                 :     493770 :               TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (m);
    1093                 :     493770 :               TYPE_TYPELESS_STORAGE (t) = TYPE_TYPELESS_STORAGE (m);
    1094                 :            :             }
    1095                 :            : 
    1096                 :     515688 :           TYPE_MAIN_VARIANT (t) = m;
    1097                 :     515688 :           TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
    1098                 :     515688 :           TYPE_NEXT_VARIANT (m) = t;
    1099                 :            :         }
    1100                 :            :     }
    1101                 :            : 
    1102                 :            :   /* Avoid spurious warnings with VLAs (c++/54583).  */
    1103                 :    5832500 :   if (TYPE_SIZE (t) && EXPR_P (TYPE_SIZE (t)))
    1104                 :       1714 :     TREE_NO_WARNING (TYPE_SIZE (t)) = 1;
    1105                 :            : 
    1106                 :            :   /* Push these needs up to the ARRAY_TYPE so that initialization takes
    1107                 :            :      place more easily.  */
    1108                 :    5832500 :   bool needs_ctor = (TYPE_NEEDS_CONSTRUCTING (t)
    1109                 :    5832500 :                      = TYPE_NEEDS_CONSTRUCTING (elt_type));
    1110                 :    5832500 :   bool needs_dtor = (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
    1111                 :    5832500 :                      = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type));
    1112                 :            : 
    1113                 :    5625110 :   if (!dependent && t == TYPE_MAIN_VARIANT (t)
    1114                 :    9495800 :       && !COMPLETE_TYPE_P (t) && COMPLETE_TYPE_P (elt_type))
    1115                 :            :     {
    1116                 :            :       /* The element type has been completed since the last time we saw
    1117                 :            :          this array type; update the layout and 'tor flags for any variants
    1118                 :            :          that need it.  */
    1119                 :     495087 :       layout_type (t);
    1120                 :     791963 :       for (tree v = TYPE_NEXT_VARIANT (t); v; v = TYPE_NEXT_VARIANT (v))
    1121                 :            :         {
    1122                 :     296876 :           TYPE_NEEDS_CONSTRUCTING (v) = needs_ctor;
    1123                 :     296876 :           TYPE_HAS_NONTRIVIAL_DESTRUCTOR (v) = needs_dtor;
    1124                 :            :         }
    1125                 :            :     }
    1126                 :            : 
    1127                 :            :   return t;
    1128                 :            : }
    1129                 :            : 
    1130                 :            : /* Return an ARRAY_TYPE with element type ELT and length N.  */
    1131                 :            : 
    1132                 :            : tree
    1133                 :     213109 : build_array_of_n_type (tree elt, int n)
    1134                 :            : {
    1135                 :     213109 :   return build_cplus_array_type (elt, build_index_type (size_int (n - 1)));
    1136                 :            : }
    1137                 :            : 
    1138                 :            : /* True iff T is an array of unknown bound.  */
    1139                 :            : 
    1140                 :            : bool
    1141                 :    1340420 : array_of_unknown_bound_p (const_tree t)
    1142                 :            : {
    1143                 :    1340420 :   return (TREE_CODE (t) == ARRAY_TYPE
    1144                 :    1340420 :           && !TYPE_DOMAIN (t));
    1145                 :            : }
    1146                 :            : 
    1147                 :            : /* True iff T is an N3639 array of runtime bound (VLA).  These were approved
    1148                 :            :    for C++14 but then removed.  This should only be used for N3639
    1149                 :            :    specifically; code wondering more generally if something is a VLA should use
    1150                 :            :    vla_type_p.  */
    1151                 :            : 
    1152                 :            : bool
    1153                 :      27329 : array_of_runtime_bound_p (tree t)
    1154                 :            : {
    1155                 :      27329 :   if (!t || TREE_CODE (t) != ARRAY_TYPE)
    1156                 :            :     return false;
    1157                 :        191 :   if (variably_modified_type_p (TREE_TYPE (t), NULL_TREE))
    1158                 :            :     return false;
    1159                 :        179 :   tree dom = TYPE_DOMAIN (t);
    1160                 :        179 :   if (!dom)
    1161                 :            :     return false;
    1162                 :        176 :   tree max = TYPE_MAX_VALUE (dom);
    1163                 :        176 :   return (!potential_rvalue_constant_expression (max)
    1164                 :        316 :           || (!value_dependent_expression_p (max) && !TREE_CONSTANT (max)));
    1165                 :            : }
    1166                 :            : 
    1167                 :            : /* True iff T is a variable length array.  */
    1168                 :            : 
    1169                 :            : bool
    1170                 :    2617920 : vla_type_p (tree t)
    1171                 :            : {
    1172                 :    3097460 :   for (; t && TREE_CODE (t) == ARRAY_TYPE;
    1173                 :     239770 :        t = TREE_TYPE (t))
    1174                 :     239956 :     if (tree dom = TYPE_DOMAIN (t))
    1175                 :            :       {
    1176                 :     239914 :         tree max = TYPE_MAX_VALUE (dom);
    1177                 :     239914 :         if (!potential_rvalue_constant_expression (max)
    1178                 :     479725 :             || (!value_dependent_expression_p (max) && !TREE_CONSTANT (max)))
    1179                 :        186 :           return true;
    1180                 :            :       }
    1181                 :            :   return false;
    1182                 :            : }
    1183                 :            : 
    1184                 :            : /* Return a reference type node referring to TO_TYPE.  If RVAL is
    1185                 :            :    true, return an rvalue reference type, otherwise return an lvalue
    1186                 :            :    reference type.  If a type node exists, reuse it, otherwise create
    1187                 :            :    a new one.  */
    1188                 :            : tree
    1189                 :   70753200 : cp_build_reference_type (tree to_type, bool rval)
    1190                 :            : {
    1191                 :   70753200 :   tree lvalue_ref, t;
    1192                 :            : 
    1193                 :   70753200 :   if (to_type == error_mark_node)
    1194                 :            :     return error_mark_node;
    1195                 :            : 
    1196                 :   70753200 :   if (TYPE_REF_P (to_type))
    1197                 :            :     {
    1198                 :          4 :       rval = rval && TYPE_REF_IS_RVALUE (to_type);
    1199                 :          4 :       to_type = TREE_TYPE (to_type);
    1200                 :            :     }
    1201                 :            : 
    1202                 :   70753200 :   lvalue_ref = build_reference_type (to_type);
    1203                 :   70753200 :   if (!rval)
    1204                 :            :     return lvalue_ref;
    1205                 :            : 
    1206                 :            :   /* This code to create rvalue reference types is based on and tied
    1207                 :            :      to the code creating lvalue reference types in the middle-end
    1208                 :            :      functions build_reference_type_for_mode and build_reference_type.
    1209                 :            : 
    1210                 :            :      It works by putting the rvalue reference type nodes after the
    1211                 :            :      lvalue reference nodes in the TYPE_NEXT_REF_TO linked list, so
    1212                 :            :      they will effectively be ignored by the middle end.  */
    1213                 :            : 
    1214                 :   13190800 :   for (t = lvalue_ref; (t = TYPE_NEXT_REF_TO (t)); )
    1215                 :   10618600 :     if (TYPE_REF_IS_RVALUE (t))
    1216                 :   10618600 :       return t;
    1217                 :            : 
    1218                 :    2572170 :   t = build_distinct_type_copy (lvalue_ref);
    1219                 :            : 
    1220                 :    2572170 :   TYPE_REF_IS_RVALUE (t) = true;
    1221                 :    2572170 :   TYPE_NEXT_REF_TO (t) = TYPE_NEXT_REF_TO (lvalue_ref);
    1222                 :    2572170 :   TYPE_NEXT_REF_TO (lvalue_ref) = t;
    1223                 :            : 
    1224                 :    2572170 :   if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
    1225                 :     128541 :     SET_TYPE_STRUCTURAL_EQUALITY (t);
    1226                 :    2443630 :   else if (TYPE_CANONICAL (to_type) != to_type)
    1227                 :    2431740 :     TYPE_CANONICAL (t) 
    1228                 :    1215870 :       = cp_build_reference_type (TYPE_CANONICAL (to_type), rval);
    1229                 :            :   else
    1230                 :    1227760 :     TYPE_CANONICAL (t) = t;
    1231                 :            : 
    1232                 :    2572170 :   layout_type (t);
    1233                 :            : 
    1234                 :    2572170 :   return t;
    1235                 :            : 
    1236                 :            : }
    1237                 :            : 
    1238                 :            : /* Returns EXPR cast to rvalue reference type, like std::move.  */
    1239                 :            : 
    1240                 :            : tree
    1241                 :     316329 : move (tree expr)
    1242                 :            : {
    1243                 :     316329 :   tree type = TREE_TYPE (expr);
    1244                 :     316329 :   gcc_assert (!TYPE_REF_P (type));
    1245                 :     316329 :   type = cp_build_reference_type (type, /*rval*/true);
    1246                 :     316329 :   return build_static_cast (input_location, type, expr,
    1247                 :     316329 :                             tf_warning_or_error);
    1248                 :            : }
    1249                 :            : 
    1250                 :            : /* Used by the C++ front end to build qualified array types.  However,
    1251                 :            :    the C version of this function does not properly maintain canonical
    1252                 :            :    types (which are not used in C).  */
    1253                 :            : tree
    1254                 :    2370200 : c_build_qualified_type (tree type, int type_quals, tree /* orig_qual_type */,
    1255                 :            :                         size_t /* orig_qual_indirect */)
    1256                 :            : {
    1257                 :    2370200 :   return cp_build_qualified_type (type, type_quals);
    1258                 :            : }
    1259                 :            : 
    1260                 :            : 
    1261                 :            : /* Make a variant of TYPE, qualified with the TYPE_QUALS.  Handles
    1262                 :            :    arrays correctly.  In particular, if TYPE is an array of T's, and
    1263                 :            :    TYPE_QUALS is non-empty, returns an array of qualified T's.
    1264                 :            : 
    1265                 :            :    FLAGS determines how to deal with ill-formed qualifications. If
    1266                 :            :    tf_ignore_bad_quals is set, then bad qualifications are dropped
    1267                 :            :    (this is permitted if TYPE was introduced via a typedef or template
    1268                 :            :    type parameter). If bad qualifications are dropped and tf_warning
    1269                 :            :    is set, then a warning is issued for non-const qualifications.  If
    1270                 :            :    tf_ignore_bad_quals is not set and tf_error is not set, we
    1271                 :            :    return error_mark_node. Otherwise, we issue an error, and ignore
    1272                 :            :    the qualifications.
    1273                 :            : 
    1274                 :            :    Qualification of a reference type is valid when the reference came
    1275                 :            :    via a typedef or template type argument. [dcl.ref] No such
    1276                 :            :    dispensation is provided for qualifying a function type.  [dcl.fct]
    1277                 :            :    DR 295 queries this and the proposed resolution brings it into line
    1278                 :            :    with qualifying a reference.  We implement the DR.  We also behave
    1279                 :            :    in a similar manner for restricting non-pointer types.  */
    1280                 :            : 
    1281                 :            : tree
    1282                 : 1847990000 : cp_build_qualified_type_real (tree type,
    1283                 :            :                               int type_quals,
    1284                 :            :                               tsubst_flags_t complain)
    1285                 :            : {
    1286                 : 1847990000 :   tree result;
    1287                 : 1847990000 :   int bad_quals = TYPE_UNQUALIFIED;
    1288                 :            : 
    1289                 : 1847990000 :   if (type == error_mark_node)
    1290                 :            :     return type;
    1291                 :            : 
    1292                 : 1847690000 :   if (type_quals == cp_type_quals (type))
    1293                 :            :     return type;
    1294                 :            : 
    1295                 :  208317000 :   if (TREE_CODE (type) == ARRAY_TYPE)
    1296                 :            :     {
    1297                 :            :       /* In C++, the qualification really applies to the array element
    1298                 :            :          type.  Obtain the appropriately qualified element type.  */
    1299                 :    3272560 :       tree t;
    1300                 :    3272560 :       tree element_type
    1301                 :    3272560 :         = cp_build_qualified_type_real (TREE_TYPE (type),
    1302                 :            :                                         type_quals,
    1303                 :            :                                         complain);
    1304                 :            : 
    1305                 :    3272560 :       if (element_type == error_mark_node)
    1306                 :            :         return error_mark_node;
    1307                 :            : 
    1308                 :            :       /* See if we already have an identically qualified type.  Tests
    1309                 :            :          should be equivalent to those in check_qualified_type.  */
    1310                 :    5706180 :       for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
    1311                 :    3601060 :         if (TREE_TYPE (t) == element_type
    1312                 :    1180070 :             && TYPE_NAME (t) == TYPE_NAME (type)
    1313                 :    1167440 :             && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
    1314                 :    4768490 :             && attribute_list_equal (TYPE_ATTRIBUTES (t),
    1315                 :    1167440 :                                      TYPE_ATTRIBUTES (type)))
    1316                 :            :           break;
    1317                 :            : 
    1318                 :    3272560 :       if (!t)
    1319                 :            :         {
    1320                 :    2105120 :           t = build_cplus_array_type (element_type, TYPE_DOMAIN (type));
    1321                 :            : 
    1322                 :            :           /* Keep the typedef name.  */
    1323                 :    2105120 :           if (TYPE_NAME (t) != TYPE_NAME (type))
    1324                 :            :             {
    1325                 :       1932 :               t = build_variant_type_copy (t);
    1326                 :       1932 :               TYPE_NAME (t) = TYPE_NAME (type);
    1327                 :       1932 :               SET_TYPE_ALIGN (t, TYPE_ALIGN (type));
    1328                 :       1932 :               TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (type);
    1329                 :            :             }
    1330                 :            :         }
    1331                 :            : 
    1332                 :            :       /* Even if we already had this variant, we update
    1333                 :            :          TYPE_NEEDS_CONSTRUCTING and TYPE_HAS_NONTRIVIAL_DESTRUCTOR in case
    1334                 :            :          they changed since the variant was originally created.
    1335                 :            : 
    1336                 :            :          This seems hokey; if there is some way to use a previous
    1337                 :            :          variant *without* coming through here,
    1338                 :            :          TYPE_NEEDS_CONSTRUCTING will never be updated.  */
    1339                 :    3272560 :       TYPE_NEEDS_CONSTRUCTING (t)
    1340                 :    3272560 :         = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (element_type));
    1341                 :    3272560 :       TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
    1342                 :    3272560 :         = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (element_type));
    1343                 :    3272560 :       return t;
    1344                 :            :     }
    1345                 :  205045000 :   else if (TREE_CODE (type) == TYPE_PACK_EXPANSION)
    1346                 :            :     {
    1347                 :          3 :       tree t = PACK_EXPANSION_PATTERN (type);
    1348                 :            : 
    1349                 :          3 :       t = cp_build_qualified_type_real (t, type_quals, complain);
    1350                 :          3 :       return make_pack_expansion (t, complain);
    1351                 :            :     }
    1352                 :            : 
    1353                 :            :   /* A reference or method type shall not be cv-qualified.
    1354                 :            :      [dcl.ref], [dcl.fct].  This used to be an error, but as of DR 295
    1355                 :            :      (in CD1) we always ignore extra cv-quals on functions.  */
    1356                 :  205045000 :   if (type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE)
    1357                 :   79636500 :       && (TYPE_REF_P (type)
    1358                 :   79587800 :           || FUNC_OR_METHOD_TYPE_P (type)))
    1359                 :            :     {
    1360                 :      62160 :       if (TYPE_REF_P (type))
    1361                 :      48708 :         bad_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
    1362                 :      62160 :       type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
    1363                 :            :     }
    1364                 :            : 
    1365                 :            :   /* But preserve any function-cv-quals on a FUNCTION_TYPE.  */
    1366                 :  205045000 :   if (TREE_CODE (type) == FUNCTION_TYPE)
    1367                 :      13456 :     type_quals |= type_memfn_quals (type);
    1368                 :            : 
    1369                 :            :   /* A restrict-qualified type must be a pointer (or reference)
    1370                 :            :      to object or incomplete type. */
    1371                 :  205045000 :   if ((type_quals & TYPE_QUAL_RESTRICT)
    1372                 :    1665020 :       && TREE_CODE (type) != TEMPLATE_TYPE_PARM
    1373                 :    1665020 :       && TREE_CODE (type) != TYPENAME_TYPE
    1374                 :    1665010 :       && !INDIRECT_TYPE_P (type))
    1375                 :            :     {
    1376                 :          9 :       bad_quals |= TYPE_QUAL_RESTRICT;
    1377                 :          9 :       type_quals &= ~TYPE_QUAL_RESTRICT;
    1378                 :            :     }
    1379                 :            : 
    1380                 :  205045000 :   if (bad_quals == TYPE_UNQUALIFIED
    1381                 :      48717 :       || (complain & tf_ignore_bad_quals))
    1382                 :            :     /*OK*/;
    1383                 :         16 :   else if (!(complain & tf_error))
    1384                 :          0 :     return error_mark_node;
    1385                 :            :   else
    1386                 :            :     {
    1387                 :         16 :       tree bad_type = build_qualified_type (ptr_type_node, bad_quals);
    1388                 :         16 :       error ("%qV qualifiers cannot be applied to %qT",
    1389                 :            :              bad_type, type);
    1390                 :            :     }
    1391                 :            : 
    1392                 :            :   /* Retrieve (or create) the appropriately qualified variant.  */
    1393                 :  205045000 :   result = build_qualified_type (type, type_quals);
    1394                 :            : 
    1395                 :  205045000 :   return result;
    1396                 :            : }
    1397                 :            : 
    1398                 :            : /* Return TYPE with const and volatile removed.  */
    1399                 :            : 
    1400                 :            : tree
    1401                 :  136151000 : cv_unqualified (tree type)
    1402                 :            : {
    1403                 :  136151000 :   int quals;
    1404                 :            : 
    1405                 :  136151000 :   if (type == error_mark_node)
    1406                 :            :     return type;
    1407                 :            : 
    1408                 :  136151000 :   quals = cp_type_quals (type);
    1409                 :  136151000 :   quals &= ~(TYPE_QUAL_CONST|TYPE_QUAL_VOLATILE);
    1410                 :  136151000 :   return cp_build_qualified_type (type, quals);
    1411                 :            : }
    1412                 :            : 
    1413                 :            : /* Subroutine of strip_typedefs.  We want to apply to RESULT the attributes
    1414                 :            :    from ATTRIBS that affect type identity, and no others.  If any are not
    1415                 :            :    applied, set *remove_attributes to true.  */
    1416                 :            : 
    1417                 :            : static tree
    1418                 :    1067400 : apply_identity_attributes (tree result, tree attribs, bool *remove_attributes)
    1419                 :            : {
    1420                 :    1067400 :   tree first_ident = NULL_TREE;
    1421                 :    1067400 :   tree new_attribs = NULL_TREE;
    1422                 :    1067400 :   tree *p = &new_attribs;
    1423                 :            : 
    1424                 :    2133230 :   if (OVERLOAD_TYPE_P (result))
    1425                 :            :     {
    1426                 :            :       /* On classes and enums all attributes are ingrained.  */
    1427                 :    1065830 :       gcc_assert (attribs == TYPE_ATTRIBUTES (result));
    1428                 :            :       return result;
    1429                 :            :     }
    1430                 :            : 
    1431                 :       3145 :   for (tree a = attribs; a; a = TREE_CHAIN (a))
    1432                 :            :     {
    1433                 :       1574 :       const attribute_spec *as
    1434                 :       1574 :         = lookup_attribute_spec (get_attribute_name (a));
    1435                 :       1574 :       if (as && as->affects_type_identity)
    1436                 :            :         {
    1437                 :       1492 :           if (!first_ident)
    1438                 :            :             first_ident = a;
    1439                 :          0 :           else if (first_ident == error_mark_node)
    1440                 :            :             {
    1441                 :          0 :               *p = tree_cons (TREE_PURPOSE (a), TREE_VALUE (a), NULL_TREE);
    1442                 :          0 :               p = &TREE_CHAIN (*p);
    1443                 :            :             }
    1444                 :            :         }
    1445                 :         82 :       else if (first_ident)
    1446                 :            :         {
    1447                 :          0 :           for (tree a2 = first_ident; a2; a2 = TREE_CHAIN (a2))
    1448                 :            :             {
    1449                 :          0 :               *p = tree_cons (TREE_PURPOSE (a2), TREE_VALUE (a2), NULL_TREE);
    1450                 :          0 :               p = &TREE_CHAIN (*p);
    1451                 :            :             }
    1452                 :          0 :           first_ident = error_mark_node;
    1453                 :            :         }
    1454                 :            :     }
    1455                 :       1571 :   if (first_ident != error_mark_node)
    1456                 :       1571 :     new_attribs = first_ident;
    1457                 :            : 
    1458                 :       1571 :   if (first_ident == attribs)
    1459                 :            :     /* All attributes affected type identity.  */;
    1460                 :            :   else
    1461                 :         79 :     *remove_attributes = true;
    1462                 :            : 
    1463                 :       1571 :   return cp_build_type_attribute_variant (result, new_attribs);
    1464                 :            : }
    1465                 :            : 
    1466                 :            : /* Builds a qualified variant of T that is either not a typedef variant
    1467                 :            :    (the default behavior) or not a typedef variant of a user-facing type
    1468                 :            :    (if FLAGS contains STF_USER_FACING).
    1469                 :            : 
    1470                 :            :    E.g. consider the following declarations:
    1471                 :            :      typedef const int ConstInt;
    1472                 :            :      typedef ConstInt* PtrConstInt;
    1473                 :            :    If T is PtrConstInt, this function returns a type representing
    1474                 :            :      const int*.
    1475                 :            :    In other words, if T is a typedef, the function returns the underlying type.
    1476                 :            :    The cv-qualification and attributes of the type returned match the
    1477                 :            :    input type.
    1478                 :            :    They will always be compatible types.
    1479                 :            :    The returned type is built so that all of its subtypes
    1480                 :            :    recursively have their typedefs stripped as well.
    1481                 :            : 
    1482                 :            :    This is different from just returning TYPE_CANONICAL (T)
    1483                 :            :    Because of several reasons:
    1484                 :            :     * If T is a type that needs structural equality
    1485                 :            :       its TYPE_CANONICAL (T) will be NULL.
    1486                 :            :     * TYPE_CANONICAL (T) desn't carry type attributes
    1487                 :            :       and loses template parameter names.
    1488                 :            : 
    1489                 :            :    If REMOVE_ATTRIBUTES is non-null, also strip attributes that don't
    1490                 :            :    affect type identity, and set the referent to true if any were
    1491                 :            :    stripped.  */
    1492                 :            : 
    1493                 :            : tree
    1494                 :  368502000 : strip_typedefs (tree t, bool *remove_attributes, unsigned int flags)
    1495                 :            : {
    1496                 :  368502000 :   tree result = NULL, type = NULL, t0 = NULL;
    1497                 :            : 
    1498                 :  368502000 :   if (!t || t == error_mark_node)
    1499                 :            :     return t;
    1500                 :            : 
    1501                 :  368179000 :   if (TREE_CODE (t) == TREE_LIST)
    1502                 :            :     {
    1503                 :      60019 :       bool changed = false;
    1504                 :     120038 :       releasing_vec vec;
    1505                 :      60019 :       tree r = t;
    1506                 :     120038 :       for (; t; t = TREE_CHAIN (t))
    1507                 :            :         {
    1508                 :      60019 :           gcc_assert (!TREE_PURPOSE (t));
    1509                 :      60019 :           tree elt = strip_typedefs (TREE_VALUE (t), remove_attributes, flags);
    1510                 :      60019 :           if (elt != TREE_VALUE (t))
    1511                 :          0 :             changed = true;
    1512                 :      60019 :           vec_safe_push (vec, elt);
    1513                 :            :         }
    1514                 :      60019 :       if (changed)
    1515                 :          0 :         r = build_tree_list_vec (vec);
    1516                 :      60019 :       return r;
    1517                 :            :     }
    1518                 :            : 
    1519                 :  368119000 :   gcc_assert (TYPE_P (t));
    1520                 :            : 
    1521                 :  368119000 :   if (t == TYPE_CANONICAL (t))
    1522                 :            :     return t;
    1523                 :            : 
    1524                 :   95984300 :   if (!(flags & STF_STRIP_DEPENDENT)
    1525                 :   95984300 :       && dependent_alias_template_spec_p (t, nt_opaque))
    1526                 :            :     /* DR 1558: However, if the template-id is dependent, subsequent
    1527                 :            :        template argument substitution still applies to the template-id.  */
    1528                 :            :     return t;
    1529                 :            : 
    1530                 :   94994200 :   switch (TREE_CODE (t))
    1531                 :            :     {
    1532                 :    6886910 :     case POINTER_TYPE:
    1533                 :    6886910 :       type = strip_typedefs (TREE_TYPE (t), remove_attributes, flags);
    1534                 :    6886910 :       result = build_pointer_type (type);
    1535                 :    6886910 :       break;
    1536                 :   14663500 :     case REFERENCE_TYPE:
    1537                 :   14663500 :       type = strip_typedefs (TREE_TYPE (t), remove_attributes, flags);
    1538                 :   14663500 :       result = cp_build_reference_type (type, TYPE_REF_IS_RVALUE (t));
    1539                 :   14663500 :       break;
    1540                 :     110005 :     case OFFSET_TYPE:
    1541                 :     110005 :       t0 = strip_typedefs (TYPE_OFFSET_BASETYPE (t), remove_attributes, flags);
    1542                 :     110005 :       type = strip_typedefs (TREE_TYPE (t), remove_attributes, flags);
    1543                 :     110005 :       result = build_offset_type (t0, type);
    1544                 :     110005 :       break;
    1545                 :   19671700 :     case RECORD_TYPE:
    1546                 :   19671700 :       if (TYPE_PTRMEMFUNC_P (t))
    1547                 :            :         {
    1548                 :     237855 :           t0 = strip_typedefs (TYPE_PTRMEMFUNC_FN_TYPE (t),
    1549                 :            :                                remove_attributes, flags);
    1550                 :     237855 :           result = build_ptrmemfunc_type (t0);
    1551                 :            :         }
    1552                 :            :       break;
    1553                 :     251041 :     case ARRAY_TYPE:
    1554                 :     251041 :       type = strip_typedefs (TREE_TYPE (t), remove_attributes, flags);
    1555                 :     251041 :       t0  = strip_typedefs (TYPE_DOMAIN (t), remove_attributes, flags);
    1556                 :     251041 :       result = build_cplus_array_type (type, t0);
    1557                 :     251041 :       break;
    1558                 :     567688 :     case FUNCTION_TYPE:
    1559                 :     567688 :     case METHOD_TYPE:
    1560                 :     567688 :       {
    1561                 :     567688 :         tree arg_types = NULL, arg_node, arg_node2, arg_type;
    1562                 :     567688 :         bool changed;
    1563                 :            : 
    1564                 :            :         /* Because we stomp on TREE_PURPOSE of TYPE_ARG_TYPES in many places
    1565                 :            :            around the compiler (e.g. cp_parser_late_parsing_default_args), we
    1566                 :            :            can't expect that re-hashing a function type will find a previous
    1567                 :            :            equivalent type, so try to reuse the input type if nothing has
    1568                 :            :            changed.  If the type is itself a variant, that will change.  */
    1569                 :     567688 :         bool is_variant = typedef_variant_p (t);
    1570                 :     567688 :         if (remove_attributes
    1571                 :    1134410 :             && (TYPE_ATTRIBUTES (t) || TYPE_USER_ALIGN (t)))
    1572                 :            :           is_variant = true;
    1573                 :            : 
    1574                 :     567688 :         type = strip_typedefs (TREE_TYPE (t), remove_attributes, flags);
    1575                 :     567688 :         tree canon_spec = (flag_noexcept_type
    1576                 :    1010260 :                            ? canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (t))
    1577                 :     567688 :                            : NULL_TREE);
    1578                 :     873659 :         changed = (type != TREE_TYPE (t) || is_variant
    1579                 :     869835 :                    || TYPE_RAISES_EXCEPTIONS (t) != canon_spec);
    1580                 :            : 
    1581                 :    1148710 :         for (arg_node = TYPE_ARG_TYPES (t);
    1582                 :    1013420 :              arg_node;
    1583                 :     445737 :              arg_node = TREE_CHAIN (arg_node))
    1584                 :            :           {
    1585                 :     939459 :             if (arg_node == void_list_node)
    1586                 :            :               break;
    1587                 :     445737 :             arg_type = strip_typedefs (TREE_VALUE (arg_node),
    1588                 :            :                                        remove_attributes, flags);
    1589                 :     445737 :             gcc_assert (arg_type);
    1590                 :     445737 :             if (arg_type == TREE_VALUE (arg_node) && !changed)
    1591                 :     430828 :               continue;
    1592                 :            : 
    1593                 :      14909 :             if (!changed)
    1594                 :            :               {
    1595                 :       2591 :                 changed = true;
    1596                 :       3457 :                 for (arg_node2 = TYPE_ARG_TYPES (t);
    1597                 :       2795 :                      arg_node2 != arg_node;
    1598                 :        204 :                      arg_node2 = TREE_CHAIN (arg_node2))
    1599                 :        204 :                   arg_types
    1600                 :        204 :                     = tree_cons (TREE_PURPOSE (arg_node2),
    1601                 :        204 :                                  TREE_VALUE (arg_node2), arg_types);
    1602                 :            :               }
    1603                 :            : 
    1604                 :      14909 :             arg_types
    1605                 :      14909 :               = tree_cons (TREE_PURPOSE (arg_node), arg_type, arg_types);
    1606                 :            :           }
    1607                 :            : 
    1608                 :     567688 :         if (!changed)
    1609                 :            :           return t;
    1610                 :            : 
    1611                 :     268223 :         if (arg_types)
    1612                 :       7834 :           arg_types = nreverse (arg_types);
    1613                 :            : 
    1614                 :            :         /* A list of parameters not ending with an ellipsis
    1615                 :            :            must end with void_list_node.  */
    1616                 :     268223 :         if (arg_node)
    1617                 :     268095 :           arg_types = chainon (arg_types, void_list_node);
    1618                 :            : 
    1619                 :     268223 :         if (TREE_CODE (t) == METHOD_TYPE)
    1620                 :            :           {
    1621                 :        965 :             tree class_type = TREE_TYPE (TREE_VALUE (arg_types));
    1622                 :        965 :             gcc_assert (class_type);
    1623                 :        965 :             result =
    1624                 :        965 :               build_method_type_directly (class_type, type,
    1625                 :        965 :                                           TREE_CHAIN (arg_types));
    1626                 :            :           }
    1627                 :            :         else
    1628                 :            :           {
    1629                 :     267258 :             result = build_function_type (type, arg_types);
    1630                 :     267258 :             result = apply_memfn_quals (result, type_memfn_quals (t));
    1631                 :            :           }
    1632                 :            : 
    1633                 :     268223 :         result = build_cp_fntype_variant (result,
    1634                 :            :                                           type_memfn_rqual (t), canon_spec,
    1635                 :     268223 :                                           TYPE_HAS_LATE_RETURN_TYPE (t));
    1636                 :            :       }
    1637                 :     268223 :       break;
    1638                 :    6725790 :     case TYPENAME_TYPE:
    1639                 :    6725790 :       {
    1640                 :    6725790 :         bool changed = false;
    1641                 :    6725790 :         tree fullname = TYPENAME_TYPE_FULLNAME (t);
    1642                 :    6725790 :         if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR
    1643                 :    6725790 :             && TREE_OPERAND (fullname, 1))
    1644                 :            :           {
    1645                 :      50068 :             tree args = TREE_OPERAND (fullname, 1);
    1646                 :      50068 :             tree new_args = copy_node (args);
    1647                 :     100148 :             for (int i = 0; i < TREE_VEC_LENGTH (args); ++i)
    1648                 :            :               {
    1649                 :      50080 :                 tree arg = TREE_VEC_ELT (args, i);
    1650                 :      50080 :                 tree strip_arg;
    1651                 :      50080 :                 if (TYPE_P (arg))
    1652                 :      50076 :                   strip_arg = strip_typedefs (arg, remove_attributes, flags);
    1653                 :            :                 else
    1654                 :          4 :                   strip_arg = strip_typedefs_expr (arg, remove_attributes,
    1655                 :            :                                                    flags);
    1656                 :      50080 :                 TREE_VEC_ELT (new_args, i) = strip_arg;
    1657                 :      50080 :                 if (strip_arg != arg)
    1658                 :       3428 :                   changed = true;
    1659                 :            :               }
    1660                 :      50068 :             if (changed)
    1661                 :            :               {
    1662                 :       6856 :                 NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_args)
    1663                 :       3428 :                   = NON_DEFAULT_TEMPLATE_ARGS_COUNT (args);
    1664                 :       3428 :                 fullname
    1665                 :       3428 :                   = lookup_template_function (TREE_OPERAND (fullname, 0),
    1666                 :            :                                               new_args);
    1667                 :            :               }
    1668                 :            :             else
    1669                 :      46640 :               ggc_free (new_args);
    1670                 :            :           }
    1671                 :    6725790 :         tree ctx = strip_typedefs (TYPE_CONTEXT (t), remove_attributes, flags);
    1672                 :   13448100 :         if (!changed && ctx == TYPE_CONTEXT (t) && !typedef_variant_p (t))
    1673                 :            :           return t;
    1674                 :     826441 :         tree name = fullname;
    1675                 :     826441 :         if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
    1676                 :       7706 :           name = TREE_OPERAND (fullname, 0);
    1677                 :            :         /* Use build_typename_type rather than make_typename_type because we
    1678                 :            :            don't want to resolve it here, just strip typedefs.  */
    1679                 :     826441 :         result = build_typename_type (ctx, name, fullname, typename_type);
    1680                 :            :       }
    1681                 :     826441 :       break;
    1682                 :    1338410 :     case DECLTYPE_TYPE:
    1683                 :    1338410 :       result = strip_typedefs_expr (DECLTYPE_TYPE_EXPR (t),
    1684                 :            :                                     remove_attributes, flags);
    1685                 :    1338410 :       if (result == DECLTYPE_TYPE_EXPR (t))
    1686                 :            :         result = NULL_TREE;
    1687                 :            :       else
    1688                 :       5567 :         result = (finish_decltype_type
    1689                 :       5567 :                   (result,
    1690                 :       5567 :                    DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (t),
    1691                 :       5567 :                    tf_none));
    1692                 :            :       break;
    1693                 :          9 :     case UNDERLYING_TYPE:
    1694                 :          9 :       type = strip_typedefs (UNDERLYING_TYPE_TYPE (t),
    1695                 :            :                              remove_attributes, flags);
    1696                 :          9 :       result = finish_underlying_type (type);
    1697                 :          9 :       break;
    1698                 :            :     default:
    1699                 :            :       break;
    1700                 :            :     }
    1701                 :            : 
    1702                 :   23249600 :   if (!result)
    1703                 :            :     {
    1704                 :   65545800 :       if (typedef_variant_p (t))
    1705                 :            :         {
    1706                 :   20748400 :           if ((flags & STF_USER_VISIBLE)
    1707                 :   20748400 :               && !user_facing_original_type_p (t))
    1708                 :            :             return t;
    1709                 :            :           /* If T is a non-template alias or typedef, we can assume that
    1710                 :            :              instantiating its definition will hit any substitution failure,
    1711                 :            :              so we don't need to retain it here as well.  */
    1712                 :   20747600 :           if (!alias_template_specialization_p (t, nt_opaque))
    1713                 :   17121800 :             flags |= STF_STRIP_DEPENDENT;
    1714                 :   20747600 :           result = strip_typedefs (DECL_ORIGINAL_TYPE (TYPE_NAME (t)),
    1715                 :            :                                    remove_attributes, flags);
    1716                 :            :         }
    1717                 :            :       else
    1718                 :   44797400 :         result = TYPE_MAIN_VARIANT (t);
    1719                 :            :     }
    1720                 :            :   /*gcc_assert (!typedef_variant_p (result)
    1721                 :            :               || dependent_alias_template_spec_p (result, nt_opaque)
    1722                 :            :               || ((flags & STF_USER_VISIBLE)
    1723                 :            :                   && !user_facing_original_type_p (result)));*/
    1724                 :            : 
    1725                 :  128374000 :   if (COMPLETE_TYPE_P (result) && !COMPLETE_TYPE_P (t))
    1726                 :            :   /* If RESULT is complete and T isn't, it's likely the case that T
    1727                 :            :      is a variant of RESULT which hasn't been updated yet.  Skip the
    1728                 :            :      attribute handling.  */;
    1729                 :            :   else
    1730                 :            :     {
    1731                 :   88794600 :       if (TYPE_USER_ALIGN (t) != TYPE_USER_ALIGN (result)
    1732                 :   88794600 :           || TYPE_ALIGN (t) != TYPE_ALIGN (result))
    1733                 :            :         {
    1734                 :         20 :           gcc_assert (TYPE_USER_ALIGN (t));
    1735                 :         20 :           if (remove_attributes)
    1736                 :         12 :             *remove_attributes = true;
    1737                 :            :           else
    1738                 :            :             {
    1739                 :          8 :               if (TYPE_ALIGN (t) == TYPE_ALIGN (result))
    1740                 :          0 :                 result = build_variant_type_copy (result);
    1741                 :            :               else
    1742                 :          8 :                 result = build_aligned_type (result, TYPE_ALIGN (t));
    1743                 :          8 :               TYPE_USER_ALIGN (result) = true;
    1744                 :            :             }
    1745                 :            :         }
    1746                 :            : 
    1747                 :   88794600 :       if (TYPE_ATTRIBUTES (t))
    1748                 :            :         {
    1749                 :    1067570 :           if (remove_attributes)
    1750                 :    1067400 :             result = apply_identity_attributes (result, TYPE_ATTRIBUTES (t),
    1751                 :            :                                                 remove_attributes);
    1752                 :            :           else
    1753                 :        171 :             result = cp_build_type_attribute_variant (result,
    1754                 :        171 :                                                       TYPE_ATTRIBUTES (t));
    1755                 :            :         }
    1756                 :            :     }
    1757                 :            : 
    1758                 :   88794600 :   return cp_build_qualified_type (result, cp_type_quals (t));
    1759                 :            : }
    1760                 :            : 
    1761                 :            : /* Like strip_typedefs above, but works on expressions, so that in
    1762                 :            : 
    1763                 :            :    template<class T> struct A
    1764                 :            :    {
    1765                 :            :      typedef T TT;
    1766                 :            :      B<sizeof(TT)> b;
    1767                 :            :    };
    1768                 :            : 
    1769                 :            :    sizeof(TT) is replaced by sizeof(T).  */
    1770                 :            : 
    1771                 :            : tree
    1772                 :   54771400 : strip_typedefs_expr (tree t, bool *remove_attributes, unsigned int flags)
    1773                 :            : {
    1774                 :   54771400 :   unsigned i,n;
    1775                 :   54771400 :   tree r, type, *ops;
    1776                 :   54771400 :   enum tree_code code;
    1777                 :            : 
    1778                 :   54771400 :   if (t == NULL_TREE || t == error_mark_node)
    1779                 :            :     return t;
    1780                 :            : 
    1781                 :   50101200 :   STRIP_ANY_LOCATION_WRAPPER (t);
    1782                 :            : 
    1783                 :   50101200 :   if (DECL_P (t) || CONSTANT_CLASS_P (t))
    1784                 :            :     return t;
    1785                 :            : 
    1786                 :            :   /* Some expressions have type operands, so let's handle types here rather
    1787                 :            :      than check TYPE_P in multiple places below.  */
    1788                 :   29673800 :   if (TYPE_P (t))
    1789                 :    5990170 :     return strip_typedefs (t, remove_attributes, flags);
    1790                 :            : 
    1791                 :   23683700 :   code = TREE_CODE (t);
    1792                 :   23683700 :   switch (code)
    1793                 :            :     {
    1794                 :            :     case IDENTIFIER_NODE:
    1795                 :            :     case TEMPLATE_PARM_INDEX:
    1796                 :            :     case OVERLOAD:
    1797                 :            :     case BASELINK:
    1798                 :            :     case ARGUMENT_PACK_SELECT:
    1799                 :            :       return t;
    1800                 :            : 
    1801                 :     359626 :     case TRAIT_EXPR:
    1802                 :     359626 :       {
    1803                 :     359626 :         tree type1 = strip_typedefs (TRAIT_EXPR_TYPE1 (t),
    1804                 :            :                                      remove_attributes, flags);
    1805                 :     359626 :         tree type2 = strip_typedefs (TRAIT_EXPR_TYPE2 (t),
    1806                 :            :                                      remove_attributes, flags);
    1807                 :     359626 :         if (type1 == TRAIT_EXPR_TYPE1 (t)
    1808                 :     359626 :             && type2 == TRAIT_EXPR_TYPE2 (t))
    1809                 :            :           return t;
    1810                 :      22254 :         r = copy_node (t);
    1811                 :      22254 :         TRAIT_EXPR_TYPE1 (r) = type1;
    1812                 :      22254 :         TRAIT_EXPR_TYPE2 (r) = type2;
    1813                 :      22254 :         return r;
    1814                 :            :       }
    1815                 :            : 
    1816                 :      81995 :     case TREE_LIST:
    1817                 :      81995 :       {
    1818                 :     163990 :         releasing_vec vec;
    1819                 :      81995 :         bool changed = false;
    1820                 :      81995 :         tree it;
    1821                 :     166243 :         for (it = t; it; it = TREE_CHAIN (it))
    1822                 :            :           {
    1823                 :      84248 :             tree val = strip_typedefs_expr (TREE_VALUE (it),
    1824                 :      84248 :                                             remove_attributes, flags);
    1825                 :      84248 :             vec_safe_push (vec, val);
    1826                 :      84248 :             if (val != TREE_VALUE (it))
    1827                 :      29260 :               changed = true;
    1828                 :      84248 :             gcc_assert (TREE_PURPOSE (it) == NULL_TREE);
    1829                 :            :           }
    1830                 :      81995 :         if (changed)
    1831                 :            :           {
    1832                 :      28169 :             r = NULL_TREE;
    1833                 :      58517 :             FOR_EACH_VEC_ELT_REVERSE (*vec, i, it)
    1834                 :      30348 :               r = tree_cons (NULL_TREE, it, r);
    1835                 :            :           }
    1836                 :            :         else
    1837                 :            :           r = t;
    1838                 :      81995 :         return r;
    1839                 :            :       }
    1840                 :            : 
    1841                 :    2590650 :     case TREE_VEC:
    1842                 :    2590650 :       {
    1843                 :    2590650 :         bool changed = false;
    1844                 :    5181290 :         releasing_vec vec;
    1845                 :    2590650 :         n = TREE_VEC_LENGTH (t);
    1846                 :    2590650 :         vec_safe_reserve (vec, n);
    1847                 :    5750010 :         for (i = 0; i < n; ++i)
    1848                 :            :           {
    1849                 :    3159360 :             tree op = strip_typedefs_expr (TREE_VEC_ELT (t, i),
    1850                 :    3159360 :                                            remove_attributes, flags);
    1851                 :    3159360 :             vec->quick_push (op);
    1852                 :    3159360 :             if (op != TREE_VEC_ELT (t, i))
    1853                 :       9798 :               changed = true;
    1854                 :            :           }
    1855                 :    2590650 :         if (changed)
    1856                 :            :           {
    1857                 :       9730 :             r = copy_node (t);
    1858                 :      24873 :             for (i = 0; i < n; ++i)
    1859                 :      15143 :               TREE_VEC_ELT (r, i) = (*vec)[i];
    1860                 :      19460 :             NON_DEFAULT_TEMPLATE_ARGS_COUNT (r)
    1861                 :      19460 :               = NON_DEFAULT_TEMPLATE_ARGS_COUNT (t);
    1862                 :            :           }
    1863                 :            :         else
    1864                 :            :           r = t;
    1865                 :    2590650 :         return r;
    1866                 :            :       }
    1867                 :            : 
    1868                 :      46597 :     case CONSTRUCTOR:
    1869                 :      46597 :       {
    1870                 :      46597 :         bool changed = false;
    1871                 :      46597 :         vec<constructor_elt, va_gc> *vec
    1872                 :      46597 :           = vec_safe_copy (CONSTRUCTOR_ELTS (t));
    1873                 :      46597 :         n = CONSTRUCTOR_NELTS (t);
    1874                 :      46597 :         type = strip_typedefs (TREE_TYPE (t), remove_attributes, flags);
    1875                 :      47466 :         for (i = 0; i < n; ++i)
    1876                 :            :           {
    1877                 :        869 :             constructor_elt *e = &(*vec)[i];
    1878                 :        869 :             tree op = strip_typedefs_expr (e->value, remove_attributes, flags);
    1879                 :        869 :             if (op != e->value)
    1880                 :            :               {
    1881                 :          4 :                 changed = true;
    1882                 :          4 :                 e->value = op;
    1883                 :            :               }
    1884                 :        869 :             gcc_checking_assert
    1885                 :            :               (e->index == strip_typedefs_expr (e->index, remove_attributes,
    1886                 :            :                                                 flags));
    1887                 :            :           }
    1888                 :            : 
    1889                 :      93190 :         if (!changed && type == TREE_TYPE (t))
    1890                 :            :           {
    1891                 :      43645 :             vec_free (vec);
    1892                 :      43645 :             return t;
    1893                 :            :           }
    1894                 :            :         else
    1895                 :            :           {
    1896                 :       2952 :             r = copy_node (t);
    1897                 :       2952 :             TREE_TYPE (r) = type;
    1898                 :       2952 :             CONSTRUCTOR_ELTS (r) = vec;
    1899                 :       2952 :             return r;
    1900                 :            :           }
    1901                 :            :       }
    1902                 :            : 
    1903                 :            :     case LAMBDA_EXPR:
    1904                 :            :       return t;
    1905                 :            : 
    1906                 :          3 :     case STATEMENT_LIST:
    1907                 :          3 :       error ("statement-expression in a constant expression");
    1908                 :          3 :       return error_mark_node;
    1909                 :            : 
    1910                 :   12489300 :     default:
    1911                 :   12489300 :       break;
    1912                 :            :     }
    1913                 :            : 
    1914                 :   12489300 :   gcc_assert (EXPR_P (t));
    1915                 :            : 
    1916                 :   12489300 :   n = cp_tree_operand_length (t);
    1917                 :   12489300 :   ops = XALLOCAVEC (tree, n);
    1918                 :   12489300 :   type = TREE_TYPE (t);
    1919                 :            : 
    1920                 :   12489300 :   switch (code)
    1921                 :            :     {
    1922                 :     159124 :     CASE_CONVERT:
    1923                 :     159124 :     case IMPLICIT_CONV_EXPR:
    1924                 :     159124 :     case DYNAMIC_CAST_EXPR:
    1925                 :     159124 :     case STATIC_CAST_EXPR:
    1926                 :     159124 :     case CONST_CAST_EXPR:
    1927                 :     159124 :     case REINTERPRET_CAST_EXPR:
    1928                 :     159124 :     case CAST_EXPR:
    1929                 :     159124 :     case NEW_EXPR:
    1930                 :     159124 :       type = strip_typedefs (type, remove_attributes, flags);
    1931                 :            :       /* fallthrough */
    1932                 :            : 
    1933                 :   12489300 :     default:
    1934                 :   42093500 :       for (i = 0; i < n; ++i)
    1935                 :   29604300 :         ops[i] = strip_typedefs_expr (TREE_OPERAND (t, i),
    1936                 :            :                                       remove_attributes, flags);
    1937                 :            :       break;
    1938                 :            :     }
    1939                 :            : 
    1940                 :            :   /* If nothing changed, return t.  */
    1941                 :   41320500 :   for (i = 0; i < n; ++i)
    1942                 :   29268600 :     if (ops[i] != TREE_OPERAND (t, i))
    1943                 :            :       break;
    1944                 :   24541200 :   if (i == n && type == TREE_TYPE (t))
    1945                 :            :     return t;
    1946                 :            : 
    1947                 :     439546 :   r = copy_node (t);
    1948                 :     439546 :   TREE_TYPE (r) = type;
    1949                 :    1475210 :   for (i = 0; i < n; ++i)
    1950                 :    1035660 :     TREE_OPERAND (r, i) = ops[i];
    1951                 :            :   return r;
    1952                 :            : }
    1953                 :            : 
    1954                 :            : /* Makes a copy of BINFO and TYPE, which is to be inherited into a
    1955                 :            :    graph dominated by T.  If BINFO is NULL, TYPE is a dependent base,
    1956                 :            :    and we do a shallow copy.  If BINFO is non-NULL, we do a deep copy.
    1957                 :            :    VIRT indicates whether TYPE is inherited virtually or not.
    1958                 :            :    IGO_PREV points at the previous binfo of the inheritance graph
    1959                 :            :    order chain.  The newly copied binfo's TREE_CHAIN forms this
    1960                 :            :    ordering.
    1961                 :            : 
    1962                 :            :    The CLASSTYPE_VBASECLASSES vector of T is constructed in the
    1963                 :            :    correct order. That is in the order the bases themselves should be
    1964                 :            :    constructed in.
    1965                 :            : 
    1966                 :            :    The BINFO_INHERITANCE of a virtual base class points to the binfo
    1967                 :            :    of the most derived type. ??? We could probably change this so that
    1968                 :            :    BINFO_INHERITANCE becomes synonymous with BINFO_PRIMARY, and hence
    1969                 :            :    remove a field.  They currently can only differ for primary virtual
    1970                 :            :    virtual bases.  */
    1971                 :            : 
    1972                 :            : tree
    1973                 :   12609800 : copy_binfo (tree binfo, tree type, tree t, tree *igo_prev, int virt)
    1974                 :            : {
    1975                 :   12609800 :   tree new_binfo;
    1976                 :            : 
    1977                 :   12609800 :   if (virt)
    1978                 :            :     {
    1979                 :            :       /* See if we've already made this virtual base.  */
    1980                 :      45653 :       new_binfo = binfo_for_vbase (type, t);
    1981                 :      45653 :       if (new_binfo)
    1982                 :            :         return new_binfo;
    1983                 :            :     }
    1984                 :            : 
    1985                 :   24087900 :   new_binfo = make_tree_binfo (binfo ? BINFO_N_BASE_BINFOS (binfo) : 0);
    1986                 :   12595800 :   BINFO_TYPE (new_binfo) = type;
    1987                 :            : 
    1988                 :            :   /* Chain it into the inheritance graph.  */
    1989                 :   12595800 :   TREE_CHAIN (*igo_prev) = new_binfo;
    1990                 :   12595800 :   *igo_prev = new_binfo;
    1991                 :            : 
    1992                 :   24087900 :   if (binfo && !BINFO_DEPENDENT_BASE_P (binfo))
    1993                 :            :     {
    1994                 :   11492000 :       int ix;
    1995                 :   11492000 :       tree base_binfo;
    1996                 :            : 
    1997                 :   11492000 :       gcc_assert (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), type));
    1998                 :            : 
    1999                 :   11492000 :       BINFO_OFFSET (new_binfo) = BINFO_OFFSET (binfo);
    2000                 :   11492000 :       BINFO_VIRTUALS (new_binfo) = BINFO_VIRTUALS (binfo);
    2001                 :            : 
    2002                 :            :       /* We do not need to copy the accesses, as they are read only.  */
    2003                 :   11492000 :       BINFO_BASE_ACCESSES (new_binfo) = BINFO_BASE_ACCESSES (binfo);
    2004                 :            : 
    2005                 :            :       /* Recursively copy base binfos of BINFO.  */
    2006                 :   16094100 :       for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
    2007                 :            :         {
    2008                 :    4602030 :           tree new_base_binfo;
    2009                 :    4602030 :           new_base_binfo = copy_binfo (base_binfo, BINFO_TYPE (base_binfo),
    2010                 :            :                                        t, igo_prev,
    2011                 :    4602030 :                                        BINFO_VIRTUAL_P (base_binfo));
    2012                 :            : 
    2013                 :    4602030 :           if (!BINFO_INHERITANCE_CHAIN (new_base_binfo))
    2014                 :    4567640 :             BINFO_INHERITANCE_CHAIN (new_base_binfo) = new_binfo;
    2015                 :    4602030 :           BINFO_BASE_APPEND (new_binfo, new_base_binfo);
    2016                 :            :         }
    2017                 :            :     }
    2018                 :            :   else
    2019                 :    1103820 :     BINFO_DEPENDENT_BASE_P (new_binfo) = 1;
    2020                 :            : 
    2021                 :   12595800 :   if (virt)
    2022                 :            :     {
    2023                 :            :       /* Push it onto the list after any virtual bases it contains
    2024                 :            :          will have been pushed.  */
    2025                 :      31686 :       CLASSTYPE_VBASECLASSES (t)->quick_push (new_binfo);
    2026                 :      31686 :       BINFO_VIRTUAL_P (new_binfo) = 1;
    2027                 :      31686 :       BINFO_INHERITANCE_CHAIN (new_binfo) = TYPE_BINFO (t);
    2028                 :            :     }
    2029                 :            : 
    2030                 :            :   return new_binfo;
    2031                 :            : }
    2032                 :            : 
    2033                 :            : /* Hashing of lists so that we don't make duplicates.
    2034                 :            :    The entry point is `list_hash_canon'.  */
    2035                 :            : 
    2036                 :            : struct list_proxy
    2037                 :            : {
    2038                 :            :   tree purpose;
    2039                 :            :   tree value;
    2040                 :            :   tree chain;
    2041                 :            : };
    2042                 :            : 
    2043                 :            : struct list_hasher : ggc_ptr_hash<tree_node>
    2044                 :            : {
    2045                 :            :   typedef list_proxy *compare_type;
    2046                 :            : 
    2047                 :            :   static hashval_t hash (tree);
    2048                 :            :   static bool equal (tree, list_proxy *);
    2049                 :            : };
    2050                 :            : 
    2051                 :            : /* Now here is the hash table.  When recording a list, it is added
    2052                 :            :    to the slot whose index is the hash code mod the table size.
    2053                 :            :    Note that the hash table is used for several kinds of lists.
    2054                 :            :    While all these live in the same table, they are completely independent,
    2055                 :            :    and the hash code is computed differently for each of these.  */
    2056                 :            : 
    2057                 :            : static GTY (()) hash_table<list_hasher> *list_hash_table;
    2058                 :            : 
    2059                 :            : /* Compare ENTRY (an entry in the hash table) with DATA (a list_proxy
    2060                 :            :    for a node we are thinking about adding).  */
    2061                 :            : 
    2062                 :            : bool
    2063                 :  206835000 : list_hasher::equal (tree t, list_proxy *proxy)
    2064                 :            : {
    2065                 :  206835000 :   return (TREE_VALUE (t) == proxy->value
    2066                 :   20372000 :           && TREE_PURPOSE (t) == proxy->purpose
    2067                 :  226929000 :           && TREE_CHAIN (t) == proxy->chain);
    2068                 :            : }
    2069                 :            : 
    2070                 :            : /* Compute a hash code for a list (chain of TREE_LIST nodes
    2071                 :            :    with goodies in the TREE_PURPOSE, TREE_VALUE, and bits of the
    2072                 :            :    TREE_COMMON slots), by adding the hash codes of the individual entries.  */
    2073                 :            : 
    2074                 :            : static hashval_t
    2075                 :  190741000 : list_hash_pieces (tree purpose, tree value, tree chain)
    2076                 :            : {
    2077                 :  190741000 :   hashval_t hashcode = 0;
    2078                 :            : 
    2079                 :  157018000 :   if (chain)
    2080                 :  189335000 :     hashcode += TREE_HASH (chain);
    2081                 :            : 
    2082                 :  190741000 :   if (value)
    2083                 :  190741000 :     hashcode += TREE_HASH (value);
    2084                 :            :   else
    2085                 :          0 :     hashcode += 1007;
    2086                 :  190741000 :   if (purpose)
    2087                 :   11492800 :     hashcode += TREE_HASH (purpose);
    2088                 :            :   else
    2089                 :  179248000 :     hashcode += 1009;
    2090                 :  190741000 :   return hashcode;
    2091                 :            : }
    2092                 :            : 
    2093                 :            : /* Hash an already existing TREE_LIST.  */
    2094                 :            : 
    2095                 :            : hashval_t
    2096                 :  157018000 : list_hasher::hash (tree t)
    2097                 :            : {
    2098                 :  157018000 :   return list_hash_pieces (TREE_PURPOSE (t),
    2099                 :  157018000 :                            TREE_VALUE (t),
    2100                 :  157018000 :                            TREE_CHAIN (t));
    2101                 :            : }
    2102                 :            : 
    2103                 :            : /* Given list components PURPOSE, VALUE, AND CHAIN, return the canonical
    2104                 :            :    object for an identical list if one already exists.  Otherwise, build a
    2105                 :            :    new one, and record it as the canonical object.  */
    2106                 :            : 
    2107                 :            : tree
    2108                 :   33722400 : hash_tree_cons (tree purpose, tree value, tree chain)
    2109                 :            : {
    2110                 :   33722400 :   int hashcode = 0;
    2111                 :   33722400 :   tree *slot;
    2112                 :   33722400 :   struct list_proxy proxy;
    2113                 :            : 
    2114                 :            :   /* Hash the list node.  */
    2115                 :   33722400 :   hashcode = list_hash_pieces (purpose, value, chain);
    2116                 :            :   /* Create a proxy for the TREE_LIST we would like to create.  We
    2117                 :            :      don't actually create it so as to avoid creating garbage.  */
    2118                 :   33722400 :   proxy.purpose = purpose;
    2119                 :   33722400 :   proxy.value = value;
    2120                 :   33722400 :   proxy.chain = chain;
    2121                 :            :   /* See if it is already in the table.  */
    2122                 :   33722400 :   slot = list_hash_table->find_slot_with_hash (&proxy, hashcode, INSERT);
    2123                 :            :   /* If not, create a new node.  */
    2124                 :   33722400 :   if (!*slot)
    2125                 :   14762000 :     *slot = tree_cons (purpose, value, chain);
    2126                 :   33722400 :   return (tree) *slot;
    2127                 :            : }
    2128                 :            : 
    2129                 :            : /* Constructor for hashed lists.  */
    2130                 :            : 
    2131                 :            : tree
    2132                 :    1362610 : hash_tree_chain (tree value, tree chain)
    2133                 :            : {
    2134                 :    1362610 :   return hash_tree_cons (NULL_TREE, value, chain);
    2135                 :            : }
    2136                 :            : 
    2137                 :            : void
    2138                 :          0 : debug_binfo (tree elem)
    2139                 :            : {
    2140                 :          0 :   HOST_WIDE_INT n;
    2141                 :          0 :   tree virtuals;
    2142                 :            : 
    2143                 :          0 :   fprintf (stderr, "type \"%s\", offset = " HOST_WIDE_INT_PRINT_DEC
    2144                 :            :            "\nvtable type:\n",
    2145                 :          0 :            TYPE_NAME_STRING (BINFO_TYPE (elem)),
    2146                 :          0 :            TREE_INT_CST_LOW (BINFO_OFFSET (elem)));
    2147                 :          0 :   debug_tree (BINFO_TYPE (elem));
    2148                 :          0 :   if (BINFO_VTABLE (elem))
    2149                 :          0 :     fprintf (stderr, "vtable decl \"%s\"\n",
    2150                 :          0 :              IDENTIFIER_POINTER (DECL_NAME (get_vtbl_decl_for_binfo (elem))));
    2151                 :            :   else
    2152                 :          0 :     fprintf (stderr, "no vtable decl yet\n");
    2153                 :          0 :   fprintf (stderr, "virtuals:\n");
    2154                 :          0 :   virtuals = BINFO_VIRTUALS (elem);
    2155                 :          0 :   n = 0;
    2156                 :            : 
    2157                 :          0 :   while (virtuals)
    2158                 :            :     {
    2159                 :          0 :       tree fndecl = TREE_VALUE (virtuals);
    2160                 :          0 :       fprintf (stderr, "%s [%ld =? %ld]\n",
    2161                 :          0 :                IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)),
    2162                 :          0 :                (long) n, (long) TREE_INT_CST_LOW (DECL_VINDEX (fndecl)));
    2163                 :          0 :       ++n;
    2164                 :          0 :       virtuals = TREE_CHAIN (virtuals);
    2165                 :            :     }
    2166                 :          0 : }
    2167                 :            : 
    2168                 :            : /* Build a representation for the qualified name SCOPE::NAME.  TYPE is
    2169                 :            :    the type of the result expression, if known, or NULL_TREE if the
    2170                 :            :    resulting expression is type-dependent.  If TEMPLATE_P is true,
    2171                 :            :    NAME is known to be a template because the user explicitly used the
    2172                 :            :    "template" keyword after the "::".
    2173                 :            : 
    2174                 :            :    All SCOPE_REFs should be built by use of this function.  */
    2175                 :            : 
    2176                 :            : tree
    2177                 :   13629700 : build_qualified_name (tree type, tree scope, tree name, bool template_p)
    2178                 :            : {
    2179                 :   13629700 :   tree t;
    2180                 :   13629700 :   if (type == error_mark_node
    2181                 :   13629700 :       || scope == error_mark_node
    2182                 :   13629700 :       || name == error_mark_node)
    2183                 :            :     return error_mark_node;
    2184                 :   13629700 :   gcc_assert (TREE_CODE (name) != SCOPE_REF);
    2185                 :   13629700 :   t = build2 (SCOPE_REF, type, scope, name);
    2186                 :   13629700 :   QUALIFIED_NAME_IS_TEMPLATE (t) = template_p;
    2187                 :   13629700 :   PTRMEM_OK_P (t) = true;
    2188                 :   13629700 :   if (type)
    2189                 :     728536 :     t = convert_from_reference (t);
    2190                 :            :   return t;
    2191                 :            : }
    2192                 :            : 
    2193                 :            : /* Like check_qualified_type, but also check ref-qualifier, exception
    2194                 :            :    specification, and whether the return type was specified after the
    2195                 :            :    parameters.  */
    2196                 :            : 
    2197                 :            : static bool
    2198                 :  132634000 : cp_check_qualified_type (const_tree cand, const_tree base, int type_quals,
    2199                 :            :                          cp_ref_qualifier rqual, tree raises, bool late)
    2200                 :            : {
    2201                 :  132634000 :   return (TYPE_QUALS (cand) == type_quals
    2202                 :  132630000 :           && check_base_type (cand, base)
    2203                 :  132623000 :           && comp_except_specs (raises, TYPE_RAISES_EXCEPTIONS (cand),
    2204                 :            :                                 ce_exact)
    2205                 :   74219200 :           && TYPE_HAS_LATE_RETURN_TYPE (cand) == late
    2206                 :  205536000 :           && type_memfn_rqual (cand) == rqual);
    2207                 :            : }
    2208                 :            : 
    2209                 :            : /* Build the FUNCTION_TYPE or METHOD_TYPE with the ref-qualifier RQUAL.  */
    2210                 :            : 
    2211                 :            : tree
    2212                 :      72883 : build_ref_qualified_type (tree type, cp_ref_qualifier rqual)
    2213                 :            : {
    2214                 :      72883 :   tree raises = TYPE_RAISES_EXCEPTIONS (type);
    2215                 :      72883 :   bool late = TYPE_HAS_LATE_RETURN_TYPE (type);
    2216                 :      72883 :   return build_cp_fntype_variant (type, rqual, raises, late);
    2217                 :            : }
    2218                 :            : 
    2219                 :            : /* Make a raw overload node containing FN.  */
    2220                 :            : 
    2221                 :            : tree
    2222                 :   78990400 : ovl_make (tree fn, tree next)
    2223                 :            : {
    2224                 :   78990400 :   tree result = make_node (OVERLOAD);
    2225                 :            : 
    2226                 :   78990400 :   if (TREE_CODE (fn) == OVERLOAD)
    2227                 :     358987 :     OVL_NESTED_P (result) = true;
    2228                 :            : 
    2229                 :   60491200 :   TREE_TYPE (result) = (next || TREE_CODE (fn) == TEMPLATE_DECL
    2230                 :  139482000 :                         ? unknown_type_node : TREE_TYPE (fn));
    2231                 :   78990400 :   if (next && TREE_CODE (next) == OVERLOAD && OVL_DEDUP_P (next))
    2232                 :    2065370 :     OVL_DEDUP_P (result) = true;
    2233                 :   78990400 :   OVL_FUNCTION (result) = fn;
    2234                 :   78990400 :   OVL_CHAIN (result) = next;
    2235                 :   78990400 :   return result;
    2236                 :            : }
    2237                 :            : 
    2238                 :            : /* Add FN to the (potentially NULL) overload set OVL.  USING_P is
    2239                 :            :    true, if FN is via a using declaration.  We also pay attention to
    2240                 :            :    DECL_HIDDEN.  We keep the hidden decls first, but remaining ones
    2241                 :            :    are unordered.  */
    2242                 :            : 
    2243                 :            : tree
    2244                 :  203269000 : ovl_insert (tree fn, tree maybe_ovl, bool using_p)
    2245                 :            : {
    2246                 :  203269000 :   tree result = maybe_ovl;
    2247                 :  203269000 :   tree insert_after = NULL_TREE;
    2248                 :            : 
    2249                 :            :   /* Skip hidden.  */
    2250                 :   20504300 :   for (; maybe_ovl && TREE_CODE (maybe_ovl) == OVERLOAD
    2251                 :  222265000 :          && OVL_HIDDEN_P (maybe_ovl);
    2252                 :    3936290 :        maybe_ovl = OVL_CHAIN (maybe_ovl))
    2253                 :            :     {
    2254                 :    3936290 :       gcc_checking_assert (!OVL_LOOKUP_P (maybe_ovl));
    2255                 :    3936290 :       insert_after = maybe_ovl;
    2256                 :            :     }
    2257                 :            : 
    2258                 :  406537000 :   bool hidden_p = DECL_HIDDEN_P (fn);
    2259                 :  203269000 :   if (maybe_ovl || using_p || hidden_p || TREE_CODE (fn) == TEMPLATE_DECL)
    2260                 :            :     {
    2261                 :   76943400 :       maybe_ovl = ovl_make (fn, maybe_ovl);
    2262                 :   76943400 :       if (hidden_p)
    2263                 :   57263600 :         OVL_HIDDEN_P (maybe_ovl) = true;
    2264                 :   76943400 :       if (using_p)
    2265                 :    1621960 :         OVL_DEDUP_P (maybe_ovl) = OVL_USING_P (maybe_ovl) = true;
    2266                 :            :     }
    2267                 :            :   else
    2268                 :            :     maybe_ovl = fn;
    2269                 :            : 
    2270                 :  203269000 :   if (insert_after)
    2271                 :            :     {
    2272                 :     538639 :       OVL_CHAIN (insert_after) = maybe_ovl;
    2273                 :     538639 :       TREE_TYPE (insert_after) = unknown_type_node;
    2274                 :            :     }
    2275                 :            :   else
    2276                 :            :     result = maybe_ovl;
    2277                 :            : 
    2278                 :  203269000 :   return result;
    2279                 :            : }
    2280                 :            : 
    2281                 :            : /* Skip any hidden names at the beginning of OVL.   */
    2282                 :            : 
    2283                 :            : tree
    2284                 :   97812300 : ovl_skip_hidden (tree ovl)
    2285                 :            : {
    2286                 :   13817700 :   for (;
    2287                 :  111630000 :        ovl && TREE_CODE (ovl) == OVERLOAD && OVL_HIDDEN_P (ovl);
    2288                 :   13817700 :        ovl = OVL_CHAIN (ovl))
    2289                 :   27635300 :     gcc_checking_assert (DECL_HIDDEN_P (OVL_FUNCTION (ovl)));
    2290                 :            : 
    2291                 :  201612000 :   if (ovl && TREE_CODE (ovl) != OVERLOAD && DECL_HIDDEN_P (ovl))
    2292                 :            :     {
    2293                 :            :       /* Any hidden functions should have been wrapped in an
    2294                 :            :          overload, but injected friend classes will not.  */
    2295                 :        516 :       gcc_checking_assert (!DECL_DECLARES_FUNCTION_P (ovl));
    2296                 :            :       ovl = NULL_TREE;
    2297                 :            :     }
    2298                 :            : 
    2299                 :   97812300 :   return ovl;
    2300                 :            : }
    2301                 :            : 
    2302                 :            : /* NODE is an OVL_HIDDEN_P node which is now revealed.  */
    2303                 :            : 
    2304                 :            : tree
    2305                 :     328757 : ovl_iterator::reveal_node (tree overload, tree node)
    2306                 :            : {
    2307                 :            :   /* We cannot have returned NODE as part of a lookup overload, so we
    2308                 :            :      don't have to worry about preserving that.  */
    2309                 :            : 
    2310                 :     328757 :   OVL_HIDDEN_P (node) = false;
    2311                 :     328757 :   if (tree chain = OVL_CHAIN (node))
    2312                 :       5272 :     if (TREE_CODE (chain) == OVERLOAD)
    2313                 :            :       {
    2314                 :       5130 :         if (OVL_HIDDEN_P (chain))
    2315                 :            :           {
    2316                 :            :             /* The node needs moving, and the simplest way is to remove it
    2317                 :            :                and reinsert.  */
    2318                 :        841 :             overload = remove_node (overload, node);
    2319                 :        841 :             overload = ovl_insert (OVL_FUNCTION (node), overload);
    2320                 :            :           }
    2321                 :       4289 :         else if (OVL_DEDUP_P (chain))
    2322                 :         12 :           OVL_DEDUP_P (node) = true;
    2323                 :            :       }
    2324                 :     328757 :   return overload;
    2325                 :            : }
    2326                 :            : 
    2327                 :            : /* NODE is on the overloads of OVL.  Remove it.  
    2328                 :            :    The removed node is unaltered and may continue to be iterated
    2329                 :            :    from (i.e. it is safe to remove a node from an overload one is
    2330                 :            :    currently iterating over).  */
    2331                 :            : 
    2332                 :            : tree
    2333                 :       4745 : ovl_iterator::remove_node (tree overload, tree node)
    2334                 :            : {
    2335                 :       4745 :   tree *slot = &overload;
    2336                 :      19362 :   while (*slot != node)
    2337                 :            :     {
    2338                 :      14617 :       tree probe = *slot;
    2339                 :      14617 :       gcc_checking_assert (!OVL_LOOKUP_P (probe));
    2340                 :            : 
    2341                 :      14617 :       slot = &OVL_CHAIN (probe);
    2342                 :            :     }
    2343                 :            : 
    2344                 :            :   /* Stitch out NODE.  We don't have to worry about now making a
    2345                 :            :      singleton overload (and consequently maybe setting its type),
    2346                 :            :      because all uses of this function will be followed by inserting a
    2347                 :            :      new node that must follow the place we've cut this out from.  */
    2348                 :       4745 :   if (TREE_CODE (node) != OVERLOAD)
    2349                 :            :     /* Cloned inherited ctors don't mark themselves as via_using.  */
    2350                 :       2083 :     *slot = NULL_TREE;
    2351                 :            :   else
    2352                 :       2662 :     *slot = OVL_CHAIN (node);
    2353                 :            : 
    2354                 :       4745 :   return overload;
    2355                 :            : }
    2356                 :            : 
    2357                 :            : /* Mark or unmark a lookup set. */
    2358                 :            : 
    2359                 :            : void
    2360                 :    9482590 : lookup_mark (tree ovl, bool val)
    2361                 :            : {
    2362                 :   58249200 :   for (lkp_iterator iter (ovl); iter; ++iter)
    2363                 :            :     {
    2364                 :   39284000 :       gcc_checking_assert (LOOKUP_SEEN_P (*iter) != val);
    2365                 :   39284000 :       LOOKUP_SEEN_P (*iter) = val;
    2366                 :            :     }
    2367                 :    9482590 : }
    2368                 :            : 
    2369                 :            : /* Add a set of new FNS into a lookup.  */
    2370                 :            : 
    2371                 :            : tree
    2372                 :   30852300 : lookup_add (tree fns, tree lookup)
    2373                 :            : {
    2374                 :   30852300 :   if (fns == error_mark_node || lookup == error_mark_node)
    2375                 :            :     return error_mark_node;
    2376                 :            : 
    2377                 :   30852300 :   if (lookup || TREE_CODE (fns) == TEMPLATE_DECL)
    2378                 :            :     {
    2379                 :    1821890 :       lookup = ovl_make (fns, lookup);
    2380                 :    1821890 :       OVL_LOOKUP_P (lookup) = true;
    2381                 :            :     }
    2382                 :            :   else
    2383                 :            :     lookup = fns;
    2384                 :            : 
    2385                 :            :   return lookup;
    2386                 :            : }
    2387                 :            : 
    2388                 :            : /* FNS is a new overload set, add them to LOOKUP, if they are not
    2389                 :            :    already present there.  */
    2390                 :            : 
    2391                 :            : tree
    2392                 :   30779700 : lookup_maybe_add (tree fns, tree lookup, bool deduping)
    2393                 :            : {
    2394                 :   30779700 :   if (deduping)
    2395                 :   20967800 :     for (tree next, probe = fns; probe; probe = next)
    2396                 :            :       {
    2397                 :   18174200 :         tree fn = probe;
    2398                 :   18174200 :         next = NULL_TREE;
    2399                 :            : 
    2400                 :   18174200 :         if (TREE_CODE (probe) == OVERLOAD)
    2401                 :            :           {
    2402                 :   17316200 :             fn = OVL_FUNCTION (probe);
    2403                 :   17316200 :             next = OVL_CHAIN (probe);
    2404                 :            :           }
    2405                 :            : 
    2406                 :   18174200 :         if (!LOOKUP_SEEN_P (fn))
    2407                 :    7384800 :           LOOKUP_SEEN_P (fn) = true;
    2408                 :            :         else
    2409                 :            :           {
    2410                 :            :             /* This function was already seen.  Insert all the
    2411                 :            :                predecessors onto the lookup.  */
    2412                 :   11854700 :             for (; fns != probe; fns = OVL_CHAIN (fns))
    2413                 :            :               {
    2414                 :    1065250 :                 lookup = lookup_add (OVL_FUNCTION (fns), lookup);
    2415                 :            :                 /* Propagate OVL_USING, but OVL_HIDDEN &
    2416                 :            :                    OVL_DEDUP_P don't matter.  */
    2417                 :    1065250 :                 if (OVL_USING_P (fns))
    2418                 :          0 :                   OVL_USING_P (lookup) = true;
    2419                 :            :               }
    2420                 :            : 
    2421                 :            :             /* And now skip this function.  */
    2422                 :            :             fns = next;
    2423                 :            :           }
    2424                 :            :       }
    2425                 :            : 
    2426                 :   30779700 :   if (fns)
    2427                 :            :     /* We ended in a set of new functions.  Add them all in one go.  */
    2428                 :   29741000 :     lookup = lookup_add (fns, lookup);
    2429                 :            : 
    2430                 :   30779700 :   return lookup;
    2431                 :            : }
    2432                 :            : 
    2433                 :            : /* Returns nonzero if X is an expression for a (possibly overloaded)
    2434                 :            :    function.  If "f" is a function or function template, "f", "c->f",
    2435                 :            :    "c.f", "C::f", and "f<int>" will all be considered possibly
    2436                 :            :    overloaded functions.  Returns 2 if the function is actually
    2437                 :            :    overloaded, i.e., if it is impossible to know the type of the
    2438                 :            :    function without performing overload resolution.  */
    2439                 :            :  
    2440                 :            : int
    2441                 :  666937000 : is_overloaded_fn (tree x)
    2442                 :            : {
    2443                 :  666937000 :   STRIP_ANY_LOCATION_WRAPPER (x);
    2444                 :            : 
    2445                 :            :   /* A baselink is also considered an overloaded function.  */
    2446                 :  666937000 :   if (TREE_CODE (x) == OFFSET_REF
    2447                 :  666928000 :       || TREE_CODE (x) == COMPONENT_REF)
    2448                 :   13385500 :     x = TREE_OPERAND (x, 1);
    2449                 :  666937000 :   x = MAYBE_BASELINK_FUNCTIONS (x);
    2450                 :  666937000 :   if (TREE_CODE (x) == TEMPLATE_ID_EXPR)
    2451                 :   18705500 :     x = TREE_OPERAND (x, 0);
    2452                 :            : 
    2453                 :  787600000 :   if (DECL_FUNCTION_TEMPLATE_P (OVL_FIRST (x))
    2454                 :  668362000 :       || (TREE_CODE (x) == OVERLOAD && !OVL_SINGLE_P (x)))
    2455                 :            :     return 2;
    2456                 :            : 
    2457                 :  580830000 :   return OVL_P (x);
    2458                 :            : }
    2459                 :            : 
    2460                 :            : /* X is the CALL_EXPR_FN of a CALL_EXPR.  If X represents a dependent name
    2461                 :            :    (14.6.2), return the IDENTIFIER_NODE for that name.  Otherwise, return
    2462                 :            :    NULL_TREE.  */
    2463                 :            : 
    2464                 :            : tree
    2465                 :   38534900 : dependent_name (tree x)
    2466                 :            : {
    2467                 :   38534900 :   if (identifier_p (x))
    2468                 :            :     return x;
    2469                 :   38409700 :   if (TREE_CODE (x) == TEMPLATE_ID_EXPR)
    2470                 :   17955000 :     x = TREE_OPERAND (x, 0);
    2471                 :   38409700 :   if (OVL_P (x))
    2472                 :   29670000 :     return OVL_NAME (x);
    2473                 :            :   return NULL_TREE;
    2474                 :            : }
    2475                 :            : 
    2476                 :            : /* Returns true iff X is an expression for an overloaded function
    2477                 :            :    whose type cannot be known without performing overload
    2478                 :            :    resolution.  */
    2479                 :            : 
    2480                 :            : bool
    2481                 :   86889600 : really_overloaded_fn (tree x)
    2482                 :            : {
    2483                 :   86889600 :   return is_overloaded_fn (x) == 2;
    2484                 :            : }
    2485                 :            : 
    2486                 :            : /* Get the overload set FROM refers to.  Returns NULL if it's not an
    2487                 :            :    overload set.  */
    2488                 :            : 
    2489                 :            : tree
    2490                 :   54129100 : maybe_get_fns (tree from)
    2491                 :            : {
    2492                 :   54129100 :   STRIP_ANY_LOCATION_WRAPPER (from);
    2493                 :            : 
    2494                 :            :   /* A baselink is also considered an overloaded function.  */
    2495                 :   54129100 :   if (TREE_CODE (from) == OFFSET_REF
    2496                 :   54123600 :       || TREE_CODE (from) == COMPONENT_REF)
    2497                 :     567552 :     from = TREE_OPERAND (from, 1);
    2498                 :   54129100 :   if (BASELINK_P (from))
    2499                 :   11248000 :     from = BASELINK_FUNCTIONS (from);
    2500                 :   54129100 :   if (TREE_CODE (from) == TEMPLATE_ID_EXPR)
    2501                 :   10821200 :     from = TREE_OPERAND (from, 0);
    2502                 :            : 
    2503                 :   54129100 :   if (OVL_P (from))
    2504                 :   54129100 :     return from;
    2505                 :            : 
    2506                 :            :   return NULL;
    2507                 :            : }
    2508                 :            : 
    2509                 :            : /* FROM refers to an overload set.  Return that set (or die).  */
    2510                 :            : 
    2511                 :            : tree
    2512                 :   54129100 : get_fns (tree from)
    2513                 :            : {
    2514                 :   54129100 :   tree res = maybe_get_fns (from);
    2515                 :            : 
    2516                 :   54129100 :   gcc_assert (res);
    2517                 :   54129100 :   return res;
    2518                 :            : }
    2519                 :            : 
    2520                 :            : /* Return the first function of the overload set FROM refers to.  */
    2521                 :            : 
    2522                 :            : tree
    2523                 :   45102900 : get_first_fn (tree from)
    2524                 :            : {
    2525                 :   45102900 :   return OVL_FIRST (get_fns (from));
    2526                 :            : }
    2527                 :            : 
    2528                 :            : /* Return the scope where the overloaded functions OVL were found.  */
    2529                 :            : 
    2530                 :            : tree
    2531                 :   19789400 : ovl_scope (tree ovl)
    2532                 :            : {
    2533                 :   19789400 :   if (TREE_CODE (ovl) == OFFSET_REF
    2534                 :   19789400 :       || TREE_CODE (ovl) == COMPONENT_REF)
    2535                 :          0 :     ovl = TREE_OPERAND (ovl, 1);
    2536                 :   19789400 :   if (TREE_CODE (ovl) == BASELINK)
    2537                 :          0 :     return BINFO_TYPE (BASELINK_BINFO (ovl));
    2538                 :   19789400 :   if (TREE_CODE (ovl) == TEMPLATE_ID_EXPR)
    2539                 :    7395640 :     ovl = TREE_OPERAND (ovl, 0);
    2540                 :            :   /* Skip using-declarations.  */
    2541                 :   19789400 :   lkp_iterator iter (ovl);
    2542                 :   20007200 :   do
    2543                 :   20007200 :     ovl = *iter;
    2544                 :   20347100 :   while (iter.using_p () && ++iter);
    2545                 :            : 
    2546                 :   19789400 :   return CP_DECL_CONTEXT (ovl);
    2547                 :            : }
    2548                 :            : 
    2549                 :            : #define PRINT_RING_SIZE 4
    2550                 :            : 
    2551                 :            : static const char *
    2552                 :      91666 : cxx_printable_name_internal (tree decl, int v, bool translate)
    2553                 :            : {
    2554                 :      91666 :   static unsigned int uid_ring[PRINT_RING_SIZE];
    2555                 :      91666 :   static char *print_ring[PRINT_RING_SIZE];
    2556                 :      91666 :   static bool trans_ring[PRINT_RING_SIZE];
    2557                 :      91666 :   static int ring_counter;
    2558                 :      91666 :   int i;
    2559                 :            : 
    2560                 :            :   /* Only cache functions.  */
    2561                 :      91666 :   if (v < 2
    2562                 :      52684 :       || TREE_CODE (decl) != FUNCTION_DECL
    2563                 :     142507 :       || DECL_LANG_SPECIFIC (decl) == 0)
    2564                 :      42004 :     return lang_decl_name (decl, v, translate);
    2565                 :            : 
    2566                 :            :   /* See if this print name is lying around.  */
    2567                 :     223773 :   for (i = 0; i < PRINT_RING_SIZE; i++)
    2568                 :     184212 :     if (uid_ring[i] == DECL_UID (decl) && translate == trans_ring[i])
    2569                 :            :       /* yes, so return it.  */
    2570                 :      10101 :       return print_ring[i];
    2571                 :            : 
    2572                 :      39561 :   if (++ring_counter == PRINT_RING_SIZE)
    2573                 :       5060 :     ring_counter = 0;
    2574                 :            : 
    2575                 :      39561 :   if (current_function_decl != NULL_TREE)
    2576                 :            :     {
    2577                 :            :       /* There may be both translated and untranslated versions of the
    2578                 :            :          name cached.  */
    2579                 :      94218 :       for (i = 0; i < 2; i++)
    2580                 :            :         {
    2581                 :      62812 :           if (uid_ring[ring_counter] == DECL_UID (current_function_decl))
    2582                 :         96 :             ring_counter += 1;
    2583                 :      62812 :           if (ring_counter == PRINT_RING_SIZE)
    2584                 :          8 :             ring_counter = 0;
    2585                 :            :         }
    2586                 :      31406 :       gcc_assert (uid_ring[ring_counter] != DECL_UID (current_function_decl));
    2587                 :            :     }
    2588                 :            : 
    2589                 :      39561 :   free (print_ring[ring_counter]);
    2590                 :            : 
    2591                 :      39561 :   print_ring[ring_counter] = xstrdup (lang_decl_name (decl, v, translate));
    2592                 :      39561 :   uid_ring[ring_counter] = DECL_UID (decl);
    2593                 :      39561 :   trans_ring[ring_counter] = translate;
    2594                 :      39561 :   return print_ring[ring_counter];
    2595                 :            : }
    2596                 :            : 
    2597                 :            : const char *
    2598                 :      74580 : cxx_printable_name (tree decl, int v)
    2599                 :            : {
    2600                 :      74580 :   return cxx_printable_name_internal (decl, v, false);
    2601                 :            : }
    2602                 :            : 
    2603                 :            : const char *
    2604                 :      17086 : cxx_printable_name_translate (tree decl, int v)
    2605                 :            : {
    2606                 :      17086 :   return cxx_printable_name_internal (decl, v, true);
    2607                 :            : }
    2608                 :            : 
    2609                 :            : /* Return the canonical version of exception-specification RAISES for a C++17
    2610                 :            :    function type, for use in type comparison and building TYPE_CANONICAL.  */
    2611                 :            : 
    2612                 :            : tree
    2613                 :    8300980 : canonical_eh_spec (tree raises)
    2614                 :            : {
    2615                 :    8300980 :   if (raises == NULL_TREE)
    2616                 :            :     return raises;
    2617                 :    7281050 :   else if (DEFERRED_NOEXCEPT_SPEC_P (raises)
    2618                 :    5939870 :            || UNPARSED_NOEXCEPT_SPEC_P (raises)
    2619                 :    5865180 :            || uses_template_parms (raises)
    2620                 :    5865180 :            || uses_template_parms (TREE_PURPOSE (raises)))
    2621                 :            :     /* Keep a dependent or deferred exception specification.  */
    2622                 :    1859630 :     return raises;
    2623                 :    5421420 :   else if (nothrow_spec_p (raises))
    2624                 :            :     /* throw() -> noexcept.  */
    2625                 :    5331440 :     return noexcept_true_spec;
    2626                 :            :   else
    2627                 :            :     /* For C++17 type matching, anything else -> nothing.  */
    2628                 :            :     return NULL_TREE;
    2629                 :            : }
    2630                 :            : 
    2631                 :            : tree
    2632                 :   90203800 : build_cp_fntype_variant (tree type, cp_ref_qualifier rqual,
    2633                 :            :                          tree raises, bool late)
    2634                 :            : {
    2635                 :   90203800 :   cp_cv_quals type_quals = TYPE_QUALS (type);
    2636                 :            : 
    2637                 :   90203800 :   if (cp_check_qualified_type (type, type, type_quals, rqual, raises, late))
    2638                 :            :     return type;
    2639                 :            : 
    2640                 :   29112400 :   tree v = TYPE_MAIN_VARIANT (type);
    2641                 :   59854100 :   for (; v; v = TYPE_NEXT_VARIANT (v))
    2642                 :   42430300 :     if (cp_check_qualified_type (v, type, type_quals, rqual, raises, late))
    2643                 :   11688600 :       return v;
    2644                 :            : 
    2645                 :            :   /* Need to build a new variant.  */
    2646                 :   17423800 :   v = build_variant_type_copy (type);
    2647                 :   27494200 :   TYPE_RAISES_EXCEPTIONS (v) = raises;
    2648                 :   27494200 :   TYPE_HAS_LATE_RETURN_TYPE (v) = late;
    2649                 :   17423800 :   switch (rqual)
    2650                 :            :     {
    2651                 :      36694 :     case REF_QUAL_RVALUE:
    2652                 :      73337 :       FUNCTION_RVALUE_QUALIFIED (v) = 1;
    2653                 :      73337 :       FUNCTION_REF_QUALIFIED (v) = 1;
    2654                 :      36694 :       break;
    2655                 :      39564 :     case REF_QUAL_LVALUE:
    2656                 :      78973 :       FUNCTION_RVALUE_QUALIFIED (v) = 0;
    2657                 :      78973 :       FUNCTION_REF_QUALIFIED (v) = 1;
    2658                 :      39564 :       break;
    2659                 :   17347500 :     default:
    2660                 :   27341900 :       FUNCTION_REF_QUALIFIED (v) = 0;
    2661                 :   17347500 :       break;
    2662                 :            :     }
    2663                 :            : 
    2664                 :            :   /* Canonicalize the exception specification.  */
    2665                 :   17423800 :   tree cr = flag_noexcept_type ? canonical_eh_spec (raises) : NULL_TREE;
    2666                 :            : 
    2667                 :   17423800 :   if (TYPE_STRUCTURAL_EQUALITY_P (type))
    2668                 :            :     /* Propagate structural equality. */
    2669                 :    1346470 :     SET_TYPE_STRUCTURAL_EQUALITY (v);
    2670                 :   16077300 :   else if (TYPE_CANONICAL (type) != type || cr != raises || late)
    2671                 :            :     /* Build the underlying canonical type, since it is different
    2672                 :            :        from TYPE. */
    2673                 :   12092700 :     TYPE_CANONICAL (v) = build_cp_fntype_variant (TYPE_CANONICAL (type),
    2674                 :            :                                                   rqual, cr, false);
    2675                 :            :   else
    2676                 :            :     /* T is its own canonical type. */
    2677                 :    3984580 :     TYPE_CANONICAL (v) = v;
    2678                 :            : 
    2679                 :            :   return v;
    2680                 :            : }
    2681                 :            : 
    2682                 :            : /* Build the FUNCTION_TYPE or METHOD_TYPE which may throw exceptions
    2683                 :            :    listed in RAISES.  */
    2684                 :            : 
    2685                 :            : tree
    2686                 :   28667400 : build_exception_variant (tree type, tree raises)
    2687                 :            : {
    2688                 :   28667400 :   cp_ref_qualifier rqual = type_memfn_rqual (type);
    2689                 :   48055400 :   bool late = TYPE_HAS_LATE_RETURN_TYPE (type);
    2690                 :   28667400 :   return build_cp_fntype_variant (type, rqual, raises, late);
    2691                 :            : }
    2692                 :            : 
    2693                 :            : /* Given a TEMPLATE_TEMPLATE_PARM node T, create a new
    2694                 :            :    BOUND_TEMPLATE_TEMPLATE_PARM bound with NEWARGS as its template
    2695                 :            :    arguments.  */
    2696                 :            : 
    2697                 :            : tree
    2698                 :      39688 : bind_template_template_parm (tree t, tree newargs)
    2699                 :            : {
    2700                 :      39688 :   tree decl = TYPE_NAME (t);
    2701                 :      39688 :   tree t2;
    2702                 :            : 
    2703                 :      39688 :   t2 = cxx_make_type (BOUND_TEMPLATE_TEMPLATE_PARM);
    2704                 :      39688 :   decl = build_decl (input_location,
    2705                 :      39688 :                      TYPE_DECL, DECL_NAME (decl), NULL_TREE);
    2706                 :            : 
    2707                 :            :   /* These nodes have to be created to reflect new TYPE_DECL and template
    2708                 :            :      arguments.  */
    2709                 :     119064 :   TEMPLATE_TYPE_PARM_INDEX (t2) = copy_node (TEMPLATE_TYPE_PARM_INDEX (t));
    2710                 :      79376 :   TEMPLATE_PARM_DECL (TEMPLATE_TYPE_PARM_INDEX (t2)) = decl;
    2711                 :      39688 :   TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (t2)
    2712                 :     119064 :     = build_template_info (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t), newargs);
    2713                 :            : 
    2714                 :      39688 :   TREE_TYPE (decl) = t2;
    2715                 :      39688 :   TYPE_NAME (t2) = decl;
    2716                 :      39688 :   TYPE_STUB_DECL (t2) = decl;
    2717                 :      39688 :   TYPE_SIZE (t2) = 0;
    2718                 :      39688 :   SET_TYPE_STRUCTURAL_EQUALITY (t2);
    2719                 :            : 
    2720                 :      39688 :   return t2;
    2721                 :            : }
    2722                 :            : 
    2723                 :            : /* Called from count_trees via walk_tree.  */
    2724                 :            : 
    2725                 :            : static tree
    2726                 :          0 : count_trees_r (tree *tp, int *walk_subtrees, void *data)
    2727                 :            : {
    2728                 :          0 :   ++*((int *) data);
    2729                 :            : 
    2730                 :          0 :   if (TYPE_P (*tp))
    2731                 :          0 :     *walk_subtrees = 0;
    2732                 :            : 
    2733                 :          0 :   return NULL_TREE;
    2734                 :            : }
    2735                 :            : 
    2736                 :            : /* Debugging function for measuring the rough complexity of a tree
    2737                 :            :    representation.  */
    2738                 :            : 
    2739                 :            : int
    2740                 :          0 : count_trees (tree t)
    2741                 :            : {
    2742                 :          0 :   int n_trees = 0;
    2743                 :          0 :   cp_walk_tree_without_duplicates (&t, count_trees_r, &n_trees);
    2744                 :          0 :   return n_trees;
    2745                 :            : }
    2746                 :            : 
    2747                 :            : /* Called from verify_stmt_tree via walk_tree.  */
    2748                 :            : 
    2749                 :            : static tree
    2750                 :     647541 : verify_stmt_tree_r (tree* tp, int * /*walk_subtrees*/, void* data)
    2751                 :            : {
    2752                 :     647541 :   tree t = *tp;
    2753                 :     647541 :   hash_table<nofree_ptr_hash <tree_node> > *statements
    2754                 :            :       = static_cast <hash_table<nofree_ptr_hash <tree_node> > *> (data);
    2755                 :     647541 :   tree_node **slot;
    2756                 :            : 
    2757                 :     647541 :   if (!STATEMENT_CODE_P (TREE_CODE (t)))
    2758                 :            :     return NULL_TREE;
    2759                 :            : 
    2760                 :            :   /* If this statement is already present in the hash table, then
    2761                 :            :      there is a circularity in the statement tree.  */
    2762                 :      35124 :   gcc_assert (!statements->find (t));
    2763                 :            : 
    2764                 :      35124 :   slot = statements->find_slot (t, INSERT);
    2765                 :      35124 :   *slot = t;
    2766                 :            : 
    2767                 :      35124 :   return NULL_TREE;
    2768                 :            : }
    2769                 :            : 
    2770                 :            : /* Debugging function to check that the statement T has not been
    2771                 :            :    corrupted.  For now, this function simply checks that T contains no
    2772                 :            :    circularities.  */
    2773                 :            : 
    2774                 :            : void
    2775                 :       1564 : verify_stmt_tree (tree t)
    2776                 :            : {
    2777                 :       3128 :   hash_table<nofree_ptr_hash <tree_node> > statements (37);
    2778                 :       1564 :   cp_walk_tree (&t, verify_stmt_tree_r, &statements, NULL);
    2779                 :       1564 : }
    2780                 :            : 
    2781                 :            : /* Check if the type T depends on a type with no linkage and if so, return
    2782                 :            :    it.  If RELAXED_P then do not consider a class type declared within
    2783                 :            :    a vague-linkage function to have no linkage.  */
    2784                 :            : 
    2785                 :            : tree
    2786                 :   62959800 : no_linkage_check (tree t, bool relaxed_p)
    2787                 :            : {
    2788                 :   62959800 :   tree r;
    2789                 :            : 
    2790                 :            :   /* Lambda types that don't have mangling scope have no linkage.  We
    2791                 :            :      check CLASSTYPE_LAMBDA_EXPR for error_mark_node because
    2792                 :            :      when we get here from pushtag none of the lambda information is
    2793                 :            :      set up yet, so we want to assume that the lambda has linkage and
    2794                 :            :      fix it up later if not.  We need to check this even in templates so
    2795                 :            :      that we properly handle a lambda-expression in the signature.  */
    2796                 :   35718300 :   if (LAMBDA_TYPE_P (t)
    2797                 :   63066000 :       && CLASSTYPE_LAMBDA_EXPR (t) != error_mark_node)
    2798                 :            :     {
    2799                 :      63257 :       tree extra = LAMBDA_TYPE_EXTRA_SCOPE (t);
    2800                 :      63257 :       if (!extra)
    2801                 :            :         return t;
    2802                 :            : 
    2803                 :            :       /* If the mangling scope is internal-linkage or not repeatable
    2804                 :            :          elsewhere, the lambda effectively has no linkage.  (Sadly
    2805                 :            :          we're not very careful with the linkages of types.)  */
    2806                 :      62979 :       if (TREE_CODE (extra) == VAR_DECL
    2807                 :      62979 :           && !(TREE_PUBLIC (extra)
    2808                 :       8243 :                && (processing_template_decl
    2809                 :       7927 :                    || (DECL_LANG_SPECIFIC (extra) && DECL_USE_TEMPLATE (extra))
    2810                 :            :                    /* DECL_COMDAT is set too late for us to check.  */
    2811                 :      15079 :                    || DECL_VAR_DECLARED_INLINE_P (extra))))
    2812                 :            :         return t;
    2813                 :            :     }
    2814                 :            : 
    2815                 :            :   /* Otherwise there's no point in checking linkage on template functions; we
    2816                 :            :      can't know their complete types.  */
    2817                 :   62959000 :   if (processing_template_decl)
    2818                 :            :     return NULL_TREE;
    2819                 :            : 
    2820                 :   51958100 :   switch (TREE_CODE (t))
    2821                 :            :     {
    2822                 :   27615200 :     case RECORD_TYPE:
    2823                 :   27615200 :       if (TYPE_PTRMEMFUNC_P (t))
    2824                 :      53717 :         goto ptrmem;
    2825                 :            :       /* Fall through.  */
    2826                 :   28109800 :     case UNION_TYPE:
    2827                 :   56219700 :       if (!CLASS_TYPE_P (t))
    2828                 :            :         return NULL_TREE;
    2829                 :            :       /* Fall through.  */
    2830                 :   28744300 :     case ENUMERAL_TYPE:
    2831                 :            :       /* Only treat unnamed types as having no linkage if they're at
    2832                 :            :          namespace scope.  This is core issue 966.  */
    2833                 :   28744300 :       if (TYPE_UNNAMED_P (t) && TYPE_NAMESPACE_SCOPE_P (t))
    2834                 :            :         return t;
    2835                 :            : 
    2836                 :   28608800 :       for (r = CP_TYPE_CONTEXT (t); ; )
    2837                 :            :         {
    2838                 :            :           /* If we're a nested type of a !TREE_PUBLIC class, we might not
    2839                 :            :              have linkage, or we might just be in an anonymous namespace.
    2840                 :            :              If we're in a TREE_PUBLIC class, we have linkage.  */
    2841                 :    2053550 :           if (TYPE_P (r) && !TREE_PUBLIC (TYPE_NAME (r)))
    2842                 :       6626 :             return no_linkage_check (TYPE_CONTEXT (t), relaxed_p);
    2843                 :   29434700 :           else if (TREE_CODE (r) == FUNCTION_DECL)
    2844                 :            :             {
    2845                 :     858271 :               if (!relaxed_p || !vague_linkage_p (r))
    2846                 :      25723 :                 return t;
    2847                 :            :               else
    2848                 :   30273900 :                 r = CP_DECL_CONTEXT (r);
    2849                 :            :             }
    2850                 :            :           else
    2851                 :            :             break;
    2852                 :            :         }
    2853                 :            : 
    2854                 :            :       return NULL_TREE;
    2855                 :            : 
    2856                 :    7963310 :     case ARRAY_TYPE:
    2857                 :    7963310 :     case POINTER_TYPE:
    2858                 :    7963310 :     case REFERENCE_TYPE:
    2859                 :    7963310 :     case VECTOR_TYPE:
    2860                 :    7963310 :       return no_linkage_check (TREE_TYPE (t), relaxed_p);
    2861                 :            : 
    2862                 :      55622 :     case OFFSET_TYPE:
    2863                 :      55622 :     ptrmem:
    2864                 :      57527 :       r = no_linkage_check (TYPE_PTRMEM_POINTED_TO_TYPE (t),
    2865                 :            :                             relaxed_p);
    2866                 :      55622 :       if (r)
    2867                 :            :         return r;
    2868                 :     109339 :       return no_linkage_check (TYPE_PTRMEM_CLASS_TYPE (t), relaxed_p);
    2869                 :            : 
    2870                 :    5967300 :     case METHOD_TYPE:
    2871                 :    5967300 :     case FUNCTION_TYPE:
    2872                 :    5967300 :       {
    2873                 :    5967300 :         tree parm = TYPE_ARG_TYPES (t);
    2874                 :    5967300 :         if (TREE_CODE (t) == METHOD_TYPE)
    2875                 :            :           /* The 'this' pointer isn't interesting; a method has the same
    2876                 :            :              linkage (or lack thereof) as its enclosing class.  */
    2877                 :    3185810 :           parm = TREE_CHAIN (parm);
    2878                 :    7185890 :         for (;
    2879                 :   13153200 :              parm && parm != void_list_node;
    2880                 :    7185890 :              parm = TREE_CHAIN (parm))
    2881                 :            :           {
    2882                 :    7205000 :             r = no_linkage_check (TREE_VALUE (parm), relaxed_p);
    2883                 :    7205000 :             if (r)
    2884                 :      19118 :               return r;
    2885                 :            :           }
    2886                 :    5948180 :         return no_linkage_check (TREE_TYPE (t), relaxed_p);
    2887                 :            :       }
    2888                 :            : 
    2889                 :            :     default:
    2890                 :            :       return NULL_TREE;
    2891                 :            :     }
    2892                 :            : }
    2893                 :            : 
    2894                 :            : extern int depth_reached;
    2895                 :            : 
    2896                 :            : void
    2897                 :          0 : cxx_print_statistics (void)
    2898                 :            : {
    2899                 :          0 :   print_template_statistics ();
    2900                 :          0 :   if (GATHER_STATISTICS)
    2901                 :            :     fprintf (stderr, "maximum template instantiation depth reached: %d\n",
    2902                 :            :              depth_reached);
    2903                 :          0 : }
    2904                 :            : 
    2905                 :            : /* Return, as an INTEGER_CST node, the number of elements for TYPE
    2906                 :            :    (which is an ARRAY_TYPE).  This counts only elements of the top
    2907                 :            :    array.  */
    2908                 :            : 
    2909                 :            : tree
    2910                 :     439391 : array_type_nelts_top (tree type)
    2911                 :            : {
    2912                 :     439391 :   return fold_build2_loc (input_location,
    2913                 :            :                       PLUS_EXPR, sizetype,
    2914                 :            :                       array_type_nelts (type),
    2915                 :     439391 :                       size_one_node);
    2916                 :            : }
    2917                 :            : 
    2918                 :            : /* Return, as an INTEGER_CST node, the number of elements for TYPE
    2919                 :            :    (which is an ARRAY_TYPE).  This one is a recursive count of all
    2920                 :            :    ARRAY_TYPEs that are clumped together.  */
    2921                 :            : 
    2922                 :            : tree
    2923                 :       2384 : array_type_nelts_total (tree type)
    2924                 :            : {
    2925                 :       2384 :   tree sz = array_type_nelts_top (type);
    2926                 :       2384 :   type = TREE_TYPE (type);
    2927                 :       2647 :   while (TREE_CODE (type) == ARRAY_TYPE)
    2928                 :            :     {
    2929                 :        263 :       tree n = array_type_nelts_top (type);
    2930                 :        263 :       sz = fold_build2_loc (input_location,
    2931                 :            :                         MULT_EXPR, sizetype, sz, n);
    2932                 :        263 :       type = TREE_TYPE (type);
    2933                 :            :     }
    2934                 :       2384 :   return sz;
    2935                 :            : }
    2936                 :            : 
    2937                 :            : struct bot_data
    2938                 :            : {
    2939                 :            :   splay_tree target_remap;
    2940                 :            :   bool clear_location;
    2941                 :            : };
    2942                 :            : 
    2943                 :            : /* Called from break_out_target_exprs via mapcar.  */
    2944                 :            : 
    2945                 :            : static tree
    2946                 :    4035440 : bot_manip (tree* tp, int* walk_subtrees, void* data_)
    2947                 :            : {
    2948                 :    4035440 :   bot_data &data = *(bot_data*)data_;
    2949                 :    4035440 :   splay_tree target_remap = data.target_remap;
    2950                 :    4035440 :   tree t = *tp;
    2951                 :            : 
    2952                 :    4035440 :   if (!TYPE_P (t) && TREE_CONSTANT (t) && !TREE_SIDE_EFFECTS (t))
    2953                 :            :     {
    2954                 :            :       /* There can't be any TARGET_EXPRs or their slot variables below this
    2955                 :            :          point.  But we must make a copy, in case subsequent processing
    2956                 :            :          alters any part of it.  For example, during gimplification a cast
    2957                 :            :          of the form (T) &X::f (where "f" is a member function) will lead
    2958                 :            :          to replacing the PTRMEM_CST for &X::f with a VAR_DECL.  */
    2959                 :    1230070 :       *walk_subtrees = 0;
    2960                 :    1230070 :       *tp = unshare_expr (t);
    2961                 :    1230070 :       return NULL_TREE;
    2962                 :            :     }
    2963                 :    2805370 :   if (TREE_CODE (t) == TARGET_EXPR)
    2964                 :            :     {
    2965                 :      68175 :       tree u;
    2966                 :            : 
    2967                 :      68175 :       if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)
    2968                 :            :         {
    2969                 :      63669 :           u = build_cplus_new (TREE_TYPE (t), TREE_OPERAND (t, 1),
    2970                 :            :                                tf_warning_or_error);
    2971                 :      63669 :           if (u == error_mark_node)
    2972                 :            :             return u;
    2973                 :      63669 :           if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t, 1)))
    2974                 :        311 :             AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u, 1)) = true;
    2975                 :            :         }
    2976                 :            :       else
    2977                 :       4506 :         u = build_target_expr_with_type (TREE_OPERAND (t, 1), TREE_TYPE (t),
    2978                 :            :                                          tf_warning_or_error);
    2979                 :            : 
    2980                 :      68175 :       TARGET_EXPR_IMPLICIT_P (u) = TARGET_EXPR_IMPLICIT_P (t);
    2981                 :      68175 :       TARGET_EXPR_LIST_INIT_P (u) = TARGET_EXPR_LIST_INIT_P (t);
    2982                 :      68175 :       TARGET_EXPR_DIRECT_INIT_P (u) = TARGET_EXPR_DIRECT_INIT_P (t);
    2983                 :            : 
    2984                 :            :       /* Map the old variable to the new one.  */
    2985                 :     204525 :       splay_tree_insert (target_remap,
    2986                 :      68175 :                          (splay_tree_key) TREE_OPERAND (t, 0),
    2987                 :      68175 :                          (splay_tree_value) TREE_OPERAND (u, 0));
    2988                 :            : 
    2989                 :      68175 :       TREE_OPERAND (u, 1) = break_out_target_exprs (TREE_OPERAND (u, 1),
    2990                 :      68175 :                                                     data.clear_location);
    2991                 :      68175 :       if (TREE_OPERAND (u, 1) == error_mark_node)
    2992                 :            :         return error_mark_node;
    2993                 :            : 
    2994                 :            :       /* Replace the old expression with the new version.  */
    2995                 :      68175 :       *tp = u;
    2996                 :            :       /* We don't have to go below this point; the recursive call to
    2997                 :            :          break_out_target_exprs will have handled anything below this
    2998                 :            :          point.  */
    2999                 :      68175 :       *walk_subtrees = 0;
    3000                 :      68175 :       return NULL_TREE;
    3001                 :            :     }
    3002                 :    2737200 :   if (TREE_CODE (*tp) == SAVE_EXPR)
    3003                 :            :     {
    3004                 :       1252 :       t = *tp;
    3005                 :       1252 :       splay_tree_node n = splay_tree_lookup (target_remap,
    3006                 :            :                                              (splay_tree_key) t);
    3007                 :       1252 :       if (n)
    3008                 :            :         {
    3009                 :        627 :           *tp = (tree)n->value;
    3010                 :        627 :           *walk_subtrees = 0;
    3011                 :            :         }
    3012                 :            :       else
    3013                 :            :         {
    3014                 :        625 :           copy_tree_r (tp, walk_subtrees, NULL);
    3015                 :        625 :           splay_tree_insert (target_remap,
    3016                 :            :                              (splay_tree_key)t,
    3017                 :        625 :                              (splay_tree_value)*tp);
    3018                 :            :           /* Make sure we don't remap an already-remapped SAVE_EXPR.  */
    3019                 :        625 :           splay_tree_insert (target_remap,
    3020                 :            :                              (splay_tree_key)*tp,
    3021                 :        625 :                              (splay_tree_value)*tp);
    3022                 :            :         }
    3023                 :       1252 :       return NULL_TREE;
    3024                 :            :     }
    3025                 :            : 
    3026                 :            :   /* Make a copy of this node.  */
    3027                 :    2735950 :   t = copy_tree_r (tp, walk_subtrees, NULL);
    3028                 :    2735950 :   if (TREE_CODE (*tp) == CALL_EXPR || TREE_CODE (*tp) == AGGR_INIT_EXPR)
    3029                 :     455038 :     if (!processing_template_decl)
    3030                 :     455032 :       set_flags_from_callee (*tp);
    3031                 :    2735950 :   if (data.clear_location && EXPR_HAS_LOCATION (*tp))
    3032                 :      10728 :     SET_EXPR_LOCATION (*tp, input_location);
    3033                 :            :   return t;
    3034                 :            : }
    3035                 :            : 
    3036                 :            : /* Replace all remapped VAR_DECLs in T with their new equivalents.
    3037                 :            :    DATA is really a splay-tree mapping old variables to new
    3038                 :            :    variables.  */
    3039                 :            : 
    3040                 :            : static tree
    3041                 :    5871680 : bot_replace (tree* t, int* /*walk_subtrees*/, void* data_)
    3042                 :            : {
    3043                 :    5871680 :   bot_data &data = *(bot_data*)data_;
    3044                 :    5871680 :   splay_tree target_remap = data.target_remap;
    3045                 :            : 
    3046                 :    5871680 :   if (VAR_P (*t))
    3047                 :            :     {
    3048                 :     288003 :       splay_tree_node n = splay_tree_lookup (target_remap,
    3049                 :            :                                              (splay_tree_key) *t);
    3050                 :     288003 :       if (n)
    3051                 :        450 :         *t = (tree) n->value;
    3052                 :            :     }
    3053                 :    5583680 :   else if (TREE_CODE (*t) == PARM_DECL
    3054                 :     460076 :            && DECL_NAME (*t) == this_identifier
    3055                 :    5783630 :            && !DECL_CONTEXT (*t))
    3056                 :            :     {
    3057                 :            :       /* In an NSDMI we need to replace the 'this' parameter we used for
    3058                 :            :          parsing with the real one for this function.  */
    3059                 :       2271 :       *t = current_class_ptr;
    3060                 :            :     }
    3061                 :    5581400 :   else if (TREE_CODE (*t) == CONVERT_EXPR
    3062                 :    5581400 :            && CONVERT_EXPR_VBASE_PATH (*t))
    3063                 :            :     {
    3064                 :            :       /* In an NSDMI build_base_path defers building conversions to virtual
    3065                 :            :          bases, and we handle it here.  */
    3066                 :         36 :       tree basetype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (*t)));
    3067                 :         36 :       vec<tree, va_gc> *vbases = CLASSTYPE_VBASECLASSES (current_class_type);
    3068                 :         36 :       int i; tree binfo;
    3069                 :         36 :       FOR_EACH_VEC_SAFE_ELT (vbases, i, binfo)
    3070                 :         36 :         if (BINFO_TYPE (binfo) == basetype)
    3071                 :            :           break;
    3072                 :         36 :       *t = build_base_path (PLUS_EXPR, TREE_OPERAND (*t, 0), binfo, true,
    3073                 :            :                             tf_warning_or_error);
    3074                 :            :     }
    3075                 :            : 
    3076                 :    5871680 :   return NULL_TREE;
    3077                 :            : }
    3078                 :            : 
    3079                 :            : /* When we parse a default argument expression, we may create
    3080                 :            :    temporary variables via TARGET_EXPRs.  When we actually use the
    3081                 :            :    default-argument expression, we make a copy of the expression
    3082                 :            :    and replace the temporaries with appropriate local versions.
    3083                 :            : 
    3084                 :            :    If CLEAR_LOCATION is true, override any EXPR_LOCATION with
    3085                 :            :    input_location.  */
    3086                 :            : 
    3087                 :            : tree
    3088                 :     960435 : break_out_target_exprs (tree t, bool clear_location /* = false */)
    3089                 :            : {
    3090                 :     960435 :   static int target_remap_count;
    3091                 :     960435 :   static splay_tree target_remap;
    3092                 :            : 
    3093                 :     960435 :   if (!target_remap_count++)
    3094                 :     892260 :     target_remap = splay_tree_new (splay_tree_compare_pointers,
    3095                 :            :                                    /*splay_tree_delete_key_fn=*/NULL,
    3096                 :            :                                    /*splay_tree_delete_value_fn=*/NULL);
    3097                 :     960435 :   bot_data data = { target_remap, clear_location };
    3098                 :     960435 :   if (cp_walk_tree (&t, bot_manip, &data, NULL) == error_mark_node)
    3099                 :          0 :     t = error_mark_node;
    3100                 :     960435 :   cp_walk_tree (&t, bot_replace, &data, NULL);
    3101                 :            : 
    3102                 :     960435 :   if (!--target_remap_count)
    3103                 :            :     {
    3104                 :     892260 :       splay_tree_delete (target_remap);
    3105                 :     892260 :       target_remap = NULL;
    3106                 :            :     }
    3107                 :            : 
    3108                 :     960435 :   return t;
    3109                 :            : }
    3110                 :            : 
    3111                 :            : /* Build an expression for the subobject of OBJ at CONSTRUCTOR index INDEX,
    3112                 :            :    which we expect to have type TYPE.  */
    3113                 :            : 
    3114                 :            : tree
    3115                 :       1060 : build_ctor_subob_ref (tree index, tree type, tree obj)
    3116                 :            : {
    3117                 :       1060 :   if (index == NULL_TREE)
    3118                 :            :     /* Can't refer to a particular member of a vector.  */
    3119                 :            :     obj = NULL_TREE;
    3120                 :       1060 :   else if (TREE_CODE (index) == INTEGER_CST)
    3121                 :        478 :     obj = cp_build_array_ref (input_location, obj, index, tf_none);
    3122                 :            :   else
    3123                 :        582 :     obj = build_class_member_access_expr (obj, index, NULL_TREE,
    3124                 :            :                                           /*reference*/false, tf_none);
    3125                 :       1060 :   if (obj)
    3126                 :            :     {
    3127                 :       1060 :       tree objtype = TREE_TYPE (obj);
    3128                 :       1060 :       if (TREE_CODE (objtype) == ARRAY_TYPE && !TYPE_DOMAIN (objtype))
    3129                 :            :         {
    3130                 :            :           /* When the destination object refers to a flexible array member
    3131                 :            :              verify that it matches the type of the source object except
    3132                 :            :              for its domain and qualifiers.  */
    3133                 :         74 :           gcc_assert (comptypes (TYPE_MAIN_VARIANT (type),
    3134                 :            :                                  TYPE_MAIN_VARIANT (objtype),
    3135                 :            :                                  COMPARE_REDECLARATION));
    3136                 :            :         }
    3137                 :            :       else
    3138                 :        986 :         gcc_assert (same_type_ignoring_top_level_qualifiers_p (type, objtype));
    3139                 :            :     }
    3140                 :            : 
    3141                 :       1060 :   return obj;
    3142                 :            : }
    3143                 :            : 
    3144                 :            : struct replace_placeholders_t
    3145                 :            : {
    3146                 :            :   tree obj;         /* The object to be substituted for a PLACEHOLDER_EXPR.  */
    3147                 :            :   tree exp;         /* The outermost exp.  */
    3148                 :            :   bool seen;        /* Whether we've encountered a PLACEHOLDER_EXPR.  */
    3149                 :            :   hash_set<tree> *pset;   /* To avoid walking same trees multiple times.  */
    3150                 :            : };
    3151                 :            : 
    3152                 :            : /* Like substitute_placeholder_in_expr, but handle C++ tree codes and
    3153                 :            :    build up subexpressions as we go deeper.  */
    3154                 :            : 
    3155                 :            : static tree
    3156                 :    5718860 : replace_placeholders_r (tree* t, int* walk_subtrees, void* data_)
    3157                 :            : {
    3158                 :    5718860 :   replace_placeholders_t *d = static_cast<replace_placeholders_t*>(data_);
    3159                 :    5718860 :   tree obj = d->obj;
    3160                 :            : 
    3161                 :    5718860 :   if (TYPE_P (*t) || TREE_CONSTANT (*t))
    3162                 :            :     {
    3163                 :    2001560 :       *walk_subtrees = false;
    3164                 :    2001560 :       return NULL_TREE;
    3165                 :            :     }
    3166                 :            : 
    3167                 :    3717300 :   switch (TREE_CODE (*t))
    3168                 :            :     {
    3169                 :            :     case PLACEHOLDER_EXPR:
    3170                 :            :       {
    3171                 :            :         tree x = obj;
    3172                 :        258 :         for (; !same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (*t),
    3173                 :        129 :                                                            TREE_TYPE (x));
    3174                 :         39 :              x = TREE_OPERAND (x, 0))
    3175                 :         39 :           gcc_assert (handled_component_p (x));
    3176                 :         90 :         *t = unshare_expr (x);
    3177                 :         90 :         *walk_subtrees = false;
    3178                 :         90 :         d->seen = true;
    3179                 :            :       }
    3180                 :         90 :       break;
    3181                 :            : 
    3182                 :      22638 :     case CONSTRUCTOR:
    3183                 :      22638 :       {
    3184                 :      22638 :         constructor_elt *ce;
    3185                 :      22638 :         vec<constructor_elt,va_gc> *v = CONSTRUCTOR_ELTS (*t);
    3186                 :            :         /* Don't walk into CONSTRUCTOR_PLACEHOLDER_BOUNDARY ctors
    3187                 :            :            other than the d->exp one, those have PLACEHOLDER_EXPRs
    3188                 :            :            related to another object.  */
    3189                 :      22638 :         if ((CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t)
    3190                 :         94 :              && *t != d->exp)
    3191                 :      22696 :             || d->pset->add (*t))
    3192                 :            :           {
    3193                 :         36 :             *walk_subtrees = false;
    3194                 :         36 :             return NULL_TREE;
    3195                 :            :           }
    3196                 :      77740 :         for (unsigned i = 0; vec_safe_iterate (v, i, &ce); ++i)
    3197                 :            :           {
    3198                 :      55138 :             tree *valp = &ce->value;
    3199                 :      55138 :             tree type = TREE_TYPE (*valp);
    3200                 :      55138 :             tree subob = obj;
    3201                 :            : 
    3202                 :            :             /* Elements with RANGE_EXPR index shouldn't have any
    3203                 :            :                placeholders in them.  */
    3204                 :      55138 :             if (ce->index && TREE_CODE (ce->index) == RANGE_EXPR)
    3205                 :          3 :               continue;
    3206                 :            : 
    3207                 :      55135 :             if (TREE_CODE (*valp) == CONSTRUCTOR
    3208                 :        538 :                 && AGGREGATE_TYPE_P (type))
    3209                 :            :               {
    3210                 :            :                 /* If we're looking at the initializer for OBJ, then build
    3211                 :            :                    a sub-object reference.  If we're looking at an
    3212                 :            :                    initializer for another object, just pass OBJ down.  */
    3213                 :       1034 :                 if (same_type_ignoring_top_level_qualifiers_p
    3214                 :        517 :                     (TREE_TYPE (*t), TREE_TYPE (obj)))
    3215                 :        475 :                   subob = build_ctor_subob_ref (ce->index, type, obj);
    3216                 :        517 :                 if (TREE_CODE (*valp) == TARGET_EXPR)
    3217                 :          0 :                   valp = &TARGET_EXPR_INITIAL (*valp);
    3218                 :            :               }
    3219                 :      55135 :             d->obj = subob;
    3220                 :      55135 :             cp_walk_tree (valp, replace_placeholders_r, data_, NULL);
    3221                 :      55135 :             d->obj = obj;
    3222                 :            :           }
    3223                 :      22602 :         *walk_subtrees = false;
    3224                 :      22602 :         break;
    3225                 :            :       }
    3226                 :            : 
    3227                 :    3694570 :     default:
    3228                 :    3694570 :       if (d->pset->add (*t))
    3229                 :     182416 :         *walk_subtrees = false;
    3230                 :            :       break;
    3231                 :            :     }
    3232                 :            : 
    3233                 :            :   return NULL_TREE;
    3234                 :            : }
    3235                 :            : 
    3236                 :            : /* Replace PLACEHOLDER_EXPRs in EXP with object OBJ.  SEEN_P is set if
    3237                 :            :    a PLACEHOLDER_EXPR has been encountered.  */
    3238                 :            : 
    3239                 :            : tree
    3240                 :   10529300 : replace_placeholders (tree exp, tree obj, bool *seen_p)
    3241                 :            : {
    3242                 :            :   /* This is only relevant for C++14.  */
    3243                 :   10529300 :   if (cxx_dialect < cxx14)
    3244                 :    1107570 :     return exp;
    3245                 :            : 
    3246                 :            :   /* If the object isn't a (member of a) class, do nothing.  */
    3247                 :            :   tree op0 = obj;
    3248                 :    9605580 :   while (TREE_CODE (op0) == COMPONENT_REF)
    3249                 :     183803 :     op0 = TREE_OPERAND (op0, 0);
    3250                 :   18851300 :   if (!CLASS_TYPE_P (strip_array_types (TREE_TYPE (op0))))
    3251                 :    8423710 :     return exp;
    3252                 :            : 
    3253                 :     998067 :   tree *tp = &exp;
    3254                 :     998067 :   if (TREE_CODE (exp) == TARGET_EXPR)
    3255                 :      27621 :     tp = &TARGET_EXPR_INITIAL (exp);
    3256                 :     998067 :   hash_set<tree> pset;
    3257                 :     998067 :   replace_placeholders_t data = { obj, *tp, false, &pset };
    3258                 :     998067 :   cp_walk_tree (tp, replace_placeholders_r, &data, NULL);
    3259                 :     998067 :   if (seen_p)
    3260                 :      69788 :     *seen_p = data.seen;
    3261                 :     998067 :   return exp;
    3262                 :            : }
    3263                 :            : 
    3264                 :            : /* Callback function for find_placeholders.  */
    3265                 :            : 
    3266                 :            : static tree
    3267                 :       1930 : find_placeholders_r (tree *t, int *walk_subtrees, void *)
    3268                 :            : {
    3269                 :       1930 :   if (TYPE_P (*t) || TREE_CONSTANT (*t))
    3270                 :            :     {
    3271                 :        815 :       *walk_subtrees = false;
    3272                 :        815 :       return NULL_TREE;
    3273                 :            :     }
    3274                 :            : 
    3275                 :       1115 :   switch (TREE_CODE (*t))
    3276                 :            :     {
    3277                 :            :     case PLACEHOLDER_EXPR:
    3278                 :            :       return *t;
    3279                 :            : 
    3280                 :         27 :     case CONSTRUCTOR:
    3281                 :         27 :       if (CONSTRUCTOR_PLACEHOLDER_BOUNDARY (*t))
    3282                 :          3 :         *walk_subtrees = false;
    3283                 :            :       break;
    3284                 :            : 
    3285                 :            :     default:
    3286                 :            :       break;
    3287                 :            :     }
    3288                 :            : 
    3289                 :            :   return NULL_TREE;
    3290                 :            : }
    3291                 :            : 
    3292                 :            : /* Return true if EXP contains a PLACEHOLDER_EXPR.  Don't walk into
    3293                 :            :    ctors with CONSTRUCTOR_PLACEHOLDER_BOUNDARY flag set.  */
    3294                 :            : 
    3295                 :            : bool
    3296                 :        679 : find_placeholders (tree exp)
    3297                 :            : {
    3298                 :            :   /* This is only relevant for C++14.  */
    3299                 :        679 :   if (cxx_dialect < cxx14)
    3300                 :            :     return false;
    3301                 :            : 
    3302                 :        679 :   return cp_walk_tree_without_duplicates (&exp, find_placeholders_r, NULL);
    3303                 :            : }
    3304                 :            : 
    3305                 :            : /* Similar to `build_nt', but for template definitions of dependent
    3306                 :            :    expressions  */
    3307                 :            : 
    3308                 :            : tree
    3309                 :   18577900 : build_min_nt_loc (location_t loc, enum tree_code code, ...)
    3310                 :            : {
    3311                 :   18577900 :   tree t;
    3312                 :   18577900 :   int length;
    3313                 :   18577900 :   int i;
    3314                 :   18577900 :   va_list p;
    3315                 :            : 
    3316                 :   18577900 :   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
    3317                 :            : 
    3318                 :   18577900 :   va_start (p, code);
    3319                 :            : 
    3320                 :   18577900 :   t = make_node (code);
    3321                 :   18577900 :   SET_EXPR_LOCATION (t, loc);
    3322                 :   18577900 :   length = TREE_CODE_LENGTH (code);
    3323                 :            : 
    3324                 :   57012300 :   for (i = 0; i < length; i++)
    3325                 :   38434500 :     TREE_OPERAND (t, i) = va_arg (p, tree);
    3326                 :            : 
    3327                 :   18577900 :   va_end (p);
    3328                 :   18577900 :   return t;
    3329                 :            : }
    3330                 :            : 
    3331                 :            : /* Similar to `build', but for template definitions.  */
    3332                 :            : 
    3333                 :            : tree
    3334                 :    9499540 : build_min (enum tree_code code, tree tt, ...)
    3335                 :            : {
    3336                 :    9499540 :   tree t;
    3337                 :    9499540 :   int length;
    3338                 :    9499540 :   int i;
    3339                 :    9499540 :   va_list p;
    3340                 :            : 
    3341                 :    9499540 :   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
    3342                 :            : 
    3343                 :    9499540 :   va_start (p, tt);
    3344                 :            : 
    3345                 :    9499540 :   t = make_node (code);
    3346                 :    9499540 :   length = TREE_CODE_LENGTH (code);
    3347                 :    9499540 :   TREE_TYPE (t) = tt;
    3348                 :            : 
    3349                 :   24756600 :   for (i = 0; i < length; i++)
    3350                 :            :     {
    3351                 :   15257100 :       tree x = va_arg (p, tree);
    3352                 :   15257100 :       TREE_OPERAND (t, i) = x;
    3353                 :   15257100 :       if (x && !TYPE_P (x) && TREE_SIDE_EFFECTS (x))
    3354                 :     167525 :         TREE_SIDE_EFFECTS (t) = 1;
    3355                 :            :     }
    3356                 :            : 
    3357                 :    9499540 :   va_end (p);
    3358                 :            : 
    3359                 :    9499540 :   return t;
    3360                 :            : }
    3361                 :            : 
    3362                 :            : /* Similar to `build', but for template definitions of non-dependent
    3363                 :            :    expressions. NON_DEP is the non-dependent expression that has been
    3364                 :            :    built.  */
    3365                 :            : 
    3366                 :            : tree
    3367                 :    5825380 : build_min_non_dep (enum tree_code code, tree non_dep, ...)
    3368                 :            : {
    3369                 :    5825380 :   tree t;
    3370                 :    5825380 :   int length;
    3371                 :    5825380 :   int i;
    3372                 :    5825380 :   va_list p;
    3373                 :            : 
    3374                 :    5825380 :   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
    3375                 :            : 
    3376                 :    5825380 :   va_start (p, non_dep);
    3377                 :            : 
    3378                 :    5825380 :   if (REFERENCE_REF_P (non_dep))
    3379                 :        198 :     non_dep = TREE_OPERAND (non_dep, 0);
    3380                 :            : 
    3381                 :    5825380 :   t = make_node (code);
    3382                 :    5825380 :   SET_EXPR_LOCATION (t, cp_expr_loc_or_input_loc (non_dep));
    3383                 :    5825380 :   length = TREE_CODE_LENGTH (code);
    3384                 :    5825380 :   TREE_TYPE (t) = unlowered_expr_type (non_dep);
    3385                 :    5825380 :   TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
    3386                 :            : 
    3387                 :   20222400 :   for (i = 0; i < length; i++)
    3388                 :   14397000 :     TREE_OPERAND (t, i) = va_arg (p, tree);
    3389                 :            : 
    3390                 :    5825380 :   if (code == COMPOUND_EXPR && TREE_CODE (non_dep) != COMPOUND_EXPR)
    3391                 :            :     /* This should not be considered a COMPOUND_EXPR, because it
    3392                 :            :        resolves to an overload.  */
    3393                 :          0 :     COMPOUND_EXPR_OVERLOADED (t) = 1;
    3394                 :            : 
    3395                 :    5825380 :   va_end (p);
    3396                 :    5825380 :   return convert_from_reference (t);
    3397                 :            : }
    3398                 :            : 
    3399                 :            : /* Similar to build_min_nt, but call expressions  */
    3400                 :            : 
    3401                 :            : tree
    3402                 :   13528800 : build_min_nt_call_vec (tree fn, vec<tree, va_gc> *args)
    3403                 :            : {
    3404                 :   13528800 :   tree ret, t;
    3405                 :   13528800 :   unsigned int ix;
    3406                 :            : 
    3407                 :   27056900 :   ret = build_vl_exp (CALL_EXPR, vec_safe_length (args) + 3);
    3408                 :   13528800 :   CALL_EXPR_FN (ret) = fn;
    3409                 :   13528800 :   CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
    3410                 :   26835800 :   FOR_EACH_VEC_SAFE_ELT (args, ix, t)
    3411                 :   13307000 :     CALL_EXPR_ARG (ret, ix) = t;
    3412                 :            : 
    3413                 :   13528800 :   return ret;
    3414                 :            : }
    3415                 :            : 
    3416                 :            : /* Similar to `build_min_nt_call_vec', but for template definitions of
    3417                 :            :    non-dependent expressions. NON_DEP is the non-dependent expression
    3418                 :            :    that has been built.  */
    3419                 :            : 
    3420                 :            : tree
    3421                 :     939400 : build_min_non_dep_call_vec (tree non_dep, tree fn, vec<tree, va_gc> *argvec)
    3422                 :            : {
    3423                 :     939400 :   tree t = build_min_nt_call_vec (fn, argvec);
    3424                 :     939400 :   if (REFERENCE_REF_P (non_dep))
    3425                 :          4 :     non_dep = TREE_OPERAND (non_dep, 0);
    3426                 :     939400 :   TREE_TYPE (t) = TREE_TYPE (non_dep);
    3427                 :     939400 :   TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (non_dep);
    3428                 :     939400 :   return convert_from_reference (t);
    3429                 :            : }
    3430                 :            : 
    3431                 :            : /* Similar to build_min_non_dep, but for expressions that have been resolved to
    3432                 :            :    a call to an operator overload.  OP is the operator that has been
    3433                 :            :    overloaded.  NON_DEP is the non-dependent expression that's been built,
    3434                 :            :    which should be a CALL_EXPR or an INDIRECT_REF to a CALL_EXPR.  OVERLOAD is
    3435                 :            :    the overload that NON_DEP is calling.  */
    3436                 :            : 
    3437                 :            : tree
    3438                 :     176493 : build_min_non_dep_op_overload (enum tree_code op,
    3439                 :            :                                tree non_dep,
    3440                 :            :                                tree overload, ...)
    3441                 :            : {
    3442                 :     176493 :   va_list p;
    3443                 :     176493 :   int nargs, expected_nargs;
    3444                 :     176493 :   tree fn, call;
    3445                 :            : 
    3446                 :     176493 :   non_dep = extract_call_expr (non_dep);
    3447                 :            : 
    3448                 :     176493 :   nargs = call_expr_nargs (non_dep);
    3449                 :            : 
    3450                 :     176493 :   expected_nargs = cp_tree_code_length (op);
    3451                 :     176493 :   if ((op == POSTINCREMENT_EXPR
    3452                 :     176493 :        || op == POSTDECREMENT_EXPR)
    3453                 :            :       /* With -fpermissive non_dep could be operator++().  */
    3454                 :       1047 :       && (!flag_permissive || nargs != expected_nargs))
    3455                 :       1043 :     expected_nargs += 1;
    3456                 :     176493 :   gcc_assert (nargs == expected_nargs);
    3457                 :            : 
    3458                 :     176493 :   releasing_vec args;
    3459                 :     176493 :   va_start (p, overload);
    3460                 :            : 
    3461                 :     176493 :   if (TREE_CODE (TREE_TYPE (overload)) == FUNCTION_TYPE)
    3462                 :            :     {
    3463                 :     408358 :       fn = overload;
    3464                 :     408358 :       for (int i = 0; i < nargs; i++)
    3465                 :            :         {
    3466                 :     270165 :           tree arg = va_arg (p, tree);
    3467                 :     270165 :           vec_safe_push (args, arg);
    3468                 :            :         }
    3469                 :            :     }
    3470                 :      38300 :   else if (TREE_CODE (TREE_TYPE (overload)) == METHOD_TYPE)
    3471                 :            :     {
    3472                 :      38300 :       tree object = va_arg (p, tree);
    3473                 :      38300 :       tree binfo = TYPE_BINFO (TREE_TYPE (object));
    3474                 :      38300 :       tree method = build_baselink (binfo, binfo, overload, NULL_TREE);
    3475                 :      38300 :       fn = build_min (COMPONENT_REF, TREE_TYPE (overload),
    3476                 :            :                       object, method, NULL_TREE);
    3477                 :      68006 :       for (int i = 1; i < nargs; i++)
    3478                 :            :         {
    3479                 :      29706 :           tree arg = va_arg (p, tree);
    3480                 :      29706 :           vec_safe_push (args, arg);
    3481                 :            :         }
    3482                 :            :     }
    3483                 :            :   else
    3484                 :          0 :    gcc_unreachable ();
    3485                 :            : 
    3486                 :     176493 :   va_end (p);
    3487                 :     176493 :   call = build_min_non_dep_call_vec (non_dep, fn, args);
    3488                 :            : 
    3489                 :     176493 :   tree call_expr = extract_call_expr (call);
    3490                 :     176493 :   KOENIG_LOOKUP_P (call_expr) = KOENIG_LOOKUP_P (non_dep);
    3491                 :     176493 :   CALL_EXPR_OPERATOR_SYNTAX (call_expr) = true;
    3492                 :     352986 :   CALL_EXPR_ORDERED_ARGS (call_expr) = CALL_EXPR_ORDERED_ARGS (non_dep);
    3493                 :     352986 :   CALL_EXPR_REVERSE_ARGS (call_expr) = CALL_EXPR_REVERSE_ARGS (non_dep);
    3494                 :            : 
    3495                 :     176493 :   return call;
    3496                 :            : }
    3497                 :            : 
    3498                 :            : /* Return a new tree vec copied from VEC, with ELT inserted at index IDX.  */
    3499                 :            : 
    3500                 :            : vec<tree, va_gc> *
    3501                 :         23 : vec_copy_and_insert (vec<tree, va_gc> *old_vec, tree elt, unsigned idx)
    3502                 :            : {
    3503                 :         23 :   unsigned len = vec_safe_length (old_vec);
    3504                 :         23 :   gcc_assert (idx <= len);
    3505                 :            : 
    3506                 :         23 :   vec<tree, va_gc> *new_vec = NULL;
    3507                 :         23 :   vec_alloc (new_vec, len + 1);
    3508                 :            : 
    3509                 :         23 :   unsigned i;
    3510                 :         52 :   for (i = 0; i < len; ++i)
    3511                 :            :     {
    3512                 :         29 :       if (i == idx)
    3513                 :          6 :         new_vec->quick_push (elt);
    3514                 :         29 :       new_vec->quick_push ((*old_vec)[i]);
    3515                 :            :     }
    3516                 :         23 :   if (i == idx)
    3517                 :         17 :     new_vec->quick_push (elt);
    3518                 :            : 
    3519                 :         23 :   return new_vec;
    3520                 :            : }
    3521                 :            : 
    3522                 :            : tree
    3523                 :       8489 : get_type_decl (tree t)
    3524                 :            : {
    3525                 :       8489 :   if (TREE_CODE (t) == TYPE_DECL)
    3526                 :            :     return t;
    3527                 :       8489 :   if (TYPE_P (t))
    3528                 :       8489 :     return TYPE_STUB_DECL (t);
    3529                 :          0 :   gcc_assert (t == error_mark_node);
    3530                 :            :   return t;
    3531                 :            : }
    3532                 :            : 
    3533                 :            : /* Returns the namespace that contains DECL, whether directly or
    3534                 :            :    indirectly.  */
    3535                 :            : 
    3536                 :            : tree
    3537                 :   65634700 : decl_namespace_context (tree decl)
    3538                 :            : {
    3539                 :  134294000 :   while (1)
    3540                 :            :     {
    3541                 :  134294000 :       if (TREE_CODE (decl) == NAMESPACE_DECL)
    3542                 :   65634700 :         return decl;
    3543                 :   68659400 :       else if (TYPE_P (decl))
    3544                 :   38891800 :         decl = CP_DECL_CONTEXT (TYPE_MAIN_DECL (decl));
    3545                 :            :       else
    3546                 :  164062000 :         decl = CP_DECL_CONTEXT (decl);
    3547                 :            :     }
    3548                 :            : }
    3549                 :            : 
    3550                 :            : /* Returns true if decl is within an anonymous namespace, however deeply
    3551                 :            :    nested, or false otherwise.  */
    3552                 :            : 
    3553                 :            : bool
    3554                 :  245911000 : decl_anon_ns_mem_p (const_tree decl)
    3555                 :            : {
    3556                 :  492717000 :   while (TREE_CODE (decl) != NAMESPACE_DECL)
    3557                 :            :     {
    3558                 :            :       /* Classes inside anonymous namespaces have TREE_PUBLIC == 0.  */
    3559                 :  279936000 :       if (TYPE_P (decl))
    3560                 :   33129700 :         return !TREE_PUBLIC (TYPE_MAIN_DECL (decl));
    3561                 :            : 
    3562                 :  739524000 :       decl = CP_DECL_CONTEXT (decl);
    3563                 :            :     }
    3564                 :  212781000 :   return !TREE_PUBLIC (decl);
    3565                 :            : }
    3566                 :            : 
    3567                 :            : /* Subroutine of cp_tree_equal: t1 and t2 are the CALL_EXPR_FNs of two
    3568                 :            :    CALL_EXPRS.  Return whether they are equivalent.  */
    3569                 :            : 
    3570                 :            : static bool
    3571                 :   11383500 : called_fns_equal (tree t1, tree t2)
    3572                 :            : {
    3573                 :            :   /* Core 1321: dependent names are equivalent even if the overload sets
    3574                 :            :      are different.  But do compare explicit template arguments.  */
    3575                 :   11383500 :   tree name1 = dependent_name (t1);
    3576                 :   11383500 :   tree name2 = dependent_name (t2);
    3577                 :   11383500 :   if (name1 || name2)
    3578                 :            :     {
    3579                 :    8098120 :       tree targs1 = NULL_TREE, targs2 = NULL_TREE;
    3580                 :            : 
    3581                 :    8098120 :       if (name1 != name2)
    3582                 :            :         return false;
    3583                 :            : 
    3584                 :    7951010 :       if (TREE_CODE (t1) == TEMPLATE_ID_EXPR)
    3585                 :    5149940 :         targs1 = TREE_OPERAND (t1, 1);
    3586                 :    7951010 :       if (TREE_CODE (t2) == TEMPLATE_ID_EXPR)
    3587                 :    5149940 :         targs2 = TREE_OPERAND (t2, 1);
    3588                 :    7951010 :       return cp_tree_equal (targs1, targs2);
    3589                 :            :     }
    3590                 :            :   else
    3591                 :    3285420 :     return cp_tree_equal (t1, t2);
    3592                 :            : }
    3593                 :            : 
    3594                 :            : /* Return truthvalue of whether T1 is the same tree structure as T2.
    3595                 :            :    Return 1 if they are the same. Return 0 if they are different.  */
    3596                 :            : 
    3597                 :            : bool
    3598                 :  310753000 : cp_tree_equal (tree t1, tree t2)
    3599                 :            : {
    3600                 :  310753000 :   enum tree_code code1, code2;
    3601                 :            : 
    3602                 :  310753000 :   if (t1 == t2)
    3603                 :            :     return true;
    3604                 :  240874000 :   if (!t1 || !t2)
    3605                 :            :     return false;
    3606                 :            : 
    3607                 :  240508000 :   code1 = TREE_CODE (t1);
    3608                 :  240508000 :   code2 = TREE_CODE (t2);
    3609                 :            : 
    3610                 :  240508000 :   if (code1 != code2)
    3611                 :            :     return false;
    3612                 :            : 
    3613                 :  196248000 :   if (CONSTANT_CLASS_P (t1)
    3614                 :  223666000 :       && !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
    3615                 :            :     return false;
    3616                 :            : 
    3617                 :  196248000 :   switch (code1)
    3618                 :            :     {
    3619                 :          0 :     case VOID_CST:
    3620                 :            :       /* There's only a single VOID_CST node, so we should never reach
    3621                 :            :          here.  */
    3622                 :          0 :       gcc_unreachable ();
    3623                 :            : 
    3624                 :   27410600 :     case INTEGER_CST:
    3625                 :   27410600 :       return tree_int_cst_equal (t1, t2);
    3626                 :            : 
    3627                 :       3885 :     case REAL_CST:
    3628                 :       3885 :       return real_equal (&TREE_REAL_CST (t1), &TREE_REAL_CST (t2));
    3629                 :            : 
    3630                 :       2801 :     case STRING_CST:
    3631                 :       2801 :       return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
    3632                 :       2801 :         && !memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
    3633                 :       2801 :                     TREE_STRING_LENGTH (t1));
    3634                 :            : 
    3635                 :          0 :     case FIXED_CST:
    3636                 :          0 :       return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1),
    3637                 :            :                                      TREE_FIXED_CST (t2));
    3638                 :            : 
    3639                 :          1 :     case COMPLEX_CST:
    3640                 :          1 :       return cp_tree_equal (TREE_REALPART (t1), TREE_REALPART (t2))
    3641                 :          2 :         && cp_tree_equal (TREE_IMAGPART (t1), TREE_IMAGPART (t2));
    3642                 :            : 
    3643                 :          0 :     case VECTOR_CST:
    3644                 :          0 :       return operand_equal_p (t1, t2, OEP_ONLY_CONST);
    3645                 :            : 
    3646                 :     552995 :     case CONSTRUCTOR:
    3647                 :            :       /* We need to do this when determining whether or not two
    3648                 :            :          non-type pointer to member function template arguments
    3649                 :            :          are the same.  */
    3650                 :     552995 :       if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
    3651                 :     896539 :           || CONSTRUCTOR_NELTS (t1) != CONSTRUCTOR_NELTS (t2))
    3652                 :            :         return false;
    3653                 :            :       {
    3654                 :            :         tree field, value;
    3655                 :            :         unsigned int i;
    3656                 :     345505 :         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1), i, field, value)
    3657                 :            :           {
    3658                 :       1553 :             constructor_elt *elt2 = CONSTRUCTOR_ELT (t2, i);
    3659                 :       1553 :             if (!cp_tree_equal (field, elt2->index)
    3660                 :       1553 :                 || !cp_tree_equal (value, elt2->value))
    3661                 :         22 :               return false;
    3662                 :            :           }
    3663                 :            :       }
    3664                 :            :       return true;
    3665                 :            : 
    3666                 :      17923 :     case TREE_LIST:
    3667                 :      17923 :       if (!cp_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)))
    3668                 :            :         return false;
    3669                 :      17923 :       if (!cp_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2)))
    3670                 :            :         return false;
    3671                 :       9331 :       return cp_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
    3672                 :            : 
    3673                 :        597 :     case SAVE_EXPR:
    3674                 :        597 :       return cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
    3675                 :            : 
    3676                 :   11383500 :     case CALL_EXPR:
    3677                 :   11383500 :       {
    3678                 :   11383500 :         tree arg1, arg2;
    3679                 :   11383500 :         call_expr_arg_iterator iter1, iter2;
    3680                 :   11383500 :         if (!called_fns_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2)))
    3681                 :            :           return false;
    3682                 :   11797200 :         for (arg1 = first_call_expr_arg (t1, &iter1),
    3683                 :    5898600 :                arg2 = first_call_expr_arg (t2, &iter2);
    3684                 :    7443750 :              arg1 && arg2;
    3685                 :    1545150 :              arg1 = next_call_expr_arg (&iter1),
    3686                 :    1545150 :                arg2 = next_call_expr_arg (&iter2))
    3687                 :    3713760 :           if (!cp_tree_equal (arg1, arg2))
    3688                 :            :             return false;
    3689                 :    3729990 :         if (arg1 || arg2)
    3690                 :          4 :           return false;
    3691                 :            :         return true;
    3692                 :            :       }
    3693                 :            : 
    3694                 :      23668 :     case TARGET_EXPR:
    3695                 :      23668 :       {
    3696                 :      23668 :         tree o1 = TREE_OPERAND (t1, 0);
    3697                 :      23668 :         tree o2 = TREE_OPERAND (t2, 0);
    3698                 :            : 
    3699                 :            :         /* Special case: if either target is an unallocated VAR_DECL,
    3700                 :            :            it means that it's going to be unified with whatever the
    3701                 :            :            TARGET_EXPR is really supposed to initialize, so treat it
    3702                 :            :            as being equivalent to anything.  */
    3703                 :      23668 :         if (VAR_P (o1) && DECL_NAME (o1) == NULL_TREE
    3704                 :      47336 :             && !DECL_RTL_SET_P (o1))
    3705                 :            :           /*Nop*/;
    3706                 :          0 :         else if (VAR_P (o2) && DECL_NAME (o2) == NULL_TREE
    3707                 :          0 :                  && !DECL_RTL_SET_P (o2))
    3708                 :            :           /*Nop*/;
    3709                 :          0 :         else if (!cp_tree_equal (o1, o2))
    3710                 :            :           return false;
    3711                 :            : 
    3712                 :      23668 :         return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
    3713                 :            :       }
    3714                 :            : 
    3715                 :      34857 :     case PARM_DECL:
    3716                 :            :       /* For comparing uses of parameters in late-specified return types
    3717                 :            :          with an out-of-class definition of the function, but can also come
    3718                 :            :          up for expressions that involve 'this' in a member function
    3719                 :            :          template.  */
    3720                 :            : 
    3721                 :      54915 :       if (comparing_specializations && !CONSTRAINT_VAR_P (t1))
    3722                 :            :         /* When comparing hash table entries, only an exact match is
    3723                 :            :            good enough; we don't want to replace 'this' with the
    3724                 :            :            version from another function.  But be more flexible
    3725                 :            :            with local parameters in a requires-expression.  */
    3726                 :            :         return false;
    3727                 :            : 
    3728                 :      14799 :       if (same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
    3729                 :            :         {
    3730                 :        775 :           if (DECL_ARTIFICIAL (t1) ^ DECL_ARTIFICIAL (t2))
    3731                 :            :             return false;
    3732                 :        775 :           if (CONSTRAINT_VAR_P (t1) ^ CONSTRAINT_VAR_P (t2))
    3733                 :            :             return false;
    3734                 :        141 :           if (DECL_ARTIFICIAL (t1)
    3735                 :         93 :               || (DECL_PARM_LEVEL (t1) == DECL_PARM_LEVEL (t2)
    3736                 :        234 :                   && DECL_PARM_INDEX (t1) == DECL_PARM_INDEX (t2)))
    3737                 :        141 :             return true;
    3738                 :            :         }
    3739                 :            :       return false;
    3740                 :            : 
    3741                 :            :     case VAR_DECL:
    3742                 :            :     case CONST_DECL:
    3743                 :            :     case FIELD_DECL:
    3744                 :            :     case FUNCTION_DECL:
    3745                 :            :     case TEMPLATE_DECL:
    3746                 :            :     case IDENTIFIER_NODE:
    3747                 :            :     case SSA_NAME:
    3748                 :            :     case USING_DECL:
    3749                 :            :     case DEFERRED_PARSE:
    3750                 :            :       return false;
    3751                 :            : 
    3752                 :    1167070 :     case BASELINK:
    3753                 :    1167070 :       return (BASELINK_BINFO (t1) == BASELINK_BINFO (t2)
    3754                 :    1093940 :               && BASELINK_ACCESS_BINFO (t1) == BASELINK_ACCESS_BINFO (t2)
    3755                 :    1093940 :               && BASELINK_QUALIFIED_P (t1) == BASELINK_QUALIFIED_P (t2)
    3756                 :    2261000 :               && cp_tree_equal (BASELINK_FUNCTIONS (t1),
    3757                 :    1093930 :                                 BASELINK_FUNCTIONS (t2)));
    3758                 :            : 
    3759                 :    3075360 :     case TEMPLATE_PARM_INDEX:
    3760                 :    3075360 :       return (TEMPLATE_PARM_IDX (t1) == TEMPLATE_PARM_IDX (t2)
    3761                 :    2865400 :               && TEMPLATE_PARM_LEVEL (t1) == TEMPLATE_PARM_LEVEL (t2)
    3762                 :    2395890 :               && (TEMPLATE_PARM_PARAMETER_PACK (t1)
    3763                 :    2395890 :                   == TEMPLATE_PARM_PARAMETER_PACK (t2))
    3764                 :    5471220 :               && same_type_p (TREE_TYPE (TEMPLATE_PARM_DECL (t1)),
    3765                 :            :                               TREE_TYPE (TEMPLATE_PARM_DECL (t2))));
    3766                 :            : 
    3767                 :    1887080 :     case TEMPLATE_ID_EXPR:
    3768                 :    1887080 :       return (cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))
    3769                 :    1887080 :               && cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)));
    3770                 :            : 
    3771                 :      72077 :     case CONSTRAINT_INFO:
    3772                 :     144154 :       return cp_tree_equal (CI_ASSOCIATED_CONSTRAINTS (t1),
    3773                 :     216231 :                             CI_ASSOCIATED_CONSTRAINTS (t2));
    3774                 :            : 
    3775                 :          0 :     case CHECK_CONSTR:
    3776                 :          0 :       return (CHECK_CONSTR_CONCEPT (t1) == CHECK_CONSTR_CONCEPT (t2)
    3777                 :          0 :               && comp_template_args (CHECK_CONSTR_ARGS (t1),
    3778                 :          0 :                                      CHECK_CONSTR_ARGS (t2)));
    3779                 :            : 
    3780                 :    8291680 :     case TREE_VEC:
    3781                 :    8291680 :       {
    3782                 :    8291680 :         unsigned ix;
    3783                 :    8291680 :         if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
    3784                 :            :           return false;
    3785                 :   11831100 :         for (ix = TREE_VEC_LENGTH (t1); ix--;)
    3786                 :    7737920 :           if (!cp_tree_equal (TREE_VEC_ELT (t1, ix),
    3787                 :    7737920 :                               TREE_VEC_ELT (t2, ix)))
    3788                 :            :             return false;
    3789                 :            :         return true;
    3790                 :            :       }
    3791                 :            : 
    3792                 :      14418 :     case SIZEOF_EXPR:
    3793                 :      14418 :     case ALIGNOF_EXPR:
    3794                 :      14418 :       {
    3795                 :      14418 :         tree o1 = TREE_OPERAND (t1, 0);
    3796                 :      14418 :         tree o2 = TREE_OPERAND (t2, 0);
    3797                 :            : 
    3798                 :      14418 :         if (code1 == SIZEOF_EXPR)
    3799                 :            :           {
    3800                 :      12593 :             if (SIZEOF_EXPR_TYPE_P (t1))
    3801                 :          0 :               o1 = TREE_TYPE (o1);
    3802                 :      12593 :             if (SIZEOF_EXPR_TYPE_P (t2))
    3803                 :          0 :               o2 = TREE_TYPE (o2);
    3804                 :            :           }
    3805                 :            : 
    3806                 :      14418 :         if (TREE_CODE (o1) != TREE_CODE (o2))
    3807                 :            :           return false;
    3808                 :            : 
    3809                 :      14416 :         if (ARGUMENT_PACK_P (o1))
    3810                 :          0 :           return template_args_equal (o1, o2);
    3811                 :      14416 :         else if (TYPE_P (o1))
    3812                 :      14231 :           return same_type_p (o1, o2);
    3813                 :            :         else
    3814                 :        185 :           return cp_tree_equal (o1, o2);
    3815                 :            :       }
    3816                 :            : 
    3817                 :         24 :     case MODOP_EXPR:
    3818                 :         24 :       {
    3819                 :         24 :         tree t1_op1, t2_op1;
    3820                 :            : 
    3821                 :         24 :         if (!cp_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)))
    3822                 :            :           return false;
    3823                 :            : 
    3824                 :         18 :         t1_op1 = TREE_OPERAND (t1, 1);
    3825                 :         18 :         t2_op1 = TREE_OPERAND (t2, 1);
    3826                 :         18 :         if (TREE_CODE (t1_op1) != TREE_CODE (t2_op1))
    3827                 :            :           return false;
    3828                 :            : 
    3829                 :         12 :         return cp_tree_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t2, 2));
    3830                 :            :       }
    3831                 :            : 
    3832                 :        524 :     case PTRMEM_CST:
    3833                 :            :       /* Two pointer-to-members are the same if they point to the same
    3834                 :            :          field or function in the same class.  */
    3835                 :        524 :       if (PTRMEM_CST_MEMBER (t1) != PTRMEM_CST_MEMBER (t2))
    3836                 :            :         return false;
    3837                 :            : 
    3838                 :       1048 :       return same_type_p (PTRMEM_CST_CLASS (t1), PTRMEM_CST_CLASS (t2));
    3839                 :            : 
    3840                 :     311214 :     case OVERLOAD:
    3841                 :     311214 :       {
    3842                 :            :         /* Two overloads. Must be exactly the same set of decls.  */
    3843                 :     311214 :         lkp_iterator first (t1);
    3844                 :     311214 :         lkp_iterator second (t2);
    3845                 :            : 
    3846                 :     311214 :         for (; first && second; ++first, ++second)
    3847                 :     311214 :           if (*first != *second)
    3848                 :            :             return false;
    3849                 :          0 :         return !(first || second);
    3850                 :            :       }
    3851                 :            : 
    3852                 :      85400 :     case TRAIT_EXPR:
    3853                 :      85400 :       if (TRAIT_EXPR_KIND (t1) != TRAIT_EXPR_KIND (t2))
    3854                 :            :         return false;
    3855                 :      40359 :       return same_type_p (TRAIT_EXPR_TYPE1 (t1), TRAIT_EXPR_TYPE1 (t2))
    3856                 :      74066 :         && cp_tree_equal (TRAIT_EXPR_TYPE2 (t1), TRAIT_EXPR_TYPE2 (t2));
    3857                 :            : 
    3858                 :      25128 :     case CAST_EXPR:
    3859                 :      25128 :     case STATIC_CAST_EXPR:
    3860                 :      25128 :     case REINTERPRET_CAST_EXPR:
    3861                 :      25128 :     case CONST_CAST_EXPR:
    3862                 :      25128 :     case DYNAMIC_CAST_EXPR:
    3863                 :      25128 :     case IMPLICIT_CONV_EXPR:
    3864                 :      25128 :     case NEW_EXPR:
    3865                 :      25128 :     CASE_CONVERT:
    3866                 :      25128 :     case NON_LVALUE_EXPR:
    3867                 :      25128 :     case VIEW_CONVERT_EXPR:
    3868                 :      25128 :       if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)))
    3869                 :            :         return false;
    3870                 :            :       /* Now compare operands as usual.  */
    3871                 :            :       break;
    3872                 :            : 
    3873                 :      91841 :     case DEFERRED_NOEXCEPT:
    3874                 :     183682 :       return (cp_tree_equal (DEFERRED_NOEXCEPT_PATTERN (t1),
    3875                 :      91841 :                              DEFERRED_NOEXCEPT_PATTERN (t2))
    3876                 :     124095 :               && comp_template_args (DEFERRED_NOEXCEPT_ARGS (t1),
    3877                 :      32254 :                                      DEFERRED_NOEXCEPT_ARGS (t2)));
    3878                 :            : 
    3879                 :            :     case LAMBDA_EXPR:
    3880                 :            :       /* Two lambda-expressions are never considered equivalent.  */
    3881                 :            :       return false;
    3882                 :            : 
    3883                 :  120435000 :     case TYPE_ARGUMENT_PACK:
    3884                 :  120435000 :     case NONTYPE_ARGUMENT_PACK:
    3885                 :  120435000 :       {
    3886                 :  240753000 :         tree p1 = ARGUMENT_PACK_ARGS (t1);
    3887                 :  240753000 :         tree p2 = ARGUMENT_PACK_ARGS (t2);
    3888                 :  120435000 :         int len = TREE_VEC_LENGTH (p1);
    3889                 :  120435000 :         if (TREE_VEC_LENGTH (p2) != len)
    3890                 :            :           return false;
    3891                 :            : 
    3892                 :  125267000 :         for (int ix = 0; ix != len; ix++)
    3893                 :  101270000 :           if (!template_args_equal (TREE_VEC_ELT (p1, ix),
    3894                 :  101270000 :                                     TREE_VEC_ELT (p2, ix)))
    3895                 :            :             return false;
    3896                 :            :         return true;
    3897                 :            :       }
    3898                 :            : 
    3899                 :            :     default:
    3900                 :            :       break;
    3901                 :            :     }
    3902                 :            : 
    3903                 :   16079000 :   switch (TREE_CODE_CLASS (code1))
    3904                 :            :     {
    3905                 :    8293420 :     case tcc_unary:
    3906                 :    8293420 :     case tcc_binary:
    3907                 :    8293420 :     case tcc_comparison:
    3908                 :    8293420 :     case tcc_expression:
    3909                 :    8293420 :     case tcc_vl_exp:
    3910                 :    8293420 :     case tcc_reference:
    3911                 :    8293420 :     case tcc_statement:
    3912                 :    8293420 :       {
    3913                 :    8293420 :         int i, n;
    3914                 :            : 
    3915                 :    8293420 :         n = cp_tree_operand_length (t1);
    3916                 :    8293420 :         if (TREE_CODE_CLASS (code1) == tcc_vl_exp
    3917                 :    8293420 :             && n != TREE_OPERAND_LENGTH (t2))
    3918                 :            :           return false;
    3919                 :            : 
    3920                 :   12352300 :         for (i = 0; i < n; ++i)
    3921                 :   10292300 :           if (!cp_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
    3922                 :            :             return false;
    3923                 :            : 
    3924                 :            :         return true;
    3925                 :            :       }
    3926                 :            : 
    3927                 :    7785580 :     case tcc_type:
    3928                 :    7785580 :       return same_type_p (t1, t2);
    3929                 :          0 :     default:
    3930                 :          0 :       gcc_unreachable ();
    3931                 :            :     }
    3932                 :            :   /* We can get here with --disable-checking.  */
    3933                 :            :   return false;
    3934                 :            : }
    3935                 :            : 
    3936                 :            : /* The type of ARG when used as an lvalue.  */
    3937                 :            : 
    3938                 :            : tree
    3939                 :  112104000 : lvalue_type (tree arg)
    3940                 :            : {
    3941                 :  112104000 :   tree type = TREE_TYPE (arg);
    3942                 :  112104000 :   return type;
    3943                 :            : }
    3944                 :            : 
    3945                 :            : /* The type of ARG for printing error messages; denote lvalues with
    3946                 :            :    reference types.  */
    3947                 :            : 
    3948                 :            : tree
    3949                 :       2762 : error_type (tree arg)
    3950                 :            : {
    3951                 :       2762 :   tree type = TREE_TYPE (arg);
    3952                 :            : 
    3953                 :       2762 :   if (TREE_CODE (type) == ARRAY_TYPE)
    3954                 :            :     ;
    3955                 :       2707 :   else if (TREE_CODE (type) == ERROR_MARK)
    3956                 :            :     ;
    3957                 :       2707 :   else if (lvalue_p (arg))
    3958                 :       1131 :     type = build_reference_type (lvalue_type (arg));
    3959                 :       2328 :   else if (MAYBE_CLASS_TYPE_P (type))
    3960                 :        692 :     type = lvalue_type (arg);
    3961                 :            : 
    3962                 :       2762 :   return type;
    3963                 :            : }
    3964                 :            : 
    3965                 :            : /* Does FUNCTION use a variable-length argument list?  */
    3966                 :            : 
    3967                 :            : int
    3968                 :      96453 : varargs_function_p (const_tree function)
    3969                 :            : {
    3970                 :      96453 :   return stdarg_p (TREE_TYPE (function));
    3971                 :            : }
    3972                 :            : 
    3973                 :            : /* Returns 1 if decl is a member of a class.  */
    3974                 :            : 
    3975                 :            : int
    3976                 :      14582 : member_p (const_tree decl)
    3977                 :            : {
    3978                 :      14582 :   const_tree const ctx = DECL_CONTEXT (decl);
    3979                 :      14582 :   return (ctx && TYPE_P (ctx));
    3980                 :            : }
    3981                 :            : 
    3982                 :            : /* Create a placeholder for member access where we don't actually have an
    3983                 :            :    object that the access is against.  */
    3984                 :            : 
    3985                 :            : tree
    3986                 :    9337550 : build_dummy_object (tree type)
    3987                 :            : {
    3988                 :    9337550 :   tree decl = build1 (CONVERT_EXPR, build_pointer_type (type), void_node);
    3989                 :    9337550 :   return cp_build_fold_indirect_ref (decl);
    3990                 :            : }
    3991                 :            : 
    3992                 :            : /* We've gotten a reference to a member of TYPE.  Return *this if appropriate,
    3993                 :            :    or a dummy object otherwise.  If BINFOP is non-0, it is filled with the
    3994                 :            :    binfo path from current_class_type to TYPE, or 0.  */
    3995                 :            : 
    3996                 :            : tree
    3997                 :    7396010 : maybe_dummy_object (tree type, tree* binfop)
    3998                 :            : {
    3999                 :    7396010 :   tree decl, context;
    4000                 :    7396010 :   tree binfo;
    4001                 :    7396010 :   tree current = current_nonlambda_class_type ();
    4002                 :            : 
    4003                 :    7396010 :   if (current
    4004                 :    7396010 :       && (binfo = lookup_base (current, type, ba_any, NULL,
    4005                 :            :                                tf_warning_or_error)))
    4006                 :            :     context = current;
    4007                 :            :   else
    4008                 :            :     {
    4009                 :            :       /* Reference from a nested class member function.  */
    4010                 :    2551190 :       context = type;
    4011                 :    2551220 :       binfo = TYPE_BINFO (type);
    4012                 :            :     }
    4013                 :            : 
    4014                 :    7396010 :   if (binfop)
    4015                 :      37068 :     *binfop = binfo;
    4016                 :            : 
    4017                 :    7396010 :   if (current_class_ref
    4018                 :            :       /* current_class_ref might not correspond to current_class_type if
    4019                 :            :          we're in tsubst_default_argument or a lambda-declarator; in either
    4020                 :            :          case, we want to use current_class_ref if it matches CONTEXT.  */
    4021                 :   13107600 :       && (same_type_ignoring_top_level_qualifiers_p
    4022                 :    5711590 :           (TREE_TYPE (current_class_ref), context)))
    4023                 :    4088430 :     decl = current_class_ref;
    4024                 :            :   else
    4025                 :    3307580 :     decl = build_dummy_object (context);
    4026                 :            : 
    4027                 :    7396010 :   return decl;
    4028                 :            : }
    4029                 :            : 
    4030                 :            : /* Returns 1 if OB is a placeholder object, or a pointer to one.  */
    4031                 :            : 
    4032                 :            : int
    4033                 :   50601600 : is_dummy_object (const_tree ob)
    4034                 :            : {
    4035                 :   50601600 :   if (INDIRECT_REF_P (ob))
    4036                 :   35462400 :     ob = TREE_OPERAND (ob, 0);
    4037                 :   50601600 :   return (TREE_CODE (ob) == CONVERT_EXPR
    4038                 :   50601600 :           && TREE_OPERAND (ob, 0) == void_node);
    4039                 :            : }
    4040                 :            : 
    4041                 :            : /* Returns 1 iff type T is something we want to treat as a scalar type for
    4042                 :            :    the purpose of deciding whether it is trivial/POD/standard-layout.  */
    4043                 :            : 
    4044                 :            : bool
    4045                 :    4629530 : scalarish_type_p (const_tree t)
    4046                 :            : {
    4047                 :    4629530 :   if (t == error_mark_node)
    4048                 :            :     return 1;
    4049                 :            : 
    4050                 :    4628970 :   return (SCALAR_TYPE_P (t) || VECTOR_TYPE_P (t));
    4051                 :            : }
    4052                 :            : 
    4053                 :            : /* Returns true iff T requires non-trivial default initialization.  */
    4054                 :            : 
    4055                 :            : bool
    4056                 :          0 : type_has_nontrivial_default_init (const_tree t)
    4057                 :            : {
    4058                 :          0 :   t = strip_array_types (CONST_CAST_TREE (t));
    4059                 :            : 
    4060                 :          0 :   if (CLASS_TYPE_P (t))
    4061                 :          0 :     return TYPE_HAS_COMPLEX_DFLT (t);
    4062                 :            :   else
    4063                 :            :     return 0;
    4064                 :            : }
    4065                 :            : 
    4066                 :            : /* Track classes with only deleted copy/move constructors so that we can warn
    4067                 :            :    if they are used in call/return by value.  */
    4068                 :            : 
    4069                 :            : static GTY(()) hash_set<tree>* deleted_copy_types;
    4070                 :            : static void
    4071                 :        867 : remember_deleted_copy (const_tree t)
    4072                 :            : {
    4073                 :        867 :   if (!deleted_copy_types)
    4074                 :        259 :     deleted_copy_types = hash_set<tree>::create_ggc(37);
    4075                 :        867 :   deleted_copy_types->add (CONST_CAST_TREE (t));
    4076                 :        867 : }
    4077                 :            : void
    4078                 :   62636600 : maybe_warn_parm_abi (tree t, location_t loc)
    4079                 :            : {
    4080                 :   62636600 :   if (!deleted_copy_types
    4081                 :   62636600 :       || !deleted_copy_types->contains (t))
    4082                 :   62636600 :     return;
    4083                 :            : 
    4084                 :         30 :   if ((flag_abi_version == 12 || warn_abi_version == 12)
    4085                 :         36 :       && classtype_has_non_deleted_move_ctor (t))
    4086                 :            :     {
    4087                 :          6 :       bool w;
    4088                 :          6 :       auto_diagnostic_group d;
    4089                 :          6 :       if (flag_abi_version > 12)
    4090                 :          0 :         w = warning_at (loc, OPT_Wabi, "%<-fabi-version=13%> (GCC 8.2) fixes "
    4091                 :            :                         "the calling convention for %qT, which was "
    4092                 :            :                         "accidentally changed in 8.1", t);
    4093                 :            :       else
    4094                 :          6 :         w = warning_at (loc, OPT_Wabi, "%<-fabi-version=12%> (GCC 8.1) accident"
    4095                 :            :                         "ally changes the calling convention for %qT", t);
    4096                 :          6 :       if (w)
    4097                 :          6 :         inform (location_of (t), " declared here");
    4098                 :          6 :       return;
    4099                 :            :     }
    4100                 :            : 
    4101                 :         60 :   auto_diagnostic_group d;
    4102                 :         30 :   if (warning_at (loc, OPT_Wabi, "the calling convention for %qT changes in "
    4103                 :            :                   "%<-fabi-version=13%> (GCC 8.2)", t))
    4104                 :         30 :     inform (location_of (t), " because all of its copy and move "
    4105                 :            :             "constructors are deleted");
    4106                 :            : }
    4107                 :            : 
    4108                 :            : /* Returns true iff copying an object of type T (including via move
    4109                 :            :    constructor) is non-trivial.  That is, T has no non-trivial copy
    4110                 :            :    constructors and no non-trivial move constructors, and not all copy/move
    4111                 :            :    constructors are deleted.  This function implements the ABI notion of
    4112                 :            :    non-trivial copy, which has diverged from the one in the standard.  */
    4113                 :            : 
    4114                 :            : bool
    4115                 :   13276000 : type_has_nontrivial_copy_init (const_tree type)
    4116                 :            : {
    4117                 :   13276000 :   tree t = strip_array_types (CONST_CAST_TREE (type));
    4118                 :            : 
    4119                 :   26261600 :   if (CLASS_TYPE_P (t))
    4120                 :            :     {
    4121                 :   12985500 :       gcc_assert (COMPLETE_TYPE_P (t));
    4122                 :            : 
    4123                 :   12985500 :       if (TYPE_HAS_COMPLEX_COPY_CTOR (t)
    4124                 :   12985500 :           || TYPE_HAS_COMPLEX_MOVE_CTOR (t))
    4125                 :            :         /* Nontrivial.  */
    4126                 :            :         return true;
    4127                 :            : 
    4128                 :   12574300 :       if (cxx_dialect < cxx11)
    4129                 :            :         /* No deleted functions before C++11.  */
    4130                 :            :         return false;
    4131                 :            : 
    4132                 :            :       /* Before ABI v12 we did a bitwise copy of types with only deleted
    4133                 :            :          copy/move constructors.  */
    4134                 :   12504300 :       if (!abi_version_at_least (12)
    4135                 :       7299 :           && !(warn_abi && abi_version_crosses (12)))
    4136                 :            :         return false;
    4137                 :            : 
    4138                 :   12497100 :       bool saw_copy = false;
    4139                 :   12497100 :       bool saw_non_deleted = false;
    4140                 :   12497100 :       bool saw_non_deleted_move = false;
    4141                 :            : 
    4142                 :   12497100 :       if (CLASSTYPE_LAZY_MOVE_CTOR (t))
    4143                 :            :         saw_copy = saw_non_deleted = true;
    4144                 :    1135440 :       else if (CLASSTYPE_LAZY_COPY_CTOR (t))
    4145                 :            :         {
    4146                 :     155285 :           saw_copy = true;
    4147                 :     155285 :           if (classtype_has_move_assign_or_move_ctor_p (t, true))
    4148                 :            :             /* [class.copy]/8 If the class definition declares a move
    4149                 :            :                constructor or move assignment operator, the implicitly declared
    4150                 :            :                copy constructor is defined as deleted.... */;
    4151                 :            :           else
    4152                 :            :             /* Any other reason the implicitly-declared function would be
    4153                 :            :                deleted would also cause TYPE_HAS_COMPLEX_COPY_CTOR to be
    4154                 :            :                set.  */
    4155                 :     153993 :             saw_non_deleted = true;
    4156                 :            :         }
    4157                 :            : 
    4158                 :   12497100 :       if (!saw_non_deleted)
    4159                 :    3289370 :         for (ovl_iterator iter (CLASSTYPE_CONSTRUCTORS (t)); iter; ++iter)
    4160                 :            :           {
    4161                 :    2115940 :             tree fn = *iter;
    4162                 :    2115940 :             if (copy_fn_p (fn))
    4163                 :            :               {
    4164                 :     980154 :                 saw_copy = true;
    4165                 :    1960310 :                 if (!DECL_DELETED_FN (fn))
    4166                 :            :                   {
    4167                 :            :                     /* Not deleted, therefore trivial.  */
    4168                 :            :                     saw_non_deleted = true;
    4169                 :            :                     break;
    4170                 :            :                   }
    4171                 :            :               }
    4172                 :    1135780 :             else if (move_fn_p (fn))
    4173                 :    1852200 :               if (!DECL_DELETED_FN (fn))
    4174                 :     924874 :                 saw_non_deleted_move = true;
    4175                 :            :           }
    4176                 :            : 
    4177                 :   12497100 :       gcc_assert (saw_copy);
    4178                 :            : 
    4179                 :            :       /* ABI v12 buggily ignored move constructors.  */
    4180                 :   12497100 :       bool v11nontriv = false;
    4181                 :   12497100 :       bool v12nontriv = !saw_non_deleted;
    4182                 :   12497100 :       bool v13nontriv = !saw_non_deleted && !saw_non_deleted_move;
    4183                 :   12497200 :       bool nontriv = (abi_version_at_least (13) ? v13nontriv
    4184                 :        141 :                       : flag_abi_version == 12 ? v12nontriv
    4185                 :   12497100 :                       : v11nontriv);
    4186                 :   12693100 :       bool warn_nontriv = (warn_abi_version >= 13 ? v13nontriv
    4187                 :     195961 :                            : warn_abi_version == 12 ? v12nontriv
    4188                 :            :                            : v11nontriv);
    4189                 :   12497100 :       if (nontriv != warn_nontriv)
    4190                 :        867 :         remember_deleted_copy (t);
    4191                 :            : 
    4192                 :   12497100 :       return nontriv;
    4193                 :            :     }
    4194                 :            :   else
    4195                 :            :     return 0;
    4196                 :            : }
    4197                 :            : 
    4198                 :            : /* Returns 1 iff type T is a trivially copyable type, as defined in
    4199                 :            :    [basic.types] and [class].  */
    4200                 :            : 
    4201                 :            : bool
    4202                 :      17282 : trivially_copyable_p (const_tree t)
    4203                 :            : {
    4204                 :      17282 :   t = strip_array_types (CONST_CAST_TREE (t));
    4205                 :            : 
    4206                 :      33028 :   if (CLASS_TYPE_P (t))
    4207                 :      15731 :     return ((!TYPE_HAS_COPY_CTOR (t)
    4208                 :      15731 :              || !TYPE_HAS_COMPLEX_COPY_CTOR (t))
    4209                 :      14853 :             && !TYPE_HAS_COMPLEX_MOVE_CTOR (t)
    4210                 :      14810 :             && (!TYPE_HAS_COPY_ASSIGN (t)
    4211                 :      14810 :                 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (t))
    4212                 :      13984 :             && !TYPE_HAS_COMPLEX_MOVE_ASSIGN (t)
    4213                 :      29544 :             && TYPE_HAS_TRIVIAL_DESTRUCTOR (t));
    4214                 :            :   else
    4215                 :            :     /* CWG 2094 makes volatile-qualified scalars trivially copyable again.  */
    4216                 :       1551 :     return scalarish_type_p (t);
    4217                 :            : }
    4218                 :            : 
    4219                 :            : /* Returns 1 iff type T is a trivial type, as defined in [basic.types] and
    4220                 :            :    [class].  */
    4221                 :            : 
    4222                 :            : bool
    4223                 :     115270 : trivial_type_p (const_tree t)
    4224                 :            : {
    4225                 :     115270 :   t = strip_array_types (CONST_CAST_TREE (t));
    4226                 :            : 
    4227                 :     155403 :   if (CLASS_TYPE_P (t))
    4228                 :      40106 :     return (TYPE_HAS_TRIVIAL_DFLT (t)
    4229                 :      50824 :             && trivially_copyable_p (t));
    4230                 :            :   else
    4231                 :      75164 :     return scalarish_type_p (t);
    4232                 :            : }
    4233                 :            : 
    4234                 :            : /* Returns 1 iff type T is a POD type, as defined in [basic.types].  */
    4235                 :            : 
    4236                 :            : bool
    4237                 :       1854 : pod_type_p (const_tree t)
    4238                 :            : {
    4239                 :            :   /* This CONST_CAST is okay because strip_array_types returns its
    4240                 :            :      argument unmodified and we assign it to a const_tree.  */
    4241                 :       1854 :   t = strip_array_types (CONST_CAST_TREE(t));
    4242                 :            : 
    4243                 :       3146 :   if (!CLASS_TYPE_P (t))
    4244                 :        634 :     return scalarish_type_p (t);
    4245                 :       1220 :   else if (cxx_dialect > cxx98)
    4246                 :            :     /* [class]/10: A POD struct is a class that is both a trivial class and a
    4247                 :            :        standard-layout class, and has no non-static data members of type
    4248                 :            :        non-POD struct, non-POD union (or array of such types).
    4249                 :            : 
    4250                 :            :        We don't need to check individual members because if a member is
    4251                 :            :        non-std-layout or non-trivial, the class will be too.  */
    4252                 :       1124 :     return (std_layout_type_p (t) && trivial_type_p (t));
    4253                 :            :   else
    4254                 :            :     /* The C++98 definition of POD is different.  */
    4255                 :         96 :     return !CLASSTYPE_NON_LAYOUT_POD_P (t);
    4256                 :            : }
    4257                 :            : 
    4258                 :            : /* Returns true iff T is POD for the purpose of layout, as defined in the
    4259                 :            :    C++ ABI.  */
    4260                 :            : 
    4261                 :            : bool
    4262                 :    2307920 : layout_pod_type_p (const_tree t)
    4263                 :            : {
    4264                 :    2307920 :   t = strip_array_types (CONST_CAST_TREE (t));
    4265                 :            : 
    4266                 :    2658510 :   if (CLASS_TYPE_P (t))
    4267                 :     349173 :     return !CLASSTYPE_NON_LAYOUT_POD_P (t);
    4268                 :            :   else
    4269                 :    1958750 :     return scalarish_type_p (t);
    4270                 :            : }
    4271                 :            : 
    4272                 :            : /* Returns true iff T is a standard-layout type, as defined in
    4273                 :            :    [basic.types].  */
    4274                 :            : 
    4275                 :            : bool
    4276                 :    2311970 : std_layout_type_p (const_tree t)
    4277                 :            : {
    4278                 :    2311970 :   t = strip_array_types (CONST_CAST_TREE (t));
    4279                 :            : 
    4280                 :    2662910 :   if (CLASS_TYPE_P (t))
    4281                 :     349520 :     return !CLASSTYPE_NON_STD_LAYOUT (t);
    4282                 :            :   else
    4283                 :    1962450 :     return scalarish_type_p (t);
    4284                 :            : }
    4285                 :            : 
    4286                 :            : static bool record_has_unique_obj_representations (const_tree, const_tree);
    4287                 :            : 
    4288                 :            : /* Returns true iff T satisfies std::has_unique_object_representations<T>,
    4289                 :            :    as defined in [meta.unary.prop].  */
    4290                 :            : 
    4291                 :            : bool
    4292                 :        317 : type_has_unique_obj_representations (const_tree t)
    4293                 :            : {
    4294                 :        355 :   bool ret;
    4295                 :            : 
    4296                 :        355 :   t = strip_array_types (CONST_CAST_TREE (t));
    4297                 :            : 
    4298                 :        355 :   if (!trivially_copyable_p (t))
    4299                 :            :     return false;
    4300                 :            : 
    4301                 :        459 :   if (CLASS_TYPE_P (t) && CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t))
    4302                 :         57 :     return CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t);
    4303                 :            : 
    4304                 :        291 :   switch (TREE_CODE (t))
    4305                 :            :     {
    4306                 :            :     case INTEGER_TYPE:
    4307                 :            :     case POINTER_TYPE:
    4308                 :            :     case REFERENCE_TYPE:
    4309                 :            :       /* If some backend has any paddings in these types, we should add
    4310                 :            :          a target hook for this and handle it there.  */
    4311                 :            :       return true;
    4312                 :            : 
    4313                 :            :     case BOOLEAN_TYPE:
    4314                 :            :       /* For bool values other than 0 and 1 should only appear with
    4315                 :            :          undefined behavior.  */
    4316                 :            :       return true;
    4317                 :            : 
    4318                 :         20 :     case ENUMERAL_TYPE:
    4319                 :         20 :       return type_has_unique_obj_representations (ENUM_UNDERLYING_TYPE (t));
    4320                 :            : 
    4321                 :         28 :     case REAL_TYPE:
    4322                 :            :       /* XFmode certainly contains padding on x86, which the CPU doesn't store
    4323                 :            :          when storing long double values, so for that we have to return false.
    4324                 :            :          Other kinds of floating point values are questionable due to +.0/-.0
    4325                 :            :          and NaNs, let's play safe for now.  */
    4326                 :         28 :       return false;
    4327                 :            : 
    4328                 :          0 :     case FIXED_POINT_TYPE:
    4329                 :          0 :       return false;
    4330                 :            : 
    4331                 :            :     case OFFSET_TYPE:
    4332                 :            :       return true;
    4333                 :            : 
    4334                 :         18 :     case COMPLEX_TYPE:
    4335                 :         18 :     case VECTOR_TYPE:
    4336                 :         18 :       return type_has_unique_obj_representations (TREE_TYPE (t));
    4337                 :            : 
    4338                 :         44 :     case RECORD_TYPE:
    4339                 :         44 :       ret = record_has_unique_obj_representations (t, TYPE_SIZE (t));
    4340                 :         88 :       if (CLASS_TYPE_P (t))
    4341                 :            :         {
    4342                 :         41 :           CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t) = 1;
    4343                 :         41 :           CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t) = ret;
    4344                 :            :         }
    4345                 :            :       return ret;
    4346                 :            : 
    4347                 :         10 :     case UNION_TYPE:
    4348                 :         10 :       ret = true;
    4349                 :         10 :       bool any_fields;
    4350                 :         10 :       any_fields = false;
    4351                 :         36 :       for (tree field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
    4352                 :         23 :         if (TREE_CODE (field) == FIELD_DECL)
    4353                 :            :           {
    4354                 :         20 :             any_fields = true;
    4355                 :         20 :             if (!type_has_unique_obj_representations (TREE_TYPE (field))
    4356                 :         36 :                 || simple_cst_equal (DECL_SIZE (field), TYPE_SIZE (t)) != 1)
    4357                 :            :               {
    4358                 :            :                 ret = false;
    4359                 :            :                 break;
    4360                 :            :               }
    4361                 :            :           }
    4362                 :         10 :       if (!any_fields && !integer_zerop (TYPE_SIZE (t)))
    4363                 :            :         ret = false;
    4364                 :         20 :       if (CLASS_TYPE_P (t))
    4365                 :            :         {
    4366                 :         10 :           CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS_SET (t) = 1;
    4367                 :         10 :           CLASSTYPE_UNIQUE_OBJ_REPRESENTATIONS (t) = ret;
    4368                 :            :         }
    4369                 :            :       return ret;
    4370                 :            : 
    4371                 :          3 :     case NULLPTR_TYPE:
    4372                 :          3 :       return false;
    4373                 :            : 
    4374                 :          8 :     case ERROR_MARK:
    4375                 :          8 :       return false;
    4376                 :            : 
    4377                 :          0 :     default:
    4378                 :          0 :       gcc_unreachable ();
    4379                 :            :     }
    4380                 :            : }
    4381                 :            : 
    4382                 :            : /* Helper function for type_has_unique_obj_representations.  */
    4383                 :            : 
    4384                 :            : static bool
    4385                 :         49 : record_has_unique_obj_representations (const_tree t, const_tree sz)
    4386                 :            : {
    4387                 :        178 :   for (tree field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
    4388                 :        136 :     if (TREE_CODE (field) != FIELD_DECL)
    4389                 :            :       ;
    4390                 :            :     /* For bases, can't use type_has_unique_obj_representations here, as in
    4391                 :            :         struct S { int i : 24; S (); };
    4392                 :            :         struct T : public S { int j : 8; T (); };
    4393                 :            :         S doesn't have unique obj representations, but T does.  */
    4394                 :         67 :     else if (DECL_FIELD_IS_BASE (field))
    4395                 :            :       {
    4396                 :          5 :         if (!record_has_unique_obj_representations (TREE_TYPE (field),
    4397                 :          5 :                                                     DECL_SIZE (field)))
    4398                 :            :           return false;
    4399                 :            :       }
    4400                 :         62 :     else if (DECL_C_BIT_FIELD (field))
    4401                 :            :       {
    4402                 :         31 :         tree btype = DECL_BIT_FIELD_TYPE (field);
    4403                 :         31 :         if (!type_has_unique_obj_representations (btype))
    4404                 :            :           return false;
    4405                 :            :       }
    4406                 :         31 :     else if (!type_has_unique_obj_representations (TREE_TYPE (field)))
    4407                 :            :       return false;
    4408                 :            : 
    4409                 :         42 :   offset_int cur = 0;
    4410                 :        148 :   for (tree field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
    4411                 :        116 :     if (TREE_CODE (field) == FIELD_DECL)
    4412                 :            :       {
    4413                 :         57 :         offset_int fld = wi::to_offset (DECL_FIELD_OFFSET (field));
    4414                 :         57 :         offset_int bitpos = wi::to_offset (DECL_FIELD_BIT_OFFSET (field));
    4415                 :         57 :         fld = fld * BITS_PER_UNIT + bitpos;
    4416                 :        114 :         if (cur != fld)
    4417                 :         10 :           return false;
    4418                 :         47 :         if (DECL_SIZE (field))
    4419                 :            :           {
    4420                 :         44 :             offset_int size = wi::to_offset (DECL_SIZE (field));
    4421                 :         44 :             cur += size;
    4422                 :            :           }
    4423                 :            :       }
    4424                 :         32 :   if (cur != wi::to_offset (sz))
    4425                 :         12 :     return false;
    4426                 :            : 
    4427                 :            :   return true;
    4428                 :            : }
    4429                 :            : 
    4430                 :            : /* Nonzero iff type T is a class template implicit specialization.  */
    4431                 :            : 
    4432                 :            : bool
    4433                 :   50775800 : class_tmpl_impl_spec_p (const_tree t)
    4434                 :            : {
    4435                 :  101552000 :   return CLASS_TYPE_P (t) && CLASSTYPE_TEMPLATE_INSTANTIATION (t);
    4436                 :            : }
    4437                 :            : 
    4438                 :            : /* Returns 1 iff zero initialization of type T means actually storing
    4439                 :            :    zeros in it.  */
    4440                 :            : 
    4441                 :            : int
    4442                 :    2437340 : zero_init_p (const_tree t)
    4443                 :            : {
    4444                 :            :   /* This CONST_CAST is okay because strip_array_types returns its
    4445                 :            :      argument unmodified and we assign it to a const_tree.  */
    4446                 :    2437340 :   t = strip_array_types (CONST_CAST_TREE(t));
    4447                 :            : 
    4448                 :    2437340 :   if (t == error_mark_node)
    4449                 :            :     return 1;
    4450                 :            : 
    4451                 :            :   /* NULL pointers to data members are initialized with -1.  */
    4452                 :    2437340 :   if (TYPE_PTRDATAMEM_P (t))
    4453                 :            :     return 0;
    4454                 :            : 
    4455                 :            :   /* Classes that contain types that can't be zero-initialized, cannot
    4456                 :            :      be zero-initialized themselves.  */
    4457                 :    2862750 :   if (CLASS_TYPE_P (t) && CLASSTYPE_NON_ZERO_INIT_P (t))
    4458                 :         64 :     return 0;
    4459                 :            : 
    4460                 :            :   return 1;
    4461                 :            : }
    4462                 :            : 
    4463                 :            : /* True IFF T is a C++20 structural type (P1907R1) that can be used as a
    4464                 :            :    non-type template parameter.  If EXPLAIN, explain why not.  */
    4465                 :            : 
    4466                 :            : bool
    4467                 :       1925 : structural_type_p (tree t, bool explain)
    4468                 :            : {
    4469                 :       1925 :   t = strip_array_types (t);
    4470                 :       1925 :   if (INTEGRAL_OR_ENUMERATION_TYPE_P (t))
    4471                 :            :     return true;
    4472                 :        912 :   if (NULLPTR_TYPE_P (t))
    4473                 :            :     return true;
    4474                 :        912 :   if (TYPE_PTR_P (t) || TYPE_PTRMEM_P (t))
    4475                 :            :     return true;
    4476                 :        794 :   if (TYPE_REF_P (t) && !TYPE_REF_IS_RVALUE (t))
    4477                 :            :     return true;
    4478                 :       1588 :   if (!CLASS_TYPE_P (t))
    4479                 :            :     return false;
    4480                 :        794 :   if (TREE_CODE (t) == UNION_TYPE)
    4481                 :            :     {
    4482                 :          0 :       if (explain)
    4483                 :          0 :         inform (location_of (t), "%qT is a union", t);
    4484                 :          0 :       return false;
    4485                 :            :     }
    4486                 :        794 :   if (!literal_type_p (t))
    4487                 :            :     {
    4488                 :          3 :       if (explain)
    4489                 :          1 :         explain_non_literal_class (t);
    4490                 :          3 :       return false;
    4491                 :            :     }
    4492                 :        791 :   if (CLASSTYPE_HAS_MUTABLE (t))
    4493                 :            :     {
    4494                 :          0 :       if (explain)
    4495                 :          0 :         inform (location_of (t), "%qT has a mutable member", t);
    4496                 :          0 :       return false;
    4497                 :            :     }
    4498                 :       3229 :   for (tree m = next_initializable_field (TYPE_FIELDS (t)); m;
    4499                 :       1219 :        m = next_initializable_field (DECL_CHAIN (m)))
    4500                 :            :     {
    4501                 :       1222 :       if (TREE_PRIVATE (m) || TREE_PROTECTED (m))
    4502                 :            :         {
    4503                 :          3 :           if (explain)
    4504                 :            :             {
    4505                 :          1 :               if (DECL_FIELD_IS_BASE (m))
    4506                 :          2 :                 inform (location_of (m), "base class %qT is not public",
    4507                 :          1 :                         TREE_TYPE (m));
    4508                 :            :               else
    4509                 :          0 :                 inform (location_of (m), "%qD is not public", m);
    4510                 :            :             }
    4511                 :          3 :           return false;
    4512                 :            :         }
    4513                 :       1219 :       if (!structural_type_p (TREE_TYPE (m)))
    4514                 :            :         {
    4515                 :          0 :           if (explain)
    4516                 :            :             {
    4517                 :          0 :               inform (location_of (m), "%qD has a non-structural type", m);
    4518                 :          0 :               structural_type_p (TREE_TYPE (m), true);
    4519                 :            :             }
    4520                 :          0 :           return false;
    4521                 :            :         }
    4522                 :            :     }
    4523                 :            :   return true;
    4524                 :            : }
    4525                 :            : 
    4526                 :            : /* Handle the C++17 [[nodiscard]] attribute, which is similar to the GNU
    4527                 :            :    warn_unused_result attribute.  */
    4528                 :            : 
    4529                 :            : static tree
    4530                 :      48741 : handle_nodiscard_attribute (tree *node, tree name, tree args,
    4531                 :            :                             int /*flags*/, bool *no_add_attrs)
    4532                 :            : {
    4533                 :      48757 :   if (args && TREE_CODE (TREE_VALUE (args)) != STRING_CST)
    4534                 :            :     {
    4535                 :          1 :       error ("%qE attribute argument must be a string constant", name);
    4536                 :          1 :       *no_add_attrs = true;
    4537                 :            :     }
    4538                 :      48741 :   if (TREE_CODE (*node) == FUNCTION_DECL)
    4539                 :            :     {
    4540                 :      48686 :       if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (*node)))
    4541                 :      48692 :           && !DECL_CONSTRUCTOR_P (*node))
    4542                 :          3 :         warning_at (DECL_SOURCE_LOCATION (*node),
    4543                 :            :                     OPT_Wattributes, "%qE attribute applied to %qD with void "
    4544                 :            :                     "return type", name, *node);
    4545                 :            :     }
    4546                 :         55 :   else if (OVERLOAD_TYPE_P (*node))
    4547                 :            :     /* OK */;
    4548                 :            :   else
    4549                 :            :     {
    4550                 :          3 :       warning (OPT_Wattributes, "%qE attribute can only be applied to "
    4551                 :            :                "functions or to class or enumeration types", name);
    4552                 :          3 :       *no_add_attrs = true;
    4553                 :            :     }
    4554                 :      48741 :   return NULL_TREE;
    4555                 :            : }
    4556                 :            : 
    4557                 :            : /* Handle a C++2a "no_unique_address" attribute; arguments as in
    4558                 :            :    struct attribute_spec.handler.  */
    4559                 :            : static tree
    4560                 :       6062 : handle_no_unique_addr_attribute (tree* node,
    4561                 :            :                                  tree name,
    4562                 :            :                                  tree /*args*/,
    4563                 :            :                                  int /*flags*/,
    4564                 :            :                                  bool* no_add_attrs)
    4565                 :            : {
    4566                 :       6062 :   if (TREE_CODE (*node) != FIELD_DECL)
    4567                 :            :     {
    4568                 :          4 :       warning (OPT_Wattributes, "%qE attribute can only be applied to "
    4569                 :            :                "non-static data members", name);
    4570                 :          4 :       *no_add_attrs = true;
    4571                 :            :     }
    4572                 :       6058 :   else if (DECL_C_BIT_FIELD (*node))
    4573                 :            :     {
    4574                 :          0 :       warning (OPT_Wattributes, "%qE attribute cannot be applied to "
    4575                 :            :                "a bit-field", name);
    4576                 :          0 :       *no_add_attrs = true;
    4577                 :            :     }
    4578                 :            : 
    4579                 :       6062 :   return NULL_TREE;
    4580                 :            : }
    4581                 :            : 
    4582                 :            : /* The C++20 [[likely]] and [[unlikely]] attributes on labels map to the GNU
    4583                 :            :    hot/cold attributes.  */
    4584                 :            : 
    4585                 :            : static tree
    4586                 :         13 : handle_likeliness_attribute (tree *node, tree name, tree args,
    4587                 :            :                              int flags, bool *no_add_attrs)
    4588                 :            : {
    4589                 :         13 :   *no_add_attrs = true;
    4590                 :         13 :   if (TREE_CODE (*node) == LABEL_DECL
    4591                 :         13 :       || TREE_CODE (*node) == FUNCTION_DECL)
    4592                 :            :     {
    4593                 :         13 :       if (args)
    4594                 :          0 :         warning (OPT_Wattributes, "%qE attribute takes no arguments", name);
    4595                 :         13 :       tree bname = (is_attribute_p ("likely", name)
    4596                 :         13 :                     ? get_identifier ("hot") : get_identifier ("cold"));
    4597                 :         13 :       if (TREE_CODE (*node) == FUNCTION_DECL)
    4598                 :          1 :         warning (OPT_Wattributes, "ISO C++ %qE attribute does not apply to "
    4599                 :            :                  "functions; treating as %<[[gnu::%E]]%>", name, bname);
    4600                 :         13 :       tree battr = build_tree_list (bname, NULL_TREE);
    4601                 :         13 :       decl_attributes (node, battr, flags);
    4602                 :         13 :       return NULL_TREE;
    4603                 :            :     }
    4604                 :            :   else
    4605                 :          0 :     return error_mark_node;
    4606                 :            : }
    4607                 :            : 
    4608                 :            : /* Table of valid C++ attributes.  */
    4609                 :            : const struct attribute_spec cxx_attribute_table[] =
    4610                 :            : {
    4611                 :            :   /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
    4612                 :            :        affects_type_identity, handler, exclude } */
    4613                 :            :   { "init_priority",  1, 1, true,  false, false, false,
    4614                 :            :     handle_init_priority_attribute, NULL },
    4615                 :            :   { "abi_tag", 1, -1, false, false, false, true,
    4616                 :            :     handle_abi_tag_attribute, NULL },
    4617                 :            :   { NULL, 0, 0, false, false, false, false, NULL, NULL }
    4618                 :            : };
    4619                 :            : 
    4620                 :            : /* Table of C++ standard attributes.  */
    4621                 :            : const struct attribute_spec std_attribute_table[] =
    4622                 :            : {
    4623                 :            :   /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
    4624                 :            :        affects_type_identity, handler, exclude } */
    4625                 :            :   { "maybe_unused", 0, 0, false, false, false, false,
    4626                 :            :     handle_unused_attribute, NULL },
    4627                 :            :   { "nodiscard", 0, 1, false, false, false, false,
    4628                 :            :     handle_nodiscard_attribute, NULL },
    4629                 :            :   { "no_unique_address", 0, 0, true, false, false, false,
    4630                 :            :     handle_no_unique_addr_attribute, NULL },
    4631                 :            :   { "likely", 0, 0, false, false, false, false,
    4632                 :            :     handle_likeliness_attribute, attr_cold_hot_exclusions },
    4633                 :            :   { "unlikely", 0, 0, false, false, false, false,
    4634                 :            :     handle_likeliness_attribute, attr_cold_hot_exclusions },
    4635                 :            :   { "noreturn", 0, 0, true, false, false, false,
    4636                 :            :     handle_noreturn_attribute, attr_noreturn_exclusions },
    4637                 :            :   { NULL, 0, 0, false, false, false, false, NULL, NULL }
    4638                 :            : };
    4639                 :            : 
    4640                 :            : /* Handle an "init_priority" attribute; arguments as in
    4641                 :            :    struct attribute_spec.handler.  */
    4642                 :            : static tree
    4643                 :         22 : handle_init_priority_attribute (tree* node,
    4644                 :            :                                 tree name,
    4645                 :            :                                 tree args,
    4646                 :            :                                 int /*flags*/,
    4647                 :            :                                 bool* no_add_attrs)
    4648                 :            : {
    4649                 :         22 :   tree initp_expr = TREE_VALUE (args);
    4650                 :         22 :   tree decl = *node;
    4651                 :         22 :   tree type = TREE_TYPE (decl);
    4652                 :         22 :   int pri;
    4653                 :            : 
    4654                 :         22 :   STRIP_NOPS (initp_expr);
    4655                 :         22 :   initp_expr = default_conversion (initp_expr);
    4656                 :         22 :   if (initp_expr)
    4657                 :         22 :     initp_expr = maybe_constant_value (initp_expr);
    4658                 :            : 
    4659                 :         22 :   if (!initp_expr || TREE_CODE (initp_expr) != INTEGER_CST)
    4660                 :            :     {
    4661                 :          0 :       error ("requested %<init_priority%> is not an integer constant");
    4662                 :          0 :       cxx_constant_value (initp_expr);
    4663                 :          0 :       *no_add_attrs = true;
    4664                 :          0 :       return NULL_TREE;
    4665                 :            :     }
    4666                 :            : 
    4667                 :         22 :   pri = TREE_INT_CST_LOW (initp_expr);
    4668                 :            : 
    4669                 :         22 :   type = strip_array_types (type);
    4670                 :            : 
    4671                 :         22 :   if (decl == NULL_TREE
    4672                 :            :       || !VAR_P (decl)
    4673                 :         22 :       || !TREE_STATIC (decl)
    4674                 :         22 :       || DECL_EXTERNAL (decl)
    4675                 :         22 :       || (TREE_CODE (type) != RECORD_TYPE
    4676                 :         22 :           && TREE_CODE (type) != UNION_TYPE)
    4677                 :            :       /* Static objects in functions are initialized the
    4678                 :            :          first time control passes through that
    4679                 :            :          function. This is not precise enough to pin down an
    4680                 :            :          init_priority value, so don't allow it.  */
    4681                 :         22 :       || current_function_decl)
    4682                 :            :     {
    4683                 :          0 :       error ("can only use %qE attribute on file-scope definitions "
    4684                 :            :              "of objects of class type", name);
    4685                 :          0 :       *no_add_attrs = true;
    4686                 :          0 :       return NULL_TREE;
    4687                 :            :     }
    4688                 :            : 
    4689                 :         22 :   if (pri > MAX_INIT_PRIORITY || pri <= 0)
    4690                 :            :     {
    4691                 :          0 :       error ("requested %<init_priority%> %i is out of range [0, %i]",
    4692                 :            :              pri, MAX_INIT_PRIORITY);
    4693                 :          0 :       *no_add_attrs = true;
    4694                 :          0 :       return NULL_TREE;
    4695                 :            :     }
    4696                 :            : 
    4697                 :            :   /* Check for init_priorities that are reserved for
    4698                 :            :      language and runtime support implementations.*/
    4699                 :         22 :   if (pri <= MAX_RESERVED_INIT_PRIORITY)
    4700                 :            :     {
    4701                 :          0 :       warning
    4702                 :          0 :         (0, "requested %<init_priority%> %i is reserved for internal use",
    4703                 :            :          pri);
    4704                 :            :     }
    4705                 :            : 
    4706                 :         22 :   if (SUPPORTS_INIT_PRIORITY)
    4707                 :            :     {
    4708                 :         22 :       SET_DECL_INIT_PRIORITY (decl, pri);
    4709                 :         22 :       DECL_HAS_INIT_PRIORITY_P (decl) = 1;
    4710                 :         22 :       return NULL_TREE;
    4711                 :            :     }
    4712                 :            :   else
    4713                 :            :     {
    4714                 :            :       error ("%qE attribute is not supported on this platform", name);
    4715                 :            :       *no_add_attrs = true;
    4716                 :            :       return NULL_TREE;
    4717                 :            :     }
    4718                 :            : }
    4719                 :            : 
    4720                 :            : /* DECL is being redeclared; the old declaration had the abi tags in OLD,
    4721                 :            :    and the new one has the tags in NEW_.  Give an error if there are tags
    4722                 :            :    in NEW_ that weren't in OLD.  */
    4723                 :            : 
    4724                 :            : bool
    4725                 :     669941 : check_abi_tag_redeclaration (const_tree decl, const_tree old, const_tree new_)
    4726                 :            : {
    4727                 :     672180 :   if (old && TREE_CODE (TREE_VALUE (old)) == TREE_LIST)
    4728                 :     669941 :     old = TREE_VALUE (old);
    4729                 :     672065 :   if (new_ && TREE_CODE (TREE_VALUE (new_)) == TREE_LIST)
    4730                 :     672065 :     new_ = TREE_VALUE (new_);
    4731                 :            :   bool err = false;
    4732                 :     672065 :   for (const_tree t = new_; t; t = TREE_CHAIN (t))
    4733                 :            :     {
    4734                 :       2124 :       tree str = TREE_VALUE (t);
    4735                 :       2124 :       for (const_tree in = old; in; in = TREE_CHAIN (in))
    4736                 :            :         {
    4737                 :       2116 :           tree ostr = TREE_VALUE (in);
    4738                 :       2116 :           if (cp_tree_equal (str, ostr))
    4739                 :       2116 :             goto found;
    4740                 :            :         }
    4741                 :          8 :       error ("redeclaration of %qD adds abi tag %qE", decl, str);
    4742                 :          8 :       err = true;
    4743                 :       2124 :     found:;
    4744                 :            :     }
    4745                 :     669941 :   if (err)
    4746                 :            :     {
    4747                 :          8 :       inform (DECL_SOURCE_LOCATION (decl), "previous declaration here");
    4748                 :          8 :       return false;
    4749                 :            :     }
    4750                 :            :   return true;
    4751                 :            : }
    4752                 :            : 
    4753                 :            : /* The abi_tag attribute with the name NAME was given ARGS.  If they are
    4754                 :            :    ill-formed, give an error and return false; otherwise, return true.  */
    4755                 :            : 
    4756                 :            : bool
    4757                 :      36728 : check_abi_tag_args (tree args, tree name)
    4758                 :            : {
    4759                 :      36728 :   if (!args)
    4760                 :            :     {
    4761                 :          0 :       error ("the %qE attribute requires arguments", name);
    4762                 :          0 :       return false;
    4763                 :            :     }
    4764                 :      73452 :   for (tree arg = args; arg; arg = TREE_CHAIN (arg))
    4765                 :            :     {
    4766                 :      36740 :       tree elt = TREE_VALUE (arg);
    4767                 :      36740 :       if (TREE_CODE (elt) != STRING_CST
    4768                 :      73472 :           || (!same_type_ignoring_top_level_qualifiers_p
    4769                 :      36732 :               (strip_array_types (TREE_TYPE (elt)),
    4770                 :            :                char_type_node)))
    4771                 :            :         {
    4772                 :         12 :           error ("arguments to the %qE attribute must be narrow string "
    4773                 :            :                  "literals", name);
    4774                 :         12 :           return false;
    4775                 :            :         }
    4776                 :      36728 :       const char *begin = TREE_STRING_POINTER (elt);
    4777                 :      36728 :       const char *end = begin + TREE_STRING_LENGTH (elt);
    4778                 :     257038 :       for (const char *p = begin; p != end; ++p)
    4779                 :            :         {
    4780                 :     220314 :           char c = *p;
    4781                 :     220314 :           if (p == begin)
    4782                 :            :             {
    4783                 :      36728 :               if (!ISALPHA (c) && c != '_')
    4784                 :            :                 {
    4785                 :          4 :                   error ("arguments to the %qE attribute must contain valid "
    4786                 :            :                          "identifiers", name);
    4787                 :          4 :                   inform (input_location, "%<%c%> is not a valid first "
    4788                 :            :                           "character for an identifier", c);
    4789                 :          4 :                   return false;
    4790                 :            :                 }
    4791                 :            :             }
    4792                 :     183586 :           else if (p == end - 1)
    4793                 :      36724 :             gcc_assert (c == 0);
    4794                 :            :           else
    4795                 :            :             {
    4796                 :     146862 :               if (!ISALNUM (c) && c != '_')
    4797                 :            :                 {
    4798                 :          0 :                   error ("arguments to the %qE attribute must contain valid "
    4799                 :            :                          "identifiers", name);
    4800                 :          0 :                   inform (input_location, "%<%c%> is not a valid character "
    4801                 :            :                           "in an identifier", c);
    4802                 :          0 :                   return false;
    4803                 :            :                 }
    4804                 :            :             }
    4805                 :            :         }
    4806                 :            :     }
    4807                 :            :   return true;
    4808                 :            : }
    4809                 :            : 
    4810                 :            : /* Handle an "abi_tag" attribute; arguments as in
    4811                 :            :    struct attribute_spec.handler.  */
    4812                 :            : 
    4813                 :            : static tree
    4814                 :      23026 : handle_abi_tag_attribute (tree* node, tree name, tree args,
    4815                 :            :                           int flags, bool* no_add_attrs)
    4816                 :            : {
    4817                 :      23026 :   if (!check_abi_tag_args (args, name))
    4818                 :         16 :     goto fail;
    4819                 :            : 
    4820                 :      23010 :   if (TYPE_P (*node))
    4821                 :            :     {
    4822                 :       1522 :       if (!OVERLOAD_TYPE_P (*node))
    4823                 :            :         {
    4824                 :          0 :           error ("%qE attribute applied to non-class, non-enum type %qT",
    4825                 :            :                  name, *node);
    4826                 :          0 :           goto fail;
    4827                 :            :         }
    4828                 :       1522 :       else if (!(flags & (int)ATTR_FLAG_TYPE_IN_PLACE))
    4829                 :            :         {
    4830                 :          0 :           error ("%qE attribute applied to %qT after its definition",
    4831                 :            :                  name, *node);
    4832                 :          0 :           goto fail;
    4833                 :            :         }
    4834                 :       1518 :       else if (CLASS_TYPE_P (*node)
    4835                 :       3040 :                && CLASSTYPE_TEMPLATE_INSTANTIATION (*node))
    4836                 :            :         {
    4837                 :          4 :           warning (OPT_Wattributes, "ignoring %qE attribute applied to "
    4838                 :            :                    "template instantiation %qT", name, *node);
    4839                 :          4 :           goto fail;
    4840                 :            :         }
    4841                 :       1514 :       else if (CLASS_TYPE_P (*node)
    4842                 :       3032 :                && CLASSTYPE_TEMPLATE_SPECIALIZATION (*node))
    4843                 :            :         {
    4844                 :          4 :           warning (OPT_Wattributes, "ignoring %qE attribute applied to "
    4845                 :            :                    "template specialization %qT", name, *node);
    4846                 :          4 :           goto fail;
    4847                 :            :         }
    4848                 :            : 
    4849                 :       1514 :       tree attributes = TYPE_ATTRIBUTES (*node);
    4850                 :       1514 :       tree decl = TYPE_NAME (*node);
    4851                 :            : 
    4852                 :            :       /* Make sure all declarations have the same abi tags.  */
    4853                 :       1514 :       if (DECL_SOURCE_LOCATION (decl) != input_location)
    4854                 :            :         {
    4855                 :          4 :           if (!check_abi_tag_redeclaration (decl,
    4856                 :          4 :                                             lookup_attribute ("abi_tag",
    4857                 :            :                                                               attributes),
    4858                 :            :                                             args))
    4859                 :          4 :             goto fail;
    4860                 :            :         }
    4861                 :            :     }
    4862                 :            :   else
    4863                 :            :     {
    4864                 :      21488 :       if (!VAR_OR_FUNCTION_DECL_P (*node))
    4865                 :            :         {
    4866                 :          0 :           error ("%qE attribute applied to non-function, non-variable %qD",
    4867                 :            :                  name, *node);
    4868                 :          0 :           goto fail;
    4869                 :            :         }
    4870                 :      21488 :       else if (DECL_LANGUAGE (*node) == lang_c)
    4871                 :            :         {
    4872                 :          0 :           error ("%qE attribute applied to extern \"C\" declaration %qD",
    4873                 :            :                  name, *node);
    4874                 :          0 :           goto fail;
    4875                 :            :         }
    4876                 :            :     }
    4877                 :            : 
    4878                 :            :   return NULL_TREE;
    4879                 :            : 
    4880                 :         28 :  fail:
    4881                 :         28 :   *no_add_attrs = true;
    4882                 :         28 :   return NULL_TREE;
    4883                 :            : }
    4884                 :            : 
    4885                 :            : /* Return a new PTRMEM_CST of the indicated TYPE.  The MEMBER is the
    4886                 :            :    thing pointed to by the constant.  */
    4887                 :            : 
    4888                 :            : tree
    4889                 :       7127 : make_ptrmem_cst (tree type, tree member)
    4890                 :            : {
    4891                 :       7127 :   tree ptrmem_cst = make_node (PTRMEM_CST);
    4892                 :       7127 :   TREE_TYPE (ptrmem_cst) = type;
    4893                 :       7127 :   PTRMEM_CST_MEMBER (ptrmem_cst) = member;
    4894                 :       7127 :   return ptrmem_cst;
    4895                 :            : }
    4896                 :            : 
    4897                 :            : /* Build a variant of TYPE that has the indicated ATTRIBUTES.  May
    4898                 :            :    return an existing type if an appropriate type already exists.  */
    4899                 :            : 
    4900                 :            : tree
    4901                 :   22955100 : cp_build_type_attribute_variant (tree type, tree attributes)
    4902                 :            : {
    4903                 :   22955100 :   tree new_type;
    4904                 :            : 
    4905                 :   22955100 :   new_type = build_type_attribute_variant (type, attributes);
    4906                 :   22955100 :   if (FUNC_OR_METHOD_TYPE_P (new_type))
    4907                 :   22953900 :     gcc_checking_assert (cxx_type_hash_eq (type, new_type));
    4908                 :            : 
    4909                 :            :   /* Making a new main variant of a class type is broken.  */
    4910                 :   22955200 :   gcc_assert (!CLASS_TYPE_P (type) || new_type == type);
    4911                 :            :     
    4912                 :   22955100 :   return new_type;
    4913                 :            : }
    4914                 :            : 
    4915                 :            : /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
    4916                 :            :    Called only after doing all language independent checks.  */
    4917                 :            : 
    4918                 :            : bool
    4919                 :   76264400 : cxx_type_hash_eq (const_tree typea, const_tree typeb)
    4920                 :            : {
    4921                 :   76264400 :   gcc_assert (FUNC_OR_METHOD_TYPE_P (typea));
    4922                 :            : 
    4923                 :   76264400 :   if (type_memfn_rqual (typea) != type_memfn_rqual (typeb))
    4924                 :            :     return false;
    4925                 :  118495000 :   if (TYPE_HAS_LATE_RETURN_TYPE (typea) != TYPE_HAS_LATE_RETURN_TYPE (typeb))
    4926                 :            :     return false;
    4927                 :  152528000 :   return comp_except_specs (TYPE_RAISES_EXCEPTIONS (typea),
    4928                 :  152528000 :                             TYPE_RAISES_EXCEPTIONS (typeb), ce_exact);
    4929                 :            : }
    4930                 :            : 
    4931                 :            : /* Copy the language-specific type variant modifiers from TYPEB to TYPEA.  For
    4932                 :            :    C++, these are the exception-specifier and ref-qualifier.  */
    4933                 :            : 
    4934                 :            : tree
    4935                 :    8741010 : cxx_copy_lang_qualifiers (const_tree typea, const_tree typeb)
    4936                 :            : {
    4937                 :    8741010 :   tree type = CONST_CAST_TREE (typea);
    4938                 :    8741010 :   if (FUNC_OR_METHOD_TYPE_P (type))
    4939                 :   17480800 :     type = build_cp_fntype_variant (type, type_memfn_rqual (typeb),
    4940                 :    8740420 :                                     TYPE_RAISES_EXCEPTIONS (typeb),
    4941                 :    8740420 :                                     TYPE_HAS_LATE_RETURN_TYPE (typeb));
    4942                 :    8741010 :   return type;
    4943                 :            : }
    4944                 :            : 
    4945                 :            : /* Apply FUNC to all language-specific sub-trees of TP in a pre-order
    4946                 :            :    traversal.  Called from walk_tree.  */
    4947                 :            : 
    4948                 :            : tree
    4949                 : 1869300000 : cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func,
    4950                 :            :                   void *data, hash_set<tree> *pset)
    4951                 :            : {
    4952                 : 1869300000 :   enum tree_code code = TREE_CODE (*tp);
    4953                 : 1869300000 :   tree result;
    4954                 :            : 
    4955                 :            : #define WALK_SUBTREE(NODE)                              \
    4956                 :            :   do                                                    \
    4957                 :            :     {                                                   \
    4958                 :            :       result = cp_walk_tree (&(NODE), func, data, pset);    \
    4959                 :            :       if (result) goto out;                             \
    4960                 :            :     }                                                   \
    4961                 :            :   while (0)
    4962                 :            : 
    4963                 : 1869300000 :   if (TYPE_P (*tp))
    4964                 :            :     /* Walk into template args without looking through typedefs.  */
    4965                 :  848682000 :     if (tree ti = TYPE_TEMPLATE_INFO_MAYBE_ALIAS (*tp))
    4966                 :  171436000 :       WALK_SUBTREE (TI_ARGS (ti));
    4967                 :            : 
    4968                 :            :   /* Not one of the easy cases.  We must explicitly go through the
    4969                 :            :      children.  */
    4970                 : 1869300000 :   result = NULL_TREE;
    4971                 : 1869300000 :   switch (code)
    4972                 :            :     {
    4973                 :  161660000 :     case DEFERRED_PARSE:
    4974                 :  161660000 :     case TEMPLATE_TEMPLATE_PARM:
    4975                 :  161660000 :     case BOUND_TEMPLATE_TEMPLATE_PARM:
    4976                 :  161660000 :     case UNBOUND_CLASS_TEMPLATE:
    4977                 :  161660000 :     case TEMPLATE_PARM_INDEX:
    4978                 :  161660000 :     case TEMPLATE_TYPE_PARM:
    4979                 :  161660000 :     case TYPENAME_TYPE:
    4980                 :  161660000 :     case TYPEOF_TYPE:
    4981                 :  161660000 :     case UNDERLYING_TYPE:
    4982                 :            :       /* None of these have subtrees other than those already walked
    4983                 :            :          above.  */
    4984                 :  161660000 :       *walk_subtrees_p = 0;
    4985                 :  161660000 :       break;
    4986                 :            : 
    4987                 :    4791410 :     case BASELINK:
    4988                 :    4791410 :       if (BASELINK_QUALIFIED_P (*tp))
    4989                 :    1013010 :         WALK_SUBTREE (BINFO_TYPE (BASELINK_ACCESS_BINFO (*tp)));
    4990                 :    4791410 :       WALK_SUBTREE (BASELINK_FUNCTIONS (*tp));
    4991                 :    4791410 :       *walk_subtrees_p = 0;
    4992                 :    4791410 :       break;
    4993                 :            : 
    4994                 :       6081 :     case PTRMEM_CST:
    4995                 :       6081 :       WALK_SUBTREE (TREE_TYPE (*tp));
    4996                 :       6081 :       *walk_subtrees_p = 0;
    4997                 :       6081 :       break;
    4998                 :            : 
    4999                 :   11551300 :     case TREE_LIST:
    5000                 :   11551300 :       WALK_SUBTREE (TREE_PURPOSE (*tp));
    5001                 :            :       break;
    5002                 :            : 
    5003                 :   14566500 :     case OVERLOAD:
    5004                 :   14566500 :       WALK_SUBTREE (OVL_FUNCTION (*tp));
    5005                 :   14566500 :       WALK_SUBTREE (OVL_CHAIN (*tp));
    5006                 :   14566500 :       *walk_subtrees_p = 0;
    5007                 :   14566500 :       break;
    5008                 :            : 
    5009                 :     160516 :     case USING_DECL:
    5010                 :     160516 :       WALK_SUBTREE (DECL_NAME (*tp));
    5011                 :     160516 :       WALK_SUBTREE (USING_DECL_SCOPE (*tp));
    5012                 :     160516 :       WALK_SUBTREE (USING_DECL_DECLS (*tp));
    5013                 :     160516 :       *walk_subtrees_p = 0;
    5014                 :     160516 :       break;
    5015                 :            : 
    5016                 :  155655000 :     case RECORD_TYPE:
    5017                 :  155655000 :       if (TYPE_PTRMEMFUNC_P (*tp))
    5018                 :    1583860 :         WALK_SUBTREE (TYPE_PTRMEMFUNC_FN_TYPE_RAW (*tp));
    5019                 :            :       break;
    5020                 :            : 
    5021                 :   17278900 :     case TYPE_ARGUMENT_PACK:
    5022                 :   17278900 :     case NONTYPE_ARGUMENT_PACK:
    5023                 :   17278900 :       {
    5024                 :   17278900 :         tree args = ARGUMENT_PACK_ARGS (*tp);
    5025                 :   17278900 :         int i, len = TREE_VEC_LENGTH (args);
    5026                 :   47123100 :         for (i = 0; i < len; i++)
    5027                 :   29921200 :           WALK_SUBTREE (TREE_VEC_ELT (args, i));
    5028                 :            :       }
    5029                 :            :       break;
    5030                 :            : 
    5031                 :    2910050 :     case TYPE_PACK_EXPANSION:
    5032                 :    2910050 :       WALK_SUBTREE (TREE_TYPE (*tp));
    5033                 :    2909520 :       WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp));
    5034                 :    2909520 :       *walk_subtrees_p = 0;
    5035                 :    2909520 :       break;
    5036                 :            :       
    5037                 :     204295 :     case EXPR_PACK_EXPANSION:
    5038                 :     204295 :       WALK_SUBTREE (TREE_OPERAND (*tp, 0));
    5039                 :     204225 :       WALK_SUBTREE (PACK_EXPANSION_EXTRA_ARGS (*tp));
    5040                 :     204225 :       *walk_subtrees_p = 0;
    5041                 :     204225 :       break;
    5042                 :            : 
    5043                 :    4448620 :     case CAST_EXPR:
    5044                 :    4448620 :     case REINTERPRET_CAST_EXPR:
    5045                 :    4448620 :     case STATIC_CAST_EXPR:
    5046                 :    4448620 :     case CONST_CAST_EXPR:
    5047                 :    4448620 :     case DYNAMIC_CAST_EXPR:
    5048                 :    4448620 :     case IMPLICIT_CONV_EXPR:
    5049                 :    4448620 :       if (TREE_TYPE (*tp))
    5050                 :    4448620 :         WALK_SUBTREE (TREE_TYPE (*tp));
    5051                 :            : 
    5052                 :            :       {
    5053                 :            :         int i;
    5054                 :    8613860 :         for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (*tp)); ++i)
    5055                 :    4448600 :           WALK_SUBTREE (TREE_OPERAND (*tp, i));
    5056                 :            :       }
    5057                 :    4165260 :       *walk_subtrees_p = 0;
    5058                 :    4165260 :       break;
    5059                 :            : 
    5060                 :    7772980 :     case CONSTRUCTOR:
    5061                 :    7772980 :       if (COMPOUND_LITERAL_P (*tp))
    5062                 :     584445 :         WALK_SUBTREE (TREE_TYPE (*tp));
    5063                 :            :       break;
    5064                 :            : 
    5065                 :    1592160 :     case TRAIT_EXPR:
    5066                 :    1592160 :       WALK_SUBTREE (TRAIT_EXPR_TYPE1 (*tp));
    5067                 :    1592160 :       WALK_SUBTREE (TRAIT_EXPR_TYPE2 (*tp));
    5068                 :    1592160 :       *walk_subtrees_p = 0;
    5069                 :    1592160 :       break;
    5070                 :            : 
    5071                 :     581774 :     case DECLTYPE_TYPE:
    5072                 :     581774 :       ++cp_unevaluated_operand;
    5073                 :            :       /* We can't use WALK_SUBTREE here because of the goto.  */
    5074                 :     581774 :       result = cp_walk_tree (&DECLTYPE_TYPE_EXPR (*tp), func, data, pset);
    5075                 :     581774 :       --cp_unevaluated_operand;
    5076                 :     581774 :       *walk_subtrees_p = 0;
    5077                 :     581774 :       break;
    5078                 :            : 
    5079                 :    3037750 :     case ALIGNOF_EXPR:
    5080                 :    3037750 :     case SIZEOF_EXPR:
    5081                 :    3037750 :     case NOEXCEPT_EXPR:
    5082                 :    3037750 :       ++cp_unevaluated_operand;
    5083                 :    3037750 :       result = cp_walk_tree (&TREE_OPERAND (*tp, 0), func, data, pset);
    5084                 :    3037750 :       --cp_unevaluated_operand;
    5085                 :    3037750 :       *walk_subtrees_p = 0;
    5086                 :    3037750 :       break;
    5087                 :            :  
    5088                 :    1159790 :     case REQUIRES_EXPR:
    5089                 :            :       // Only recurse through the nested expression. Do not
    5090                 :            :       // walk the parameter list. Doing so causes false
    5091                 :            :       // positives in the pack expansion checker since the
    5092                 :            :       // requires parameters are introduced as pack expansions.
    5093                 :    1159790 :       WALK_SUBTREE (TREE_OPERAND (*tp, 1));
    5094                 :    1159790 :       *walk_subtrees_p = 0;
    5095                 :    1159790 :       break;
    5096                 :            : 
    5097                 :    5376050 :     case DECL_EXPR:
    5098                 :            :       /* User variables should be mentioned in BIND_EXPR_VARS
    5099                 :            :          and their initializers and sizes walked when walking
    5100                 :            :          the containing BIND_EXPR.  Compiler temporaries are
    5101                 :            :          handled here.  And also normal variables in templates,
    5102                 :            :          since do_poplevel doesn't build a BIND_EXPR then.  */
    5103                 :    5376050 :       if (VAR_P (TREE_OPERAND (*tp, 0))
    5104                 :    5376050 :           && (processing_template_decl
    5105                 :    5282430 :               || (DECL_ARTIFICIAL (TREE_OPERAND (*tp, 0))
    5106                 :    5282430 :                   && !TREE_STATIC (TREE_OPERAND (*tp, 0)))))
    5107                 :            :         {
    5108                 :     229602 :           tree decl = TREE_OPERAND (*tp, 0);
    5109                 :     229602 :           WALK_SUBTREE (DECL_INITIAL (decl));
    5110                 :     229562 :           WALK_SUBTREE (DECL_SIZE (decl));
    5111                 :     229562 :           WALK_SUBTREE (DECL_SIZE_UNIT (decl));
    5112                 :            :         }
    5113                 :            :       break;
    5114                 :            : 
    5115                 :       2938 :     case LAMBDA_EXPR:
    5116                 :            :       /* Don't walk into the body of the lambda, but the capture initializers
    5117                 :            :          are part of the enclosing context.  */
    5118                 :       9916 :       for (tree cap = LAMBDA_EXPR_CAPTURE_LIST (*tp); cap;
    5119                 :       3489 :            cap = TREE_CHAIN (cap))
    5120                 :       3489 :         WALK_SUBTREE (TREE_VALUE (cap));
    5121                 :            :       break;
    5122                 :            : 
    5123                 :        189 :     case CO_YIELD_EXPR:
    5124                 :        189 :       if (TREE_OPERAND (*tp, 1))
    5125                 :            :         /* Operand 1 is the tree for the relevant co_await which has any
    5126                 :            :            interesting sub-trees.  */
    5127                 :        139 :         WALK_SUBTREE (TREE_OPERAND (*tp, 1));
    5128                 :            :       break;
    5129                 :            : 
    5130                 :      15784 :     case CO_AWAIT_EXPR:
    5131                 :      15784 :       if (TREE_OPERAND (*tp, 1))
    5132                 :            :         /* Operand 1 is frame variable.  */
    5133                 :      15653 :         WALK_SUBTREE (TREE_OPERAND (*tp, 1));
    5134                 :      15784 :       if (TREE_OPERAND (*tp, 2))
    5135                 :            :         /* Operand 2 has the initialiser, and we need to walk any subtrees
    5136                 :            :            there.  */
    5137                 :      15653 :         WALK_SUBTREE (TREE_OPERAND (*tp, 2));
    5138                 :            :       break;
    5139                 :            : 
    5140                 :       4229 :     case CO_RETURN_EXPR:
    5141                 :       4229 :       if (TREE_OPERAND (*tp, 0))
    5142                 :            :         {
    5143                 :       3803 :           if (VOID_TYPE_P (TREE_OPERAND (*tp, 0)))
    5144                 :            :             /* For void expressions, operand 1 is a trivial call, and any
    5145                 :            :                interesting subtrees will be part of operand 0.  */
    5146                 :          0 :             WALK_SUBTREE (TREE_OPERAND (*tp, 0));
    5147                 :       3803 :           else if (TREE_OPERAND (*tp, 1))
    5148                 :            :             /* Interesting sub-trees will be in the return_value () call
    5149                 :            :                arguments.  */
    5150                 :       3755 :             WALK_SUBTREE (TREE_OPERAND (*tp, 1));
    5151                 :            :         }
    5152                 :            :       break;
    5153                 :            : 
    5154                 :            :     default:
    5155                 :            :       return NULL_TREE;
    5156                 :            :     }
    5157                 :            : 
    5158                 :            :   /* We didn't find what we were looking for.  */
    5159                 :            :  out:
    5160                 :            :   return result;
    5161                 :            : 
    5162                 :            : #undef WALK_SUBTREE
    5163                 :            : }
    5164                 :            : 
    5165                 :            : /* Like save_expr, but for C++.  */
    5166                 :            : 
    5167                 :            : tree
    5168                 :      17583 : cp_save_expr (tree expr)
    5169                 :            : {
    5170                 :            :   /* There is no reason to create a SAVE_EXPR within a template; if
    5171                 :            :      needed, we can create the SAVE_EXPR when instantiating the
    5172                 :            :      template.  Furthermore, the middle-end cannot handle C++-specific
    5173                 :            :      tree codes.  */
    5174                 :      17583 :   if (processing_template_decl)
    5175                 :            :     return expr;
    5176                 :            : 
    5177                 :            :   /* TARGET_EXPRs are only expanded once.  */
    5178                 :      12485 :   if (TREE_CODE (expr) == TARGET_EXPR)
    5179                 :            :     return expr;
    5180                 :            : 
    5181                 :      12477 :   return save_expr (expr);
    5182                 :            : }
    5183                 :            : 
    5184                 :            : /* Initialize tree.c.  */
    5185                 :            : 
    5186                 :            : void
    5187                 :      78233 : init_tree (void)
    5188                 :            : {
    5189                 :      78233 :   list_hash_table = hash_table<list_hasher>::create_ggc (61);
    5190                 :      78233 :   register_scoped_attributes (std_attribute_table, NULL);
    5191                 :      78233 : }
    5192                 :            : 
    5193                 :            : /* Returns the kind of special function that DECL (a FUNCTION_DECL)
    5194                 :            :    is.  Note that sfk_none is zero, so this function can be used as a
    5195                 :            :    predicate to test whether or not DECL is a special function.  */
    5196                 :            : 
    5197                 :            : special_function_kind
    5198                 :   10528400 : special_function_p (const_tree decl)
    5199                 :            : {
    5200                 :            :   /* Rather than doing all this stuff with magic names, we should
    5201                 :            :      probably have a field of type `special_function_kind' in
    5202                 :            :      DECL_LANG_SPECIFIC.  */
    5203                 :   21056700 :   if (DECL_INHERITED_CTOR (decl))
    5204                 :            :     return sfk_inheriting_constructor;
    5205                 :   20763200 :   if (DECL_COPY_CONSTRUCTOR_P (decl))
    5206                 :            :     return sfk_copy_constructor;
    5207                 :   18913400 :   if (DECL_MOVE_CONSTRUCTOR_P (decl))
    5208                 :            :     return sfk_move_constructor;
    5209                 :   15582700 :   if (DECL_CONSTRUCTOR_P (decl))
    5210                 :            :     return sfk_constructor;
    5211                 :    6960300 :   if (DECL_ASSIGNMENT_OPERATOR_P (decl)
    5212                 :    6960300 :       && DECL_OVERLOADED_OPERATOR_IS (decl, NOP_EXPR))
    5213                 :            :     {
    5214                 :     733720 :       if (copy_fn_p (decl))
    5215                 :            :         return sfk_copy_assignment;
    5216                 :     355997 :       if (move_fn_p (decl))
    5217                 :            :         return sfk_move_assignment;
    5218                 :            :     }
    5219                 :    6226580 :   if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
    5220                 :            :     return sfk_destructor;
    5221                 :    2252900 :   if (DECL_COMPLETE_DESTRUCTOR_P (decl))
    5222                 :            :     return sfk_complete_destructor;
    5223                 :    1086250 :   if (DECL_BASE_DESTRUCTOR_P (decl))
    5224                 :            :     return sfk_base_destructor;
    5225                 :    1031420 :   if (DECL_DELETING_DESTRUCTOR_P (decl))
    5226                 :            :     return sfk_deleting_destructor;
    5227                 :       7095 :   if (DECL_CONV_FN_P (decl))
    5228                 :            :     return sfk_conversion;
    5229                 :       7093 :   if (deduction_guide_p (decl))
    5230                 :            :     return sfk_deduction_guide;
    5231                 :      14186 :   if (DECL_OVERLOADED_OPERATOR_CODE_RAW (decl) >= OVL_OP_EQ_EXPR
    5232                 :       7093 :       && DECL_OVERLOADED_OPERATOR_CODE_RAW (decl) <= OVL_OP_SPACESHIP_EXPR)
    5233                 :       2913 :     return sfk_comparison;
    5234                 :            : 
    5235                 :            :   return sfk_none;
    5236                 :            : }
    5237                 :            : 
    5238                 :            : /* As above, but only if DECL is a special member function as per 11.3.3
    5239                 :            :    [special]: default/copy/move ctor, copy/move assignment, or destructor.  */
    5240                 :            : 
    5241                 :            : special_function_kind
    5242                 :       4816 : special_memfn_p (const_tree decl)
    5243                 :            : {
    5244                 :       4816 :   switch (special_function_kind sfk = special_function_p (decl))
    5245                 :            :     {
    5246                 :        555 :     case sfk_constructor:
    5247                 :        555 :       if (!default_ctor_p (decl))
    5248                 :            :         break;
    5249                 :            :       gcc_fallthrough();
    5250                 :            :     case sfk_copy_constructor:
    5251                 :            :     case sfk_copy_assignment:
    5252                 :            :     case sfk_move_assignment:
    5253                 :            :     case sfk_move_constructor:
    5254                 :            :     case sfk_destructor:
    5255                 :            :       return sfk;
    5256                 :            : 
    5257                 :            :     default:
    5258                 :            :       break;
    5259                 :            :     }
    5260                 :            :   return sfk_none;
    5261                 :            : }
    5262                 :            : 
    5263                 :            : /* Returns nonzero if TYPE is a character type, including wchar_t.  */
    5264                 :            : 
    5265                 :            : int
    5266                 :    2203640 : char_type_p (tree type)
    5267                 :            : {
    5268                 :    2203640 :   return (same_type_p (type, char_type_node)
    5269                 :    1766250 :           || same_type_p (type, unsigned_char_type_node)
    5270                 :    1765380 :           || same_type_p (type, signed_char_type_node)
    5271                 :    1765190 :           || same_type_p (type, char8_type_node)
    5272                 :    1765160 :           || same_type_p (type, char16_type_node)
    5273                 :    1764880 :           || same_type_p (type, char32_type_node)
    5274                 :    3968260 :           || same_type_p (type, wchar_type_node));
    5275                 :            : }
    5276                 :            : 
    5277                 :            : /* Returns the kind of linkage associated with the indicated DECL.  Th
    5278                 :            :    value returned is as specified by the language standard; it is
    5279                 :            :    independent of implementation details regarding template
    5280                 :            :    instantiation, etc.  For example, it is possible that a declaration
    5281                 :            :    to which this function assigns external linkage would not show up
    5282                 :            :    as a global symbol when you run `nm' on the resulting object file.  */
    5283                 :            : 
    5284                 :            : linkage_kind
    5285                 :  164870000 : decl_linkage (tree decl)
    5286                 :            : {
    5287                 :            :   /* This function doesn't attempt to calculate the linkage from first
    5288                 :            :      principles as given in [basic.link].  Instead, it makes use of
    5289                 :            :      the fact that we have already set TREE_PUBLIC appropriately, and
    5290                 :            :      then handles a few special cases.  Ideally, we would calculate
    5291                 :            :      linkage first, and then transform that into a concrete
    5292                 :            :      implementation.  */
    5293                 :            : 
    5294                 :            :   /* Things that don't have names have no linkage.  */
    5295                 :  164870000 :   if (!DECL_NAME (decl))
    5296                 :            :     return lk_none;
    5297                 :            : 
    5298                 :            :   /* Fields have no linkage.  */
    5299                 :  164533000 :   if (TREE_CODE (decl) == FIELD_DECL)
    5300                 :            :     return lk_none;
    5301                 :            : 
    5302                 :            :   /* Things in local scope do not have linkage.  */
    5303                 :  164533000 :   if (decl_function_context (decl))
    5304                 :            :     return lk_none;
    5305                 :            : 
    5306                 :            :   /* Things that are TREE_PUBLIC have external linkage.  */
    5307                 :  163917000 :   if (TREE_PUBLIC (decl))
    5308                 :            :     return lk_external;
    5309                 :            : 
    5310                 :            :   /* maybe_thunk_body clears TREE_PUBLIC on the maybe-in-charge 'tor variants,
    5311                 :            :      check one of the "clones" for the real linkage.  */
    5312                 :   27843900 :   if (DECL_MAYBE_IN_CHARGE_CDTOR_P (decl)
    5313                 :       1171 :       && DECL_CHAIN (decl)
    5314                 :   13922500 :       && DECL_CLONED_FUNCTION_P (DECL_CHAIN (decl)))
    5315                 :  164870000 :     return decl_linkage (DECL_CHAIN (decl));
    5316                 :            : 
    5317                 :   13922400 :   if (TREE_CODE (decl) == NAMESPACE_DECL)
    5318                 :            :     return lk_external;
    5319                 :            : 
    5320                 :            :   /* Linkage of a CONST_DECL depends on the linkage of the enumeration
    5321                 :            :      type.  */
    5322                 :   13765900 :   if (TREE_CODE (decl) == CONST_DECL)
    5323                 :          0 :     return decl_linkage (TYPE_NAME (DECL_CONTEXT (decl)));
    5324                 :            : 
    5325                 :            :   /* Members of the anonymous namespace also have TREE_PUBLIC unset, but
    5326                 :            :      are considered to have external linkage for language purposes, as do
    5327                 :            :      template instantiations on targets without weak symbols.  DECLs really
    5328                 :            :      meant to have internal linkage have DECL_THIS_STATIC set.  */
    5329                 :   13765900 :   if (TREE_CODE (decl) == TYPE_DECL)
    5330                 :            :     return lk_external;
    5331                 :   13610900 :   if (VAR_OR_FUNCTION_DECL_P (decl))
    5332                 :            :     {
    5333                 :   10973400 :       if (!DECL_THIS_STATIC (decl))
    5334                 :            :         return lk_external;
    5335                 :            : 
    5336                 :            :       /* Static data members and static member functions from classes
    5337                 :            :          in anonymous namespace also don't have TREE_PUBLIC set.  */
    5338                 :     352008 :       if (DECL_CLASS_CONTEXT (decl))
    5339                 :       6976 :         return lk_external;
    5340                 :            :     }
    5341                 :            : 
    5342                 :            :   /* Everything else has internal linkage.  */
    5343                 :            :   return lk_internal;
    5344                 :            : }
    5345                 :            : 
    5346                 :            : /* Returns the storage duration of the object or reference associated with
    5347                 :            :    the indicated DECL, which should be a VAR_DECL or PARM_DECL.  */
    5348                 :            : 
    5349                 :            : duration_kind
    5350                 :    5103660 : decl_storage_duration (tree decl)
    5351                 :            : {
    5352                 :    5103660 :   if (TREE_CODE (decl) == PARM_DECL)
    5353                 :            :     return dk_auto;
    5354                 :    5103660 :   if (TREE_CODE (decl) == FUNCTION_DECL)
    5355                 :            :     return dk_static;
    5356                 :    5103660 :   gcc_assert (VAR_P (decl));
    5357                 :    5103660 :   if (!TREE_STATIC (decl)
    5358                 :    7875140 :       && !DECL_EXTERNAL (decl))
    5359                 :            :     return dk_auto;
    5360                 :    2622280 :   if (CP_DECL_THREAD_LOCAL_P (decl))
    5361                 :            :     return dk_thread;
    5362                 :            :   return dk_static;
    5363                 :            : }
    5364                 :            : 
    5365                 :            : /* EXP is an expression that we want to pre-evaluate.  Returns (in
    5366                 :            :    *INITP) an expression that will perform the pre-evaluation.  The
    5367                 :            :    value returned by this function is a side-effect free expression
    5368                 :            :    equivalent to the pre-evaluated expression.  Callers must ensure
    5369                 :            :    that *INITP is evaluated before EXP.  */
    5370                 :            : 
    5371                 :            : tree
    5372                 :     643156 : stabilize_expr (tree exp, tree* initp)
    5373                 :            : {
    5374                 :     643156 :   tree init_expr;
    5375                 :            : 
    5376                 :     643156 :   if (!TREE_SIDE_EFFECTS (exp))
    5377                 :            :     init_expr = NULL_TREE;
    5378                 :     179499 :   else if (VOID_TYPE_P (TREE_TYPE (exp)))
    5379                 :            :     {
    5380                 :          0 :       init_expr = exp;
    5381                 :          0 :       exp = void_node;
    5382                 :            :     }
    5383                 :            :   /* There are no expressions with REFERENCE_TYPE, but there can be call
    5384                 :            :      arguments with such a type; just treat it as a pointer.  */
    5385                 :     179499 :   else if (TYPE_REF_P (TREE_TYPE (exp))
    5386                 :     154687 :            || SCALAR_TYPE_P (TREE_TYPE (exp))
    5387                 :     212029 :            || !glvalue_p (exp))
    5388                 :            :     {
    5389                 :     148859 :       init_expr = get_target_expr (exp);
    5390                 :     148859 :       exp = TARGET_EXPR_SLOT (init_expr);
    5391                 :     148859 :       if (CLASS_TYPE_P (TREE_TYPE (exp)))
    5392                 :       1886 :         exp = move (exp);
    5393                 :            :       else
    5394                 :     146973 :         exp = rvalue (exp);
    5395                 :            :     }
    5396                 :            :   else
    5397                 :            :     {
    5398                 :      30640 :       bool xval = !lvalue_p (exp);
    5399                 :      30640 :       exp = cp_build_addr_expr (exp, tf_warning_or_error);
    5400                 :      30640 :       init_expr = get_target_expr (exp);
    5401                 :      30640 :       exp = TARGET_EXPR_SLOT (init_expr);
    5402                 :      30640 :       exp = cp_build_fold_indirect_ref (exp);
    5403                 :      30640 :       if (xval)
    5404                 :      15307 :         exp = move (exp);
    5405                 :            :     }
    5406                 :     643156 :   *initp = init_expr;
    5407                 :            : 
    5408                 :     643156 :   gcc_assert (!TREE_SIDE_EFFECTS (exp));
    5409                 :     643156 :   return exp;
    5410                 :            : }
    5411                 :            : 
    5412                 :            : /* Add NEW_EXPR, an expression whose value we don't care about, after the
    5413                 :            :    similar expression ORIG.  */
    5414                 :            : 
    5415                 :            : tree
    5416                 :     359843 : add_stmt_to_compound (tree orig, tree new_expr)
    5417                 :            : {
    5418                 :     500718 :   if (!new_expr || !TREE_SIDE_EFFECTS (new_expr))
    5419                 :            :     return orig;
    5420                 :     151331 :   if (!orig || !TREE_SIDE_EFFECTS (orig))
    5421                 :            :     return new_expr;
    5422                 :      12283 :   return build2 (COMPOUND_EXPR, void_type_node, orig, new_expr);
    5423                 :            : }
    5424                 :            : 
    5425                 :            : /* Like stabilize_expr, but for a call whose arguments we want to
    5426                 :            :    pre-evaluate.  CALL is modified in place to use the pre-evaluated
    5427                 :            :    arguments, while, upon return, *INITP contains an expression to
    5428                 :            :    compute the arguments.  */
    5429                 :            : 
    5430                 :            : void
    5431                 :     169386 : stabilize_call (tree call, tree *initp)
    5432                 :            : {
    5433                 :     169386 :   tree inits = NULL_TREE;
    5434                 :     169386 :   int i;
    5435                 :     169386 :   int nargs = call_expr_nargs (call);
    5436                 :            : 
    5437                 :     169386 :   if (call == error_mark_node || processing_template_decl)
    5438                 :            :     {
    5439                 :         15 :       *initp = NULL_TREE;
    5440                 :         15 :       return;
    5441                 :            :     }
    5442                 :            : 
    5443                 :     169371 :   gcc_assert (TREE_CODE (call) == CALL_EXPR);
    5444                 :            : 
    5445                 :     479378 :   for (i = 0; i < nargs; i++)
    5446                 :            :     {
    5447                 :     310007 :       tree init;
    5448                 :     930021 :       CALL_EXPR_ARG (call, i) =
    5449                 :     310007 :         stabilize_expr (CALL_EXPR_ARG (call, i), &init);
    5450                 :     310007 :       inits = add_stmt_to_compound (inits, init);
    5451                 :            :     }
    5452                 :            : 
    5453                 :     169371 :   *initp = inits;
    5454                 :            : }
    5455                 :            : 
    5456                 :            : /* Like stabilize_expr, but for an AGGR_INIT_EXPR whose arguments we want
    5457                 :            :    to pre-evaluate.  CALL is modified in place to use the pre-evaluated
    5458                 :            :    arguments, while, upon return, *INITP contains an expression to
    5459                 :            :    compute the arguments.  */
    5460                 :            : 
    5461                 :            : static void
    5462                 :      38947 : stabilize_aggr_init (tree call, tree *initp)
    5463                 :            : {
    5464                 :      38947 :   tree inits = NULL_TREE;
    5465                 :      38947 :   int i;
    5466                 :      38947 :   int nargs = aggr_init_expr_nargs (call);
    5467                 :            : 
    5468                 :      38947 :   if (call == error_mark_node)
    5469                 :            :     return;
    5470                 :            : 
    5471                 :      38947 :   gcc_assert (TREE_CODE (call) == AGGR_INIT_EXPR);
    5472                 :            : 
    5473                 :      77990 :   for (i = 0; i < nargs; i++)
    5474                 :            :     {
    5475                 :      39043 :       tree init;
    5476                 :     117129 :       AGGR_INIT_EXPR_ARG (call, i) =
    5477                 :      39043 :         stabilize_expr (AGGR_INIT_EXPR_ARG (call, i), &init);
    5478                 :      39043 :       inits = add_stmt_to_compound (inits, init);
    5479                 :            :     }
    5480                 :            : 
    5481                 :      38947 :   *initp = inits;
    5482                 :            : }
    5483                 :            : 
    5484                 :            : /* Like stabilize_expr, but for an initialization.  
    5485                 :            : 
    5486                 :            :    If the initialization is for an object of class type, this function
    5487                 :            :    takes care not to introduce additional temporaries.
    5488                 :            : 
    5489                 :            :    Returns TRUE iff the expression was successfully pre-evaluated,
    5490                 :            :    i.e., if INIT is now side-effect free, except for, possibly, a
    5491                 :            :    single call to a constructor.  */
    5492                 :            : 
    5493                 :            : bool
    5494                 :     144744 : stabilize_init (tree init, tree *initp)
    5495                 :            : {
    5496                 :     144744 :   tree t = init;
    5497                 :            : 
    5498                 :     144744 :   *initp = NULL_TREE;
    5499                 :            : 
    5500                 :     144744 :   if (t == error_mark_node || processing_template_decl)
    5501                 :            :     return true;
    5502                 :            : 
    5503                 :     140588 :   if (TREE_CODE (t) == INIT_EXPR)
    5504                 :      73965 :     t = TREE_OPERAND (t, 1);
    5505                 :     140588 :   if (TREE_CODE (t) == TARGET_EXPR)
    5506                 :        187 :     t = TARGET_EXPR_INITIAL (t);
    5507                 :            : 
    5508                 :            :   /* If the RHS can be stabilized without breaking copy elision, stabilize
    5509                 :            :      it.  We specifically don't stabilize class prvalues here because that
    5510                 :            :      would mean an extra copy, but they might be stabilized below.  */
    5511                 :     140588 :   if (TREE_CODE (init) == INIT_EXPR
    5512                 :      73965 :       && TREE_CODE (t) != CONSTRUCTOR
    5513                 :      73665 :       && TREE_CODE (t) != AGGR_INIT_EXPR
    5514                 :     175324 :       && (SCALAR_TYPE_P (TREE_TYPE (t))
    5515                 :      30967 :           || glvalue_p (t)))
    5516                 :            :     {
    5517                 :      34650 :       TREE_OPERAND (init, 1) = stabilize_expr (t, initp);
    5518                 :      34650 :       return true;
    5519                 :            :     }
    5520                 :            : 
    5521                 :     105938 :   if (TREE_CODE (t) == COMPOUND_EXPR
    5522                 :          4 :       && TREE_CODE (init) == INIT_EXPR)
    5523                 :            :     {
    5524                 :          4 :       tree last = expr_last (t);
    5525                 :            :       /* Handle stabilizing the EMPTY_CLASS_EXPR pattern.  */
    5526                 :          4 :       if (!TREE_SIDE_EFFECTS (last))
    5527                 :            :         {
    5528                 :          0 :           *initp = t;
    5529                 :          0 :           TREE_OPERAND (init, 1) = last;
    5530                 :          0 :           return true;
    5531                 :            :         }
    5532                 :            :     }
    5533                 :            : 
    5534                 :     105938 :   if (TREE_CODE (t) == CONSTRUCTOR)
    5535                 :            :     {
    5536                 :            :       /* Aggregate initialization: stabilize each of the field
    5537                 :            :          initializers.  */
    5538                 :        369 :       unsigned i;
    5539                 :        369 :       constructor_elt *ce;
    5540                 :        369 :       bool good = true;
    5541                 :        369 :       vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (t);
    5542                 :        818 :       for (i = 0; vec_safe_iterate (v, i, &ce); ++i)
    5543                 :            :         {
    5544                 :        449 :           tree type = TREE_TYPE (ce->value);
    5545                 :        449 :           tree subinit;
    5546                 :        449 :           if (TYPE_REF_P (type)
    5547                 :        449 :               || SCALAR_TYPE_P (type))
    5548                 :        359 :             ce->value = stabilize_expr (ce->value, &subinit);
    5549                 :         90 :           else if (!stabilize_init (ce->value, &subinit))
    5550                 :          0 :             good = false;
    5551                 :        449 :           *initp = add_stmt_to_compound (*initp, subinit);
    5552                 :            :         }
    5553                 :        369 :       return good;
    5554                 :            :     }
    5555                 :            : 
    5556                 :     105569 :   if (TREE_CODE (t) == CALL_EXPR)
    5557                 :            :     {
    5558                 :      65834 :       stabilize_call (t, initp);
    5559                 :      65834 :       return true;
    5560                 :            :     }
    5561                 :            : 
    5562                 :      39735 :   if (TREE_CODE (t) == AGGR_INIT_EXPR)
    5563                 :            :     {
    5564                 :      38947 :       stabilize_aggr_init (t, initp);
    5565                 :      38947 :       return true;
    5566                 :            :     }
    5567                 :            : 
    5568                 :            :   /* The initialization is being performed via a bitwise copy -- and
    5569                 :            :      the item copied may have side effects.  */
    5570                 :        788 :   return !TREE_SIDE_EFFECTS (init);
    5571                 :            : }
    5572                 :            : 
    5573                 :            : /* Returns true if a cast to TYPE may appear in an integral constant
    5574                 :            :    expression.  */
    5575                 :            : 
    5576                 :            : bool
    5577                 :    6329310 : cast_valid_in_integral_constant_expression_p (tree type)
    5578                 :            : {
    5579                 :    6329310 :   return (INTEGRAL_OR_ENUMERATION_TYPE_P (type)
    5580                 :    4440850 :           || cxx_dialect >= cxx11
    5581                 :     231126 :           || dependent_type_p (type)
    5582                 :    6498470 :           || type == error_mark_node);
    5583                 :            : }
    5584                 :            : 
    5585                 :            : /* Return true if we need to fix linkage information of DECL.  */
    5586                 :            : 
    5587                 :            : static bool
    5588                 :    1513720 : cp_fix_function_decl_p (tree decl)
    5589                 :            : {
    5590                 :            :   /* Skip if DECL is not externally visible.  */
    5591                 :    1513720 :   if (!TREE_PUBLIC (decl))
    5592                 :            :     return false;
    5593                 :            : 
    5594                 :            :   /* We need to fix DECL if it a appears to be exported but with no
    5595                 :            :      function body.  Thunks do not have CFGs and we may need to
    5596                 :            :      handle them specially later.   */
    5597                 :    1511660 :   if (!gimple_has_body_p (decl)
    5598                 :    2942650 :       && !DECL_THUNK_P (decl)
    5599                 :    2982380 :       && !DECL_EXTERNAL (decl))
    5600                 :            :     {
    5601                 :      10169 :       struct cgraph_node *node = cgraph_node::get (decl);
    5602                 :            : 
    5603                 :            :       /* Don't fix same_body aliases.  Although they don't have their own
    5604                 :            :          CFG, they share it with what they alias to.  */
    5605                 :       4890 :       if (!node || !node->alias
    5606                 :      15059 :           || !vec_safe_length (node->ref_list.references))
    5607                 :       5279 :         return true;
    5608                 :            :     }
    5609                 :            : 
    5610                 :            :   return false;
    5611                 :            : }
    5612                 :            : 
    5613                 :            : /* Clean the C++ specific parts of the tree T. */
    5614                 :            : 
    5615                 :            : void
    5616                 :    2703420 : cp_free_lang_data (tree t)
    5617                 :            : {
    5618                 :    2703420 :   if (FUNC_OR_METHOD_TYPE_P (t))
    5619                 :            :     {
    5620                 :            :       /* Default args are not interesting anymore.  */
    5621                 :     420443 :       tree argtypes = TYPE_ARG_TYPES (t);
    5622                 :    1589610 :       while (argtypes)
    5623                 :            :         {
    5624                 :    1169160 :           TREE_PURPOSE (argtypes) = 0;
    5625                 :    1169160 :           argtypes = TREE_CHAIN (argtypes);
    5626                 :            :         }
    5627                 :            :     }
    5628                 :    2282980 :   else if (TREE_CODE (t) == FUNCTION_DECL
    5629                 :    2282980 :            && cp_fix_function_decl_p (t))
    5630                 :            :     {
    5631                 :            :       /* If T is used in this translation unit at all,  the definition
    5632                 :            :          must exist somewhere else since we have decided to not emit it
    5633                 :            :          in this TU.  So make it an external reference.  */
    5634                 :       5279 :       DECL_EXTERNAL (t) = 1;
    5635                 :       5279 :       TREE_STATIC (t) = 0;
    5636                 :            :     }
    5637                 :    2703420 :   if (TREE_CODE (t) == FUNCTION_DECL)
    5638                 :    1513720 :     discard_operator_bindings (t);
    5639                 :    2703420 :   if (TREE_CODE (t) == NAMESPACE_DECL)
    5640                 :            :     /* We do not need the leftover chaining of namespaces from the
    5641                 :            :        binding level.  */
    5642                 :       2427 :     DECL_CHAIN (t) = NULL_TREE;
    5643                 :    2703420 : }
    5644                 :            : 
    5645                 :            : /* Stub for c-common.  Please keep in sync with c-decl.c.
    5646                 :            :    FIXME: If address space support is target specific, then this
    5647                 :            :    should be a C target hook.  But currently this is not possible,
    5648                 :            :    because this function is called via REGISTER_TARGET_PRAGMAS.  */
    5649                 :            : void
    5650                 :     156466 : c_register_addr_space (const char * /*word*/, addr_space_t /*as*/)
    5651                 :            : {
    5652                 :     156466 : }
    5653                 :            : 
    5654                 :            : /* Return the number of operands in T that we care about for things like
    5655                 :            :    mangling.  */
    5656                 :            : 
    5657                 :            : int
    5658                 :   41151600 : cp_tree_operand_length (const_tree t)
    5659                 :            : {
    5660                 :   41151600 :   enum tree_code code = TREE_CODE (t);
    5661                 :            : 
    5662                 :   41151600 :   if (TREE_CODE_CLASS (code) == tcc_vl_exp)
    5663                 :    4430590 :     return VL_EXP_OPERAND_LENGTH (t);
    5664                 :            : 
    5665                 :   36721000 :   return cp_tree_code_length (code);
    5666                 :            : }
    5667                 :            : 
    5668                 :            : /* Like cp_tree_operand_length, but takes a tree_code CODE.  */
    5669                 :            : 
    5670                 :            : int
    5671                 :   36897500 : cp_tree_code_length (enum tree_code code)
    5672                 :            : {
    5673                 :   36897500 :   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
    5674                 :            : 
    5675                 :   36897500 :   switch (code)
    5676                 :            :     {
    5677                 :            :     case PREINCREMENT_EXPR:
    5678                 :            :     case PREDECREMENT_EXPR:
    5679                 :            :     case POSTINCREMENT_EXPR:
    5680                 :            :     case POSTDECREMENT_EXPR:
    5681                 :            :       return 1;
    5682                 :            : 
    5683                 :      11439 :     case ARRAY_REF:
    5684                 :      11439 :       return 2;
    5685                 :            : 
    5686                 :            :     case EXPR_PACK_EXPANSION:
    5687                 :            :       return 1;
    5688                 :            : 
    5689                 :   36678500 :     default:
    5690                 :   36678500 :       return TREE_CODE_LENGTH (code);
    5691                 :            :     }
    5692                 :            : }
    5693                 :            : 
    5694                 :            : /* Like EXPR_LOCATION, but also handle some tcc_exceptional that have
    5695                 :            :    locations.  */
    5696                 :            : 
    5697                 :            : location_t
    5698                 : 1804400000 : cp_expr_location (const_tree t_)
    5699                 :            : {
    5700                 : 1804400000 :   tree t = CONST_CAST_TREE (t_);
    5701                 : 1804400000 :   if (t == NULL_TREE)
    5702                 :            :     return UNKNOWN_LOCATION;
    5703                 : 1677480000 :   switch (TREE_CODE (t))
    5704                 :            :     {
    5705                 :      60635 :     case LAMBDA_EXPR:
    5706                 :      60635 :       return LAMBDA_EXPR_LOCATION (t);
    5707                 :     147695 :     case STATIC_ASSERT:
    5708                 :     147695 :       return STATIC_ASSERT_SOURCE_LOCATION (t);
    5709                 :    3756870 :     case TRAIT_EXPR:
    5710                 :    3756870 :       return TRAIT_EXPR_LOCATION (t);
    5711                 : 1673520000 :     default:
    5712                 : 1673520000 :       return EXPR_LOCATION (t);
    5713                 :            :     }
    5714                 :            : }
    5715                 :            : 
    5716                 :            : /* Implement -Wzero_as_null_pointer_constant.  Return true if the
    5717                 :            :    conditions for the warning hold, false otherwise.  */
    5718                 :            : bool
    5719                 :    1321370 : maybe_warn_zero_as_null_pointer_constant (tree expr, location_t loc)
    5720                 :            : {
    5721                 :    1321370 :   if (c_inhibit_evaluation_warnings == 0
    5722                 :    3680840 :       && !null_node_p (expr) && !NULLPTR_TYPE_P (TREE_TYPE (expr)))
    5723                 :            :     {
    5724                 :     466703 :       warning_at (loc, OPT_Wzero_as_null_pointer_constant,
    5725                 :            :                   "zero as null pointer constant");
    5726                 :     466703 :       return true;
    5727                 :            :     }
    5728                 :            :   return false;
    5729                 :            : }
    5730                 :            : 
    5731                 :            : /* Given an initializer INIT for a TYPE, return true if INIT is zero
    5732                 :            :    so that it can be replaced by value initialization.  This function
    5733                 :            :    distinguishes betwen empty strings as initializers for arrays and
    5734                 :            :    for pointers (which make it return false).  */
    5735                 :            : 
    5736                 :            : bool
    5737                 :     460132 : type_initializer_zero_p (tree type, tree init)
    5738                 :            : {
    5739                 :     460132 :   if (type == error_mark_node || init == error_mark_node)
    5740                 :            :     return false;
    5741                 :            : 
    5742                 :     460128 :   STRIP_NOPS (init);
    5743                 :            : 
    5744                 :     460128 :   if (POINTER_TYPE_P (type))
    5745                 :      39913 :     return TREE_CODE (init) != STRING_CST && initializer_zerop (init);
    5746                 :            : 
    5747                 :     420215 :   if (TREE_CODE (init) != CONSTRUCTOR)
    5748                 :            :     {
    5749                 :            :       /* A class can only be initialized by a non-class type if it has
    5750                 :            :          a ctor that converts from that type.  Such classes are excluded
    5751                 :            :          since their semantics are unknown.  */
    5752                 :     336543 :       if (RECORD_OR_UNION_TYPE_P (type)
    5753                 :     342406 :           && !RECORD_OR_UNION_TYPE_P (TREE_TYPE (init)))
    5754                 :            :         return false;
    5755                 :     332751 :       return initializer_zerop (init);
    5756                 :            :     }
    5757                 :            : 
    5758                 :      83672 :   if (TREE_CODE (type) == ARRAY_TYPE)
    5759                 :            :     {
    5760                 :       1475 :       tree elt_type = TREE_TYPE (type);
    5761                 :       1475 :       elt_type = TYPE_MAIN_VARIANT (elt_type);
    5762                 :       1475 :       if (elt_type == char_type_node)
    5763                 :        231 :         return initializer_zerop (init);
    5764                 :            : 
    5765                 :            :       tree elt_init;
    5766                 :            :       unsigned HOST_WIDE_INT i;
    5767                 :       2935 :       FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), i, elt_init)
    5768                 :       1154 :         if (!type_initializer_zero_p (elt_type, elt_init))
    5769                 :            :           return false;
    5770                 :            :       return true;
    5771                 :            :     }
    5772                 :            : 
    5773                 :      82197 :   if (TREE_CODE (type) != RECORD_TYPE)
    5774                 :       5198 :     return initializer_zerop (init);
    5775                 :            : 
    5776                 :      76999 :   if (TYPE_NON_AGGREGATE_CLASS (type))
    5777                 :            :     return false;
    5778                 :            : 
    5779                 :      73018 :   tree fld = TYPE_FIELDS (type);
    5780                 :            : 
    5781                 :      73018 :   tree fld_init;
    5782                 :      73018 :   unsigned HOST_WIDE_INT i;
    5783                 :     148930 :   FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), i, fld_init)
    5784                 :            :     {
    5785                 :      74024 :       fld = next_initializable_field (fld);
    5786                 :      74024 :       if (!fld)
    5787                 :            :         return true;
    5788                 :            : 
    5789                 :      74024 :       tree fldtype = TREE_TYPE (fld);
    5790                 :      74024 :       if (!type_initializer_zero_p (fldtype, fld_init))
    5791                 :            :         return false;
    5792                 :            : 
    5793                 :       1571 :       fld = DECL_CHAIN (fld);
    5794                 :       1571 :       if (!fld)
    5795                 :            :         break;
    5796                 :            :     }
    5797                 :            : 
    5798                 :            :   return true;
    5799                 :            : }
    5800                 :            : 
    5801                 :            : #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
    5802                 :            : /* Complain that some language-specific thing hanging off a tree
    5803                 :            :    node has been accessed improperly.  */
    5804                 :            : 
    5805                 :            : void
    5806                 :          0 : lang_check_failed (const char* file, int line, const char* function)
    5807                 :            : {
    5808                 :          0 :   internal_error ("%<lang_*%> check: failed in %s, at %s:%d",
    5809                 :            :                   function, trim_filename (file), line);
    5810                 :            : }
    5811                 :            : #endif /* ENABLE_TREE_CHECKING */
    5812                 :            : 
    5813                 :            : #if CHECKING_P
    5814                 :            : 
    5815                 :            : namespace selftest {
    5816                 :            : 
    5817                 :            : /* Verify that lvalue_kind () works, for various expressions,
    5818                 :            :    and that location wrappers don't affect the results.  */
    5819                 :            : 
    5820                 :            : static void
    5821                 :          1 : test_lvalue_kind ()
    5822                 :            : {
    5823                 :          1 :   location_t loc = BUILTINS_LOCATION;
    5824                 :            : 
    5825                 :            :   /* Verify constants and parameters, without and with
    5826                 :            :      location wrappers.  */
    5827                 :          1 :   tree int_cst = build_int_cst (integer_type_node, 42);
    5828                 :          1 :   ASSERT_EQ (clk_none, lvalue_kind (int_cst));
    5829                 :            : 
    5830                 :          1 :   tree wrapped_int_cst = maybe_wrap_with_location (int_cst, loc);
    5831                 :          1 :   ASSERT_TRUE (location_wrapper_p (wrapped_int_cst));
    5832                 :          1 :   ASSERT_EQ (clk_none, lvalue_kind (wrapped_int_cst));
    5833                 :            : 
    5834                 :          1 :   tree string_lit = build_string (4, "foo");
    5835                 :          1 :   TREE_TYPE (string_lit) = char_array_type_node;
    5836                 :          1 :   string_lit = fix_string_type (string_lit);
    5837                 :          1 :   ASSERT_EQ (clk_ordinary, lvalue_kind (string_lit));
    5838                 :            : 
    5839                 :          1 :   tree wrapped_string_lit = maybe_wrap_with_location (string_lit, loc);
    5840                 :          1 :   ASSERT_TRUE (location_wrapper_p (wrapped_string_lit));
    5841                 :          1 :   ASSERT_EQ (clk_ordinary, lvalue_kind (wrapped_string_lit));
    5842                 :            : 
    5843                 :          1 :   tree parm = build_decl (UNKNOWN_LOCATION, PARM_DECL,
    5844                 :            :                           get_identifier ("some_parm"),
    5845                 :            :                           integer_type_node);
    5846                 :          1 :   ASSERT_EQ (clk_ordinary, lvalue_kind (parm));
    5847                 :            : 
    5848                 :          1 :   tree wrapped_parm = maybe_wrap_with_location (parm, loc);
    5849                 :          1 :   ASSERT_TRUE (location_wrapper_p (wrapped_parm));
    5850                 :          1 :   ASSERT_EQ (clk_ordinary, lvalue_kind (wrapped_parm));
    5851                 :            : 
    5852                 :            :   /* Verify that lvalue_kind of std::move on a parm isn't
    5853                 :            :      affected by location wrappers.  */
    5854                 :          1 :   tree rvalue_ref_of_parm = move (parm);
    5855                 :          1 :   ASSERT_EQ (clk_rvalueref, lvalue_kind (rvalue_ref_of_parm));
    5856                 :          1 :   tree rvalue_ref_of_wrapped_parm = move (wrapped_parm);
    5857                 :          1 :   ASSERT_EQ (clk_rvalueref, lvalue_kind (rvalue_ref_of_wrapped_parm));
    5858                 :            : 
    5859                 :            :   /* Verify lvalue_p.  */
    5860                 :          1 :   ASSERT_FALSE (lvalue_p (int_cst));
    5861                 :          1 :   ASSERT_FALSE (lvalue_p (wrapped_int_cst));
    5862                 :          1 :   ASSERT_TRUE (lvalue_p (parm));
    5863                 :          1 :   ASSERT_TRUE (lvalue_p (wrapped_parm));
    5864                 :          1 :   ASSERT_FALSE (lvalue_p (rvalue_ref_of_parm));
    5865                 :          1 :   ASSERT_FALSE (lvalue_p (rvalue_ref_of_wrapped_parm));
    5866                 :          1 : }
    5867                 :            : 
    5868                 :            : /* Run all of the selftests within this file.  */
    5869                 :            : 
    5870                 :            : void
    5871                 :          1 : cp_tree_c_tests ()
    5872                 :            : {
    5873                 :          1 :   test_lvalue_kind ();
    5874                 :          1 : }
    5875                 :            : 
    5876                 :            : } // namespace selftest
    5877                 :            : 
    5878                 :            : #endif /* #if CHECKING_P */
    5879                 :            : 
    5880                 :            : 
    5881                 :            : #include "gt-cp-tree.h"

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.