LCOV - code coverage report
Current view: top level - gcc/cp - typeck2.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 93.0 % 1236 1150
Test Date: 2025-01-11 13:11:20 Functions: 100.0 % 40 40
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* Report error messages, build initializers, and perform
       2                 :             :    some front-end optimizations for C++ compiler.
       3                 :             :    Copyright (C) 1987-2025 Free Software Foundation, Inc.
       4                 :             :    Hacked by Michael Tiemann (tiemann@cygnus.com)
       5                 :             : 
       6                 :             : This file is part of GCC.
       7                 :             : 
       8                 :             : GCC is free software; you can redistribute it and/or modify
       9                 :             : it under the terms of the GNU General Public License as published by
      10                 :             : the Free Software Foundation; either version 3, or (at your option)
      11                 :             : any later version.
      12                 :             : 
      13                 :             : GCC is distributed in the hope that it will be useful,
      14                 :             : but WITHOUT ANY WARRANTY; without even the implied warranty of
      15                 :             : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      16                 :             : GNU General Public License for more details.
      17                 :             : 
      18                 :             : You should have received a copy of the GNU General Public License
      19                 :             : along with GCC; see the file COPYING3.  If not see
      20                 :             : <http://www.gnu.org/licenses/>.  */
      21                 :             : 
      22                 :             : 
      23                 :             : /* This file is part of the C++ front end.
      24                 :             :    It contains routines to build C++ expressions given their operands,
      25                 :             :    including computing the types of the result, C and C++ specific error
      26                 :             :    checks, and some optimization.  */
      27                 :             : 
      28                 :             : #include "config.h"
      29                 :             : #include "system.h"
      30                 :             : #include "coretypes.h"
      31                 :             : #include "cp-tree.h"
      32                 :             : #include "stor-layout.h"
      33                 :             : #include "varasm.h"
      34                 :             : #include "intl.h"
      35                 :             : #include "gcc-rich-location.h"
      36                 :             : #include "target.h"
      37                 :             : 
      38                 :             : static tree
      39                 :             : process_init_constructor (tree type, tree init, int nested, int flags,
      40                 :             :                           tsubst_flags_t complain);
      41                 :             : 
      42                 :             : 
      43                 :             : /* Print an error message stemming from an attempt to use
      44                 :             :    BASETYPE as a base class for TYPE.  */
      45                 :             : 
      46                 :             : tree
      47                 :          26 : error_not_base_type (tree basetype, tree type)
      48                 :             : {
      49                 :          26 :   if (TREE_CODE (basetype) == FUNCTION_DECL)
      50                 :           0 :     basetype = DECL_CONTEXT (basetype);
      51                 :          26 :   error ("type %qT is not a base type for type %qT", basetype, type);
      52                 :          26 :   return error_mark_node;
      53                 :             : }
      54                 :             : 
      55                 :             : tree
      56                 :        1307 : binfo_or_else (tree base, tree type)
      57                 :             : {
      58                 :        1307 :   tree binfo = lookup_base (type, base, ba_unique,
      59                 :             :                             NULL, tf_warning_or_error);
      60                 :             : 
      61                 :        1307 :   if (binfo == error_mark_node)
      62                 :             :     return NULL_TREE;
      63                 :        1307 :   else if (!binfo)
      64                 :           0 :     error_not_base_type (base, type);
      65                 :             :   return binfo;
      66                 :             : }
      67                 :             : 
      68                 :             : /* According to ARM $7.1.6, "A `const' object may be initialized, but its
      69                 :             :    value may not be changed thereafter.  */
      70                 :             : 
      71                 :             : void
      72                 :         144 : cxx_readonly_error (location_t loc, tree arg, enum lvalue_use errstring)
      73                 :             : {
      74                 :             : 
      75                 :             : /* This macro is used to emit diagnostics to ensure that all format
      76                 :             :    strings are complete sentences, visible to gettext and checked at
      77                 :             :    compile time.  */
      78                 :             : 
      79                 :             : #define ERROR_FOR_ASSIGNMENT(LOC, AS, ASM, IN, DE, ARG)                 \
      80                 :             :   do {                                                                  \
      81                 :             :     switch (errstring)                                                  \
      82                 :             :       {                                                                 \
      83                 :             :       case lv_assign:                                                   \
      84                 :             :         error_at (LOC, AS, ARG);                                        \
      85                 :             :         break;                                                          \
      86                 :             :       case lv_asm:                                                      \
      87                 :             :         error_at (LOC, ASM, ARG);                                       \
      88                 :             :         break;                                                          \
      89                 :             :       case lv_increment:                                                \
      90                 :             :         error_at (LOC, IN, ARG);                                        \
      91                 :             :         break;                                                          \
      92                 :             :       case lv_decrement:                                                \
      93                 :             :         error_at (LOC, DE, ARG);                                        \
      94                 :             :         break;                                                          \
      95                 :             :       default:                                                          \
      96                 :             :         gcc_unreachable ();                                             \
      97                 :             :       }                                                                 \
      98                 :             :   } while (0)
      99                 :             : 
     100                 :             :   /* Handle C++-specific things first.  */
     101                 :             : 
     102                 :         144 :   if (VAR_P (arg)
     103                 :          15 :       && DECL_LANG_SPECIFIC (arg)
     104                 :           0 :       && DECL_IN_AGGR_P (arg)
     105                 :         144 :       && !TREE_STATIC (arg))
     106                 :           0 :     ERROR_FOR_ASSIGNMENT (loc,
     107                 :             :                           G_("assignment of constant field %qD"),
     108                 :             :                           G_("constant field %qD used as %<asm%> output"),
     109                 :             :                           G_("increment of constant field %qD"),
     110                 :             :                           G_("decrement of constant field %qD"),
     111                 :             :                           arg);
     112                 :         144 :   else if (INDIRECT_REF_P (arg)
     113                 :          24 :            && TYPE_REF_P (TREE_TYPE (TREE_OPERAND (arg, 0)))
     114                 :         162 :            && (VAR_P (TREE_OPERAND (arg, 0))
     115                 :           5 :                || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL))
     116                 :          13 :     ERROR_FOR_ASSIGNMENT (loc,
     117                 :             :                           G_("assignment of read-only reference %qD"),
     118                 :             :                           G_("read-only reference %qD used as %<asm%> output"),
     119                 :             :                           G_("increment of read-only reference %qD"),
     120                 :             :                           G_("decrement of read-only reference %qD"),
     121                 :             :                           TREE_OPERAND (arg, 0));
     122                 :             :   else
     123                 :         131 :     readonly_error (loc, arg, errstring);
     124                 :         144 : }
     125                 :             : 
     126                 :             : /* If TYPE has abstract virtual functions, issue an error about trying
     127                 :             :    to create an object of that type.  DECL is the object declared, or
     128                 :             :    NULL_TREE if the declaration is unavailable, in which case USE specifies
     129                 :             :    the kind of invalid use.  Returns 1 if an error occurred; zero if
     130                 :             :    all was well.  */
     131                 :             : 
     132                 :             : static int
     133                 :   304336155 : abstract_virtuals_error (tree decl, tree type, abstract_class_use use,
     134                 :             :                          tsubst_flags_t complain)
     135                 :             : {
     136                 :   304336155 :   vec<tree, va_gc> *pure;
     137                 :             : 
     138                 :   304336155 :   if (TREE_CODE (type) == ARRAY_TYPE)
     139                 :             :     {
     140                 :      739650 :       decl = NULL_TREE;
     141                 :      739650 :       use = ACU_ARRAY;
     142                 :      739650 :       type = strip_array_types (type);
     143                 :             :     }
     144                 :             : 
     145                 :             :   /* This function applies only to classes. Any other entity can never
     146                 :             :      be abstract.  */
     147                 :   304336155 :   if (!CLASS_TYPE_P (type))
     148                 :             :     return 0;
     149                 :    45030162 :   type = TYPE_MAIN_VARIANT (type);
     150                 :             : 
     151                 :             : #if 0
     152                 :             :   /* Instantiation here seems to be required by the standard,
     153                 :             :      but breaks e.g. boost::bind.  FIXME!  */
     154                 :             :   /* In SFINAE, non-N3276 context, force instantiation.  */
     155                 :             :   if (!(complain & (tf_error|tf_decltype)))
     156                 :             :     complete_type (type);
     157                 :             : #endif
     158                 :             : 
     159                 :    45030162 :   if (!TYPE_SIZE (type))
     160                 :             :     /* TYPE is being defined, and during that time
     161                 :             :        CLASSTYPE_PURE_VIRTUALS holds the inline friends.  */
     162                 :             :     return 0;
     163                 :             : 
     164                 :    45030100 :   pure = CLASSTYPE_PURE_VIRTUALS (type);
     165                 :    45030100 :   if (!pure)
     166                 :             :     return 0;
     167                 :             : 
     168                 :         126 :   if (!(complain & tf_error))
     169                 :             :     return 1;
     170                 :             : 
     171                 :         102 :   auto_diagnostic_group d;
     172                 :         102 :   if (decl)
     173                 :             :     {
     174                 :          51 :       if (VAR_P (decl))
     175                 :           9 :         error ("cannot declare variable %q+D to be of abstract "
     176                 :             :                "type %qT", decl, type);
     177                 :          42 :       else if (TREE_CODE (decl) == PARM_DECL)
     178                 :             :         {
     179                 :          27 :           if (DECL_NAME (decl))
     180                 :          24 :             error ("cannot declare parameter %q+D to be of abstract type %qT",
     181                 :             :                    decl, type);
     182                 :             :           else
     183                 :           3 :             error ("cannot declare parameter to be of abstract type %qT",
     184                 :             :                    type);
     185                 :             :         }
     186                 :          15 :       else if (TREE_CODE (decl) == FIELD_DECL)
     187                 :          12 :         error ("cannot declare field %q+D to be of abstract type %qT",
     188                 :             :                decl, type);
     189                 :           3 :       else if (TREE_CODE (decl) == FUNCTION_DECL
     190                 :           3 :                && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
     191                 :           0 :         error ("invalid abstract return type for member function %q+#D", decl);
     192                 :           3 :       else if (TREE_CODE (decl) == FUNCTION_DECL)
     193                 :           3 :         error ("invalid abstract return type for function %q+#D", decl);
     194                 :           0 :       else if (identifier_p (decl))
     195                 :             :         /* Here we do not have location information.  */
     196                 :           0 :         error ("invalid abstract type %qT for %qE", type, decl);
     197                 :             :       else
     198                 :           0 :         error ("invalid abstract type for %q+D", decl);
     199                 :             :     }
     200                 :          51 :   else switch (use)
     201                 :             :     {
     202                 :           9 :     case ACU_ARRAY:
     203                 :           9 :       error ("creating array of %qT, which is an abstract class type", type);
     204                 :           9 :       break;
     205                 :           9 :     case ACU_CAST:
     206                 :           9 :       error ("invalid cast to abstract class type %qT", type);
     207                 :           9 :       break;
     208                 :           0 :     case ACU_NEW:
     209                 :           0 :       error ("invalid new-expression of abstract class type %qT", type);
     210                 :           0 :       break;
     211                 :           0 :     case ACU_RETURN:
     212                 :           0 :       error ("invalid abstract return type %qT", type);
     213                 :           0 :       break;
     214                 :           0 :     case ACU_PARM:
     215                 :           0 :       error ("invalid abstract parameter type %qT", type);
     216                 :           0 :       break;
     217                 :           6 :     case ACU_THROW:
     218                 :           6 :       error ("expression of abstract class type %qT cannot "
     219                 :             :              "be used in throw-expression", type);
     220                 :           6 :       break;
     221                 :           3 :     case ACU_CATCH:
     222                 :           3 :       error ("cannot declare %<catch%> parameter to be of abstract "
     223                 :             :              "class type %qT", type);
     224                 :           3 :       break;
     225                 :          24 :     default:
     226                 :          24 :       error ("cannot allocate an object of abstract type %qT", type);
     227                 :             :     }
     228                 :             : 
     229                 :             :   /* Only go through this once.  */
     230                 :         102 :   if (pure->length ())
     231                 :             :     {
     232                 :          42 :       unsigned ix;
     233                 :          42 :       tree fn;
     234                 :             : 
     235                 :          42 :       inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
     236                 :             :               "  because the following virtual functions are pure within %qT:",
     237                 :             :               type);
     238                 :             : 
     239                 :         126 :       FOR_EACH_VEC_ELT (*pure, ix, fn)
     240                 :          84 :         if (! DECL_CLONED_FUNCTION_P (fn)
     241                 :          42 :             || DECL_COMPLETE_DESTRUCTOR_P (fn))
     242                 :          42 :           inform (DECL_SOURCE_LOCATION (fn), "    %#qD", fn);
     243                 :             : 
     244                 :             :       /* Now truncate the vector.  This leaves it non-null, so we know
     245                 :             :          there are pure virtuals, but empty so we don't list them out
     246                 :             :          again.  */
     247                 :          42 :       pure->truncate (0);
     248                 :             :     }
     249                 :             : 
     250                 :         102 :   return 1;
     251                 :         102 : }
     252                 :             : 
     253                 :             : int
     254                 :   263174218 : abstract_virtuals_error (tree decl, tree type,
     255                 :             :                          tsubst_flags_t complain /* = tf_warning_or_error */)
     256                 :             : {
     257                 :   263174218 :   return abstract_virtuals_error (decl, type, ACU_UNKNOWN, complain);
     258                 :             : }
     259                 :             : 
     260                 :             : int
     261                 :    41161937 : abstract_virtuals_error (abstract_class_use use, tree type,
     262                 :             :                          tsubst_flags_t complain /* = tf_warning_or_error */)
     263                 :             : {
     264                 :    41161937 :   return abstract_virtuals_error (NULL_TREE, type, use, complain);
     265                 :             : }
     266                 :             : 
     267                 :             : 
     268                 :             : /* Print an inform about the declaration of the incomplete type TYPE.  */
     269                 :             : 
     270                 :             : void
     271                 :         902 : cxx_incomplete_type_inform (const_tree type)
     272                 :             : {
     273                 :         902 :   if (!TYPE_MAIN_DECL (type))
     274                 :             :     return;
     275                 :             : 
     276                 :         815 :   location_t loc = DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type));
     277                 :         815 :   tree ptype = strip_top_quals (CONST_CAST_TREE (type));
     278                 :             : 
     279                 :         815 :   if (current_class_type
     280                 :         265 :       && TYPE_BEING_DEFINED (current_class_type)
     281                 :        1026 :       && same_type_p (ptype, current_class_type))
     282                 :          87 :     inform (loc, "definition of %q#T is not complete until "
     283                 :             :             "the closing brace", ptype);
     284                 :         728 :   else if (!TYPE_TEMPLATE_INFO (ptype))
     285                 :         582 :     inform (loc, "forward declaration of %q#T", ptype);
     286                 :             :   else
     287                 :         146 :     inform (loc, "declaration of %q#T", ptype);
     288                 :             : }
     289                 :             : 
     290                 :             : /* Print an error message for invalid use of an incomplete type.
     291                 :             :    VALUE is the expression that was used (or 0 if that isn't known)
     292                 :             :    and TYPE is the type that was invalid.  DIAG_KIND indicates the
     293                 :             :    type of diagnostic (see diagnostic.def).  */
     294                 :             : 
     295                 :             : bool
     296                 :         921 : cxx_incomplete_type_diagnostic (location_t loc, const_tree value,
     297                 :             :                                 const_tree type, diagnostic_t diag_kind)
     298                 :             : {
     299                 :         921 :   bool is_decl = false, complained = false;
     300                 :             : 
     301                 :             :   /* Avoid duplicate error message.  */
     302                 :         921 :   if (TREE_CODE (type) == ERROR_MARK)
     303                 :             :     return false;
     304                 :             : 
     305                 :         921 :   auto_diagnostic_group d;
     306                 :         921 :   if (value)
     307                 :             :     {
     308                 :         380 :       STRIP_ANY_LOCATION_WRAPPER (value);
     309                 :             : 
     310                 :         380 :       if (VAR_P (value)
     311                 :         335 :           || TREE_CODE (value) == PARM_DECL
     312                 :         290 :           || TREE_CODE (value) == FIELD_DECL)
     313                 :             :         {
     314                 :         117 :           complained = emit_diagnostic (diag_kind, DECL_SOURCE_LOCATION (value), 0,
     315                 :             :                                         "%qD has incomplete type", value);
     316                 :         117 :           is_decl = true;
     317                 :             :         }
     318                 :             :     }
     319                 :         921 :  retry:
     320                 :             :   /* We must print an error message.  Be clever about what it says.  */
     321                 :             : 
     322                 :         927 :   switch (TREE_CODE (type))
     323                 :             :     {
     324                 :         664 :     case RECORD_TYPE:
     325                 :         664 :     case UNION_TYPE:
     326                 :         664 :     case ENUMERAL_TYPE:
     327                 :         664 :       if (!is_decl)
     328                 :         568 :         complained = emit_diagnostic (diag_kind, loc, 0,
     329                 :             :                                       "invalid use of incomplete type %q#T",
     330                 :             :                                       type);
     331                 :         664 :       if (complained)
     332                 :         661 :         cxx_incomplete_type_inform (type);
     333                 :             :       break;
     334                 :             : 
     335                 :          10 :     case VOID_TYPE:
     336                 :          10 :       complained = emit_diagnostic (diag_kind, loc, 0,
     337                 :             :                        "invalid use of %qT", type);
     338                 :          10 :       break;
     339                 :             : 
     340                 :          60 :     case ARRAY_TYPE:
     341                 :          60 :       if (TYPE_DOMAIN (type))
     342                 :             :         {
     343                 :           6 :           type = TREE_TYPE (type);
     344                 :           6 :           goto retry;
     345                 :             :         }
     346                 :          54 :       complained = emit_diagnostic (diag_kind, loc, 0,
     347                 :             :                        "invalid use of array with unspecified bounds");
     348                 :          54 :       break;
     349                 :             : 
     350                 :          72 :     case OFFSET_TYPE:
     351                 :          72 :     bad_member:
     352                 :          72 :       {
     353                 :          72 :         tree member = TREE_OPERAND (value, 1);
     354                 :          72 :         if (is_overloaded_fn (member) && !flag_ms_extensions)
     355                 :             :           {
     356                 :          69 :             gcc_rich_location richloc (loc);
     357                 :             :             /* If "member" has no arguments (other than "this"), then
     358                 :             :                add a fix-it hint.  */
     359                 :          69 :             member = MAYBE_BASELINK_FUNCTIONS (member);
     360                 :          69 :             if (TREE_CODE (member) == FUNCTION_DECL
     361                 :          57 :                 && DECL_OBJECT_MEMBER_FUNCTION_P (member)
     362                 :         126 :                 && type_num_arguments (TREE_TYPE (member)) == 1)
     363                 :          54 :               richloc.add_fixit_insert_after ("()");
     364                 :          69 :             complained = emit_diagnostic (diag_kind, &richloc, 0,
     365                 :             :                              "invalid use of member function %qD "
     366                 :             :                              "(did you forget the %<()%> ?)", member);
     367                 :          69 :           }
     368                 :             :         else
     369                 :           3 :           complained = emit_diagnostic (diag_kind, loc, 0,
     370                 :             :                            "invalid use of member %qD "
     371                 :             :                            "(did you forget the %<&%> ?)", member);
     372                 :             :       }
     373                 :             :       break;
     374                 :             : 
     375                 :          28 :     case TEMPLATE_TYPE_PARM:
     376                 :          28 :       if (is_auto (type))
     377                 :             :         {
     378                 :          16 :           if (CLASS_PLACEHOLDER_TEMPLATE (type))
     379                 :           3 :             complained = emit_diagnostic (diag_kind, loc, 0,
     380                 :             :                              "invalid use of placeholder %qT", type);
     381                 :             :           else
     382                 :          13 :             complained = emit_diagnostic (diag_kind, loc, 0,
     383                 :             :                              "invalid use of %qT", type);
     384                 :             :         }
     385                 :             :       else
     386                 :          12 :         complained = emit_diagnostic (diag_kind, loc, 0,
     387                 :             :                          "invalid use of template type parameter %qT", type);
     388                 :             :       break;
     389                 :             : 
     390                 :           3 :     case BOUND_TEMPLATE_TEMPLATE_PARM:
     391                 :           3 :       complained = emit_diagnostic (diag_kind, loc, 0,
     392                 :             :                        "invalid use of template template parameter %qT",
     393                 :           3 :                        TYPE_NAME (type));
     394                 :           3 :       break;
     395                 :             : 
     396                 :           0 :     case TYPE_PACK_EXPANSION:
     397                 :           0 :       complained = emit_diagnostic (diag_kind, loc, 0,
     398                 :             :                        "invalid use of pack expansion %qT", type);
     399                 :           0 :       break;
     400                 :             : 
     401                 :          18 :     case TYPENAME_TYPE:
     402                 :          18 :     case DECLTYPE_TYPE:
     403                 :          18 :       complained = emit_diagnostic (diag_kind, loc, 0,
     404                 :             :                        "invalid use of dependent type %qT", type);
     405                 :          18 :       break;
     406                 :             : 
     407                 :         144 :     case LANG_TYPE:
     408                 :         144 :       if (type == init_list_type_node)
     409                 :             :         {
     410                 :           3 :           complained = emit_diagnostic (diag_kind, loc, 0,
     411                 :             :                            "invalid use of brace-enclosed initializer list");
     412                 :           3 :           break;
     413                 :             :         }
     414                 :         141 :       gcc_assert (type == unknown_type_node);
     415                 :         141 :       if (value && TREE_CODE (value) == COMPONENT_REF)
     416                 :          72 :         goto bad_member;
     417                 :          69 :       else if (value && TREE_CODE (value) == ADDR_EXPR)
     418                 :          27 :         complained = emit_diagnostic (diag_kind, loc, 0,
     419                 :             :                          "address of overloaded function with no contextual "
     420                 :             :                          "type information");
     421                 :          42 :       else if (value && TREE_CODE (value) == OVERLOAD)
     422                 :          42 :         complained = emit_diagnostic (diag_kind, loc, 0,
     423                 :             :                          "overloaded function with no contextual type information");
     424                 :             :       else
     425                 :           0 :         complained = emit_diagnostic (diag_kind, loc, 0,
     426                 :             :                          "insufficient contextual information to determine type");
     427                 :             :       break;
     428                 :             : 
     429                 :           0 :     default:
     430                 :           0 :       gcc_unreachable ();
     431                 :             :     }
     432                 :             : 
     433                 :         921 :   return complained;
     434                 :         921 : }
     435                 :             : 
     436                 :             : /* Print an error message for invalid use of an incomplete type.
     437                 :             :    VALUE is the expression that was used (or 0 if that isn't known)
     438                 :             :    and TYPE is the type that was invalid.  */
     439                 :             : 
     440                 :             : void
     441                 :          57 : cxx_incomplete_type_error (location_t loc, const_tree value, const_tree type)
     442                 :             : {
     443                 :          57 :   cxx_incomplete_type_diagnostic (loc, value, type, DK_ERROR);
     444                 :          57 : }
     445                 :             : 
     446                 :             : 
     447                 :             : /* We've just initialized subobject SUB; also insert a TARGET_EXPR with an
     448                 :             :    EH-only cleanup for SUB.  Because of EH region nesting issues, we need to
     449                 :             :    make the cleanup conditional on a flag that we will clear once the object is
     450                 :             :    fully initialized, so push a new flag onto FLAGS.  */
     451                 :             : 
     452                 :             : static void
     453                 :      315820 : maybe_push_temp_cleanup (tree sub, vec<tree,va_gc> **flags)
     454                 :             : {
     455                 :      315820 :   if (!flag_exceptions)
     456                 :             :     return;
     457                 :      628964 :   if (tree cleanup
     458                 :      314482 :       = cxx_maybe_build_cleanup (sub, tf_warning_or_error))
     459                 :             :     {
     460                 :         102 :       tree tx = get_target_expr (boolean_true_node);
     461                 :         102 :       tree flag = TARGET_EXPR_SLOT (tx);
     462                 :         102 :       CLEANUP_EH_ONLY (tx) = true;
     463                 :         102 :       TARGET_EXPR_CLEANUP (tx) = build3 (COND_EXPR, void_type_node,
     464                 :             :                                          flag, cleanup, void_node);
     465                 :         102 :       add_stmt (tx);
     466                 :         102 :       vec_safe_push (*flags, flag);
     467                 :             :     }
     468                 :             : }
     469                 :             : 
     470                 :             : /* F is something added to a cleanup flags vec by maybe_push_temp_cleanup or
     471                 :             :    build_vec_init.  Return the code to disable the cleanup it controls.  */
     472                 :             : 
     473                 :             : tree
     474                 :         335 : build_disable_temp_cleanup (tree f)
     475                 :             : {
     476                 :         335 :   tree d = f;
     477                 :         335 :   tree i = boolean_false_node;
     478                 :         335 :   if (TREE_CODE (f) == TREE_LIST)
     479                 :             :     {
     480                 :             :       /* To disable a build_vec_init cleanup, set
     481                 :             :          iterator = maxindex.  */
     482                 :         233 :       d = TREE_PURPOSE (f);
     483                 :         233 :       i = TREE_VALUE (f);
     484                 :         233 :       ggc_free (f);
     485                 :             :     }
     486                 :         335 :   return build2 (MODIFY_EXPR, TREE_TYPE (d), d, i);
     487                 :             : }
     488                 :             : 
     489                 :             : /* The recursive part of split_nonconstant_init.  DEST is an lvalue
     490                 :             :    expression to which INIT should be assigned.  INIT is a CONSTRUCTOR.
     491                 :             :    Return true if the whole of the value was initialized by the
     492                 :             :    generated statements.  */
     493                 :             : 
     494                 :             : static bool
     495                 :      244184 : split_nonconstant_init_1 (tree dest, tree init, bool last,
     496                 :             :                           vec<tree,va_gc> **flags)
     497                 :             : {
     498                 :      244184 :   unsigned HOST_WIDE_INT idx, tidx = HOST_WIDE_INT_M1U;
     499                 :      244184 :   tree field_index, value;
     500                 :      244184 :   tree type = TREE_TYPE (dest);
     501                 :      244184 :   tree inner_type = NULL;
     502                 :      244184 :   bool array_type_p = false;
     503                 :      244184 :   bool complete_p = true;
     504                 :      244184 :   HOST_WIDE_INT num_split_elts = 0;
     505                 :      244184 :   tree last_split_elt = NULL_TREE;
     506                 :             : 
     507                 :      244184 :   switch (TREE_CODE (type))
     508                 :             :     {
     509                 :        3296 :     case ARRAY_TYPE:
     510                 :        3296 :       inner_type = TREE_TYPE (type);
     511                 :        3296 :       array_type_p = true;
     512                 :        3296 :       if ((TREE_SIDE_EFFECTS (init)
     513                 :         498 :            && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
     514                 :        3606 :           || vla_type_p (type))
     515                 :             :         {
     516                 :         255 :           if (!TYPE_DOMAIN (type)
     517                 :           3 :               && TREE_CODE (init) == CONSTRUCTOR
     518                 :         258 :               && CONSTRUCTOR_NELTS (init))
     519                 :             :             {
     520                 :             :               /* Flexible array.  */
     521                 :           3 :               cp_complete_array_type (&type, init, /*default*/true);
     522                 :           3 :               dest = build1 (VIEW_CONVERT_EXPR, type, dest);
     523                 :             :             }
     524                 :             : 
     525                 :             :           /* For an array, we only need/want a single cleanup region rather
     526                 :             :              than one per element.  build_vec_init will handle it.  */
     527                 :         255 :           tree code = build_vec_init (dest, NULL_TREE, init, false, 1,
     528                 :             :                                       tf_warning_or_error, flags);
     529                 :         255 :           add_stmt (code);
     530                 :         255 :           return true;
     531                 :             :         }
     532                 :             :       /* FALLTHRU */
     533                 :             : 
     534                 :      242878 :     case RECORD_TYPE:
     535                 :      242878 :     case UNION_TYPE:
     536                 :      242878 :     case QUAL_UNION_TYPE:
     537                 :      795285 :       FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx,
     538                 :             :                                 field_index, value)
     539                 :             :         {
     540                 :             :           /* The current implementation of this algorithm assumes that
     541                 :             :              the field was set for all the elements. This is usually done
     542                 :             :              by process_init_constructor.  */
     543                 :      552407 :           gcc_assert (field_index);
     544                 :             : 
     545                 :      552407 :           if (!array_type_p)
     546                 :      546326 :             inner_type = TREE_TYPE (field_index);
     547                 :             : 
     548                 :      552407 :           tree sub;
     549                 :      552407 :           if (array_type_p)
     550                 :        6081 :             sub = build4 (ARRAY_REF, inner_type, dest, field_index,
     551                 :             :                           NULL_TREE, NULL_TREE);
     552                 :             :           else
     553                 :      546326 :             sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
     554                 :             :                           NULL_TREE);
     555                 :             : 
     556                 :     1655035 :           bool elt_last = last && idx == CONSTRUCTOR_NELTS (init) - 1;
     557                 :             : 
     558                 :             :           /* We need to see sub-array TARGET_EXPR before cp_fold_r so we can
     559                 :             :              handle cleanup flags properly.  */
     560                 :      552407 :           gcc_checking_assert (!target_expr_needs_replace (value));
     561                 :             : 
     562                 :      552407 :           if (TREE_CODE (value) == CONSTRUCTOR)
     563                 :             :             {
     564                 :         598 :               if (!split_nonconstant_init_1 (sub, value, elt_last, flags)
     565                 :             :                       /* For flexible array member with initializer we
     566                 :             :                          can't remove the initializer, because only the
     567                 :             :                          initializer determines how many elements the
     568                 :             :                          flexible array member has.  */
     569                 :         598 :                   || (!array_type_p
     570                 :         177 :                       && TREE_CODE (inner_type) == ARRAY_TYPE
     571                 :          91 :                       && TYPE_DOMAIN (inner_type) == NULL
     572                 :          49 :                       && TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
     573                 :          49 :                       && COMPLETE_TYPE_P (TREE_TYPE (value))
     574                 :          49 :                       && !integer_zerop (TYPE_SIZE (TREE_TYPE (value)))
     575                 :          49 :                       && elt_last
     576                 :          49 :                       && TYPE_HAS_TRIVIAL_DESTRUCTOR
     577                 :             :                                 (strip_array_types (inner_type))))
     578                 :             :                 complete_p = false;
     579                 :             :               else
     580                 :             :                 {
     581                 :             :                   /* Mark element for removal.  */
     582                 :         171 :                   last_split_elt = field_index;
     583                 :         171 :                   CONSTRUCTOR_ELT (init, idx)->index = NULL_TREE;
     584                 :         171 :                   if (idx < tidx)
     585                 :             :                     tidx = idx;
     586                 :         171 :                   num_split_elts++;
     587                 :             :                 }
     588                 :             :             }
     589                 :      551809 :           else if (tree vi = get_vec_init_expr (value))
     590                 :             :             {
     591                 :          35 :               add_stmt (expand_vec_init_expr (sub, vi, tf_warning_or_error,
     592                 :             :                                               flags));
     593                 :             : 
     594                 :             :               /* Mark element for removal.  */
     595                 :          35 :               last_split_elt = field_index;
     596                 :          35 :               CONSTRUCTOR_ELT (init, idx)->index = NULL_TREE;
     597                 :          35 :               if (idx < tidx)
     598                 :             :                 tidx = idx;
     599                 :          35 :               num_split_elts++;
     600                 :             :             }
     601                 :      551774 :           else if (!initializer_constant_valid_p (value, inner_type))
     602                 :             :             {
     603                 :      451836 :               tree code;
     604                 :             : 
     605                 :             :               /* Push cleanups for any preceding members with constant
     606                 :             :                  initialization.  */
     607                 :      451836 :               if (CLASS_TYPE_P (type))
     608                 :      893318 :                 for (tree prev = (last_split_elt ?
     609                 :      215181 :                                   DECL_CHAIN (last_split_elt)
     610                 :      231478 :                                   : TYPE_FIELDS (type));
     611                 :        1276 :                      ; prev = DECL_CHAIN (prev))
     612                 :             :                   {
     613                 :      447935 :                     prev = next_aggregate_field (prev);
     614                 :      447935 :                     if (prev == field_index)
     615                 :             :                       break;
     616                 :        1276 :                     tree ptype = TREE_TYPE (prev);
     617                 :        1276 :                     if (TYPE_P (ptype) && type_build_dtor_call (ptype))
     618                 :             :                       {
     619                 :          24 :                         tree pcref = build3 (COMPONENT_REF, ptype, dest, prev,
     620                 :             :                                              NULL_TREE);
     621                 :          24 :                         maybe_push_temp_cleanup (pcref, flags);
     622                 :             :                       }
     623                 :        1276 :                   }
     624                 :             : 
     625                 :             :               /* Mark element for removal.  */
     626                 :      451836 :               CONSTRUCTOR_ELT (init, idx)->index = NULL_TREE;
     627                 :      451836 :               if (idx < tidx)
     628                 :             :                 tidx = idx;
     629                 :             : 
     630                 :      451836 :               if (TREE_CODE (field_index) == RANGE_EXPR)
     631                 :             :                 {
     632                 :             :                   /* Use build_vec_init to initialize a range.  */
     633                 :           0 :                   tree low = TREE_OPERAND (field_index, 0);
     634                 :           0 :                   tree hi = TREE_OPERAND (field_index, 1);
     635                 :           0 :                   sub = build4 (ARRAY_REF, inner_type, dest, low,
     636                 :             :                                 NULL_TREE, NULL_TREE);
     637                 :           0 :                   sub = cp_build_addr_expr (sub, tf_warning_or_error);
     638                 :           0 :                   tree max = size_binop (MINUS_EXPR, hi, low);
     639                 :           0 :                   code = build_vec_init (sub, max, value, false, 0,
     640                 :             :                                          tf_warning_or_error);
     641                 :           0 :                   add_stmt (code);
     642                 :           0 :                   if (tree_fits_shwi_p (max))
     643                 :           0 :                     num_split_elts += tree_to_shwi (max);
     644                 :             :                 }
     645                 :             :               else
     646                 :             :                 {
     647                 :             :                   /* We may need to add a copy constructor call if
     648                 :             :                      the field has [[no_unique_address]].  */
     649                 :      451836 :                   if (unsafe_return_slot_p (sub))
     650                 :             :                     {
     651                 :             :                       /* But not if the initializer is an implicit ctor call
     652                 :             :                          we just built in digest_init.  */
     653                 :        1095 :                       if (TREE_CODE (value) == TARGET_EXPR
     654                 :        1095 :                           && TARGET_EXPR_LIST_INIT_P (value)
     655                 :        1824 :                           && make_safe_copy_elision (sub, value))
     656                 :         729 :                         goto build_init;
     657                 :             : 
     658                 :         366 :                       tree name = (DECL_FIELD_IS_BASE (field_index)
     659                 :         366 :                                    ? base_ctor_identifier
     660                 :         366 :                                    : complete_ctor_identifier);
     661                 :         366 :                       releasing_vec args = make_tree_vector_single (value);
     662                 :         366 :                       code = build_special_member_call
     663                 :         366 :                         (sub, name, &args, inner_type,
     664                 :             :                          LOOKUP_NORMAL, tf_warning_or_error);
     665                 :         366 :                     }
     666                 :             :                   else
     667                 :             :                     {
     668                 :      450741 :                     build_init:
     669                 :      451470 :                       code = cp_build_init_expr (sub, value);
     670                 :             :                     }
     671                 :      451836 :                   code = build_stmt (input_location, EXPR_STMT, code);
     672                 :      451836 :                   add_stmt (code);
     673                 :      451836 :                   if (!elt_last)
     674                 :      315796 :                     maybe_push_temp_cleanup (sub, flags);
     675                 :             :                 }
     676                 :             : 
     677                 :      451836 :               last_split_elt = field_index;
     678                 :      451836 :               num_split_elts++;
     679                 :             :             }
     680                 :             :         }
     681                 :      242878 :       if (num_split_elts == 1)
     682                 :      115736 :         CONSTRUCTOR_ELTS (init)->ordered_remove (tidx);
     683                 :      127142 :       else if (num_split_elts > 1)
     684                 :             :         {
     685                 :             :           /* Perform the delayed ordered removal of non-constant elements
     686                 :             :              we split out.  */
     687                 :      455425 :           for (idx = tidx; idx < CONSTRUCTOR_NELTS (init); ++idx)
     688                 :      336551 :             if (CONSTRUCTOR_ELT (init, idx)->index == NULL_TREE)
     689                 :             :               ;
     690                 :             :             else
     691                 :             :               {
     692                 :         245 :                 *CONSTRUCTOR_ELT (init, tidx) = *CONSTRUCTOR_ELT (init, idx);
     693                 :         245 :                 ++tidx;
     694                 :             :               }
     695                 :      118874 :           vec_safe_truncate (CONSTRUCTOR_ELTS (init), tidx);
     696                 :             :         }
     697                 :             :       break;
     698                 :             : 
     699                 :        1051 :     case VECTOR_TYPE:
     700                 :        1051 :       if (!initializer_constant_valid_p (init, type))
     701                 :             :         {
     702                 :        1046 :           tree code;
     703                 :        1046 :           tree cons = copy_node (init);
     704                 :        1046 :           CONSTRUCTOR_ELTS (init) = NULL;
     705                 :        1046 :           code = build2 (MODIFY_EXPR, type, dest, cons);
     706                 :        1046 :           code = build_stmt (input_location, EXPR_STMT, code);
     707                 :        1046 :           add_stmt (code);
     708                 :        1046 :           num_split_elts += CONSTRUCTOR_NELTS (init);
     709                 :             :         }
     710                 :             :       break;
     711                 :             : 
     712                 :           0 :     default:
     713                 :           0 :       gcc_unreachable ();
     714                 :             :     }
     715                 :             : 
     716                 :             :   /* The rest of the initializer is now a constant. */
     717                 :      243929 :   TREE_CONSTANT (init) = 1;
     718                 :      243929 :   TREE_SIDE_EFFECTS (init) = 0;
     719                 :             : 
     720                 :             :   /* We didn't split out anything.  */
     721                 :      243929 :   if (num_split_elts == 0)
     722                 :             :     return false;
     723                 :             : 
     724                 :      234610 :   return complete_p && complete_ctor_at_level_p (TREE_TYPE (init),
     725                 :             :                                                  num_split_elts, inner_type);
     726                 :             : }
     727                 :             : 
     728                 :             : /* A subroutine of store_init_value.  Splits non-constant static
     729                 :             :    initializer INIT into a constant part and generates code to
     730                 :             :    perform the non-constant part of the initialization to DEST.
     731                 :             :    Returns the code for the runtime init.  */
     732                 :             : 
     733                 :             : tree
     734                 :    12380534 : split_nonconstant_init (tree dest, tree init)
     735                 :             : {
     736                 :    12380534 :   tree code;
     737                 :             : 
     738                 :    12380534 :   if (TREE_CODE (init) == TARGET_EXPR)
     739                 :      215949 :     init = TARGET_EXPR_INITIAL (init);
     740                 :    12380534 :   if (TREE_CODE (init) == CONSTRUCTOR)
     741                 :             :     {
     742                 :             :       /* Subobject initializers are not full-expressions.  */
     743                 :      243586 :       auto fe = (make_temp_override
     744                 :      243586 :                  (current_stmt_tree ()->stmts_are_full_exprs_p, 0));
     745                 :             : 
     746                 :      243586 :       init = cp_fully_fold_init (init);
     747                 :      243586 :       code = push_stmt_list ();
     748                 :             : 
     749                 :             :       /* If the complete object is an array, build_vec_init's cleanup is
     750                 :             :          enough.  Otherwise, collect flags for disabling subobject
     751                 :             :          cleanups once the complete object is fully constructed.  */
     752                 :      243586 :       vec<tree, va_gc> *flags = nullptr;
     753                 :      243586 :       if (TREE_CODE (TREE_TYPE (dest)) != ARRAY_TYPE)
     754                 :      240490 :         flags = make_tree_vector ();
     755                 :             : 
     756                 :      243586 :       if (split_nonconstant_init_1 (dest, init, true, &flags))
     757                 :      135767 :         init = NULL_TREE;
     758                 :             : 
     759                 :      725218 :       for (tree f : flags)
     760                 :         306 :         finish_expr_stmt (build_disable_temp_cleanup (f));
     761                 :      243586 :       release_tree_vector (flags);
     762                 :             : 
     763                 :      243586 :       code = pop_stmt_list (code);
     764                 :      243586 :       if (VAR_P (dest) && !is_local_temp (dest))
     765                 :             :         {
     766                 :      242084 :           DECL_INITIAL (dest) = init;
     767                 :      242084 :           TREE_READONLY (dest) = 0;
     768                 :             :         }
     769                 :        1502 :       else if (init)
     770                 :             :         {
     771                 :         119 :           tree ie = cp_build_init_expr (dest, init);
     772                 :         119 :           code = add_stmt_to_compound (ie, code);
     773                 :             :         }
     774                 :      243586 :     }
     775                 :    12136948 :   else if (TREE_CODE (init) == STRING_CST
     776                 :    12136948 :            && array_of_runtime_bound_p (TREE_TYPE (dest)))
     777                 :          25 :     code = build_vec_init (dest, NULL_TREE, init, /*value-init*/false,
     778                 :             :                            /*from array*/1, tf_warning_or_error);
     779                 :             :   else
     780                 :    12136923 :     code = cp_build_init_expr (dest, init);
     781                 :             : 
     782                 :    12380534 :   return code;
     783                 :             : }
     784                 :             : 
     785                 :             : /* T is the initializer of a constexpr variable.  Set CONSTRUCTOR_MUTABLE_POISON
     786                 :             :    for any CONSTRUCTOR within T that contains (directly or indirectly) a mutable
     787                 :             :    member, thereby poisoning it so it can't be copied to another a constexpr
     788                 :             :    variable or read during constexpr evaluation.  */
     789                 :             : 
     790                 :             : static void
     791                 :    18695070 : poison_mutable_constructors (tree t)
     792                 :             : {
     793                 :    18695070 :   if (TREE_CODE (t) != CONSTRUCTOR)
     794                 :             :     return;
     795                 :             : 
     796                 :     1030527 :   if (cp_has_mutable_p (TREE_TYPE (t)))
     797                 :             :     {
     798                 :         159 :       CONSTRUCTOR_MUTABLE_POISON (t) = true;
     799                 :             : 
     800                 :         159 :       if (vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (t))
     801                 :         341 :         for (const constructor_elt &ce : *elts)
     802                 :         188 :           poison_mutable_constructors (ce.value);
     803                 :             :     }
     804                 :             : }
     805                 :             : 
     806                 :             : /* Perform appropriate conversions on the initial value of a variable,
     807                 :             :    store it in the declaration DECL,
     808                 :             :    and print any error messages that are appropriate.
     809                 :             :    If the init is invalid, store an ERROR_MARK.
     810                 :             : 
     811                 :             :    C++: Note that INIT might be a TREE_LIST, which would mean that it is
     812                 :             :    a base class initializer for some aggregate type, hopefully compatible
     813                 :             :    with DECL.  If INIT is a single element, and DECL is an aggregate
     814                 :             :    type, we silently convert INIT into a TREE_LIST, allowing a constructor
     815                 :             :    to be called.
     816                 :             : 
     817                 :             :    If INIT is a TREE_LIST and there is no constructor, turn INIT
     818                 :             :    into a CONSTRUCTOR and use standard initialization techniques.
     819                 :             :    Perhaps a warning should be generated?
     820                 :             : 
     821                 :             :    Returns code to be executed if initialization could not be performed
     822                 :             :    for static variable.  In that case, caller must emit the code.  */
     823                 :             : 
     824                 :             : tree
     825                 :    33611345 : store_init_value (tree decl, tree init, vec<tree, va_gc>** cleanups, int flags)
     826                 :             : {
     827                 :    33611345 :   tree value, type;
     828                 :             : 
     829                 :             :   /* If variable's type was invalidly declared, just ignore it.  */
     830                 :             : 
     831                 :    33611345 :   type = TREE_TYPE (decl);
     832                 :    33611345 :   if (TREE_CODE (type) == ERROR_MARK)
     833                 :             :     return NULL_TREE;
     834                 :             : 
     835                 :     2153627 :   if (MAYBE_CLASS_TYPE_P (type))
     836                 :             :     {
     837                 :     2122972 :       if (TREE_CODE (init) == TREE_LIST)
     838                 :             :         {
     839                 :           0 :           error ("constructor syntax used, but no constructor declared "
     840                 :             :                  "for type %qT", type);
     841                 :           0 :           init = build_constructor_from_list (init_list_type_node, nreverse (init));
     842                 :             :         }
     843                 :             :     }
     844                 :             : 
     845                 :             :   /* End of special C++ code.  */
     846                 :             : 
     847                 :    33611345 :   if (flags & LOOKUP_ALREADY_DIGESTED)
     848                 :             :     value = init;
     849                 :             :   else
     850                 :             :     {
     851                 :    32160423 :       if (TREE_STATIC (decl))
     852                 :    14976855 :         flags |= LOOKUP_ALLOW_FLEXARRAY_INIT;
     853                 :             :       /* Digest the specified initializer into an expression.  */
     854                 :    32160423 :       value = digest_init_flags (type, init, flags, tf_warning_or_error);
     855                 :             :     }
     856                 :             : 
     857                 :             :   /* Look for braced array initializers for character arrays and
     858                 :             :      recursively convert them into STRING_CSTs.  */
     859                 :    33611345 :   value = braced_lists_to_strings (type, value);
     860                 :             : 
     861                 :    33611345 :   current_ref_temp_count = 0;
     862                 :    33611345 :   value = extend_ref_init_temps (decl, value, cleanups);
     863                 :             : 
     864                 :             :   /* In C++11 constant expression is a semantic, not syntactic, property.
     865                 :             :      In C++98, make sure that what we thought was a constant expression at
     866                 :             :      template definition time is still constant and otherwise perform this
     867                 :             :      as optimization, e.g. to fold SIZEOF_EXPRs in the initializer.  */
     868                 :    33611345 :   if (decl_maybe_constant_var_p (decl) || TREE_STATIC (decl))
     869                 :             :     {
     870                 :    18697579 :       bool const_init;
     871                 :    18697579 :       tree oldval = value;
     872                 :    18697579 :       if (DECL_DECLARED_CONSTEXPR_P (decl)
     873                 :     5148808 :           || DECL_DECLARED_CONSTINIT_P (decl)
     874                 :    23846109 :           || (DECL_IN_AGGR_P (decl)
     875                 :     1099013 :               && DECL_INITIALIZED_IN_CLASS_P (decl)))
     876                 :             :         {
     877                 :    14647932 :           value = fold_non_dependent_expr (value, tf_warning_or_error,
     878                 :             :                                            /*manifestly_const_eval=*/true,
     879                 :             :                                            decl);
     880                 :    14645235 :           if (value == error_mark_node)
     881                 :             :             ;
     882                 :             :           /* Diagnose a non-constant initializer for constexpr variable or
     883                 :             :              non-inline in-class-initialized static data member.  */
     884                 :    14645036 :           else if (!is_constant_expression (value))
     885                 :             :             {
     886                 :             :               /* Maybe we want to give this message for constexpr variables as
     887                 :             :                  well, but that will mean a lot of testsuite adjustment.  */
     888                 :         161 :               if (DECL_DECLARED_CONSTINIT_P (decl))
     889                 :          60 :               error_at (location_of (decl),
     890                 :             :                         "%<constinit%> variable %qD does not have a "
     891                 :             :                         "constant initializer", decl);
     892                 :         161 :               require_constant_expression (value);
     893                 :         161 :               value = error_mark_node;
     894                 :             :             }
     895                 :             :           else
     896                 :             :             {
     897                 :    14644875 :               value = maybe_constant_init (value, decl, true);
     898                 :             : 
     899                 :             :               /* In a template we might not have done the necessary
     900                 :             :                  transformations to make value actually constant,
     901                 :             :                  e.g. extend_ref_init_temps.  */
     902                 :    14644875 :               if (!processing_template_decl
     903                 :    14644875 :                   && !TREE_CONSTANT (value))
     904                 :             :                 {
     905                 :        1352 :                   if (DECL_DECLARED_CONSTINIT_P (decl))
     906                 :          36 :                   error_at (location_of (decl),
     907                 :             :                             "%<constinit%> variable %qD does not have a "
     908                 :             :                             "constant initializer", decl);
     909                 :        1352 :                   value = cxx_constant_init (value, decl);
     910                 :             :                 }
     911                 :             :             }
     912                 :             :         }
     913                 :             :       else
     914                 :     4049647 :         value = fold_non_dependent_init (value, tf_warning_or_error,
     915                 :             :                                          /*manifestly_const_eval=*/true, decl);
     916                 :    18694882 :       poison_mutable_constructors (value);
     917                 :    18694882 :       const_init = (reduced_constant_expression_p (value)
     918                 :    18694882 :                     || error_operand_p (value));
     919                 :    18694882 :       DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = const_init;
     920                 :             :       /* FIXME setting TREE_CONSTANT on refs breaks the back end.  */
     921                 :    18694882 :       if (!TYPE_REF_P (type))
     922                 :    20918721 :         TREE_CONSTANT (decl) = const_init && decl_maybe_constant_var_p (decl);
     923                 :    18694882 :       if (!const_init)
     924                 :    16848289 :         value = oldval;
     925                 :             :     }
     926                 :             :   /* Don't fold initializers of automatic variables in constexpr functions,
     927                 :             :      that might fold away something that needs to be diagnosed at constexpr
     928                 :             :      evaluation time.  */
     929                 :    33608648 :   if (!current_function_decl
     930                 :    18566216 :       || !DECL_DECLARED_CONSTEXPR_P (current_function_decl)
     931                 :    36572517 :       || TREE_STATIC (decl))
     932                 :    30644845 :     value = cp_fully_fold_init (value);
     933                 :             : 
     934                 :             :   /* Handle aggregate NSDMI in non-constant initializers, too.  */
     935                 :    33608648 :   value = replace_placeholders (value, decl);
     936                 :             : 
     937                 :             :   /* A COMPOUND_LITERAL_P CONSTRUCTOR is the syntactic form; by the time we get
     938                 :             :      here it should have been digested into an actual value for the type.  */
     939                 :    33608648 :   gcc_checking_assert (TREE_CODE (value) != CONSTRUCTOR
     940                 :             :                        || processing_template_decl
     941                 :             :                        || VECTOR_TYPE_P (type)
     942                 :             :                        || !TREE_HAS_CONSTRUCTOR (value));
     943                 :             : 
     944                 :             :   /* If the initializer is not a constant, fill in DECL_INITIAL with
     945                 :             :      the bits that are constant, and then return an expression that
     946                 :             :      will perform the dynamic initialization.  */
     947                 :    33608648 :   if (value != error_mark_node
     948                 :    33604378 :       && !processing_template_decl
     949                 :    65461495 :       && (TREE_SIDE_EFFECTS (value)
     950                 :    26463052 :           || vla_type_p (type)
     951                 :    26462960 :           || ! reduced_constant_expression_p (value)))
     952                 :    12371648 :     return split_nonconstant_init (decl, value);
     953                 :             : 
     954                 :             :   /* DECL may change value; purge caches.  */
     955                 :    21237000 :   clear_cv_and_fold_caches ();
     956                 :             : 
     957                 :             :   /* If the value is a constant, just put it in DECL_INITIAL.  If DECL
     958                 :             :      is an automatic variable, the middle end will turn this into a
     959                 :             :      dynamic initialization later.  */
     960                 :    21237000 :   DECL_INITIAL (decl) = value;
     961                 :    21237000 :   return NULL_TREE;
     962                 :             : }
     963                 :             : 
     964                 :             : 
     965                 :             : /* Give diagnostic about narrowing conversions within { }, or as part of
     966                 :             :    a converted constant expression.  If CONST_ONLY, only check
     967                 :             :    constants.  */
     968                 :             : 
     969                 :             : bool
     970                 :    14839571 : check_narrowing (tree type, tree init, tsubst_flags_t complain,
     971                 :             :                  bool const_only/*= false*/)
     972                 :             : {
     973                 :    14839571 :   tree ftype = unlowered_expr_type (init);
     974                 :    14839571 :   bool ok = true;
     975                 :    14839571 :   REAL_VALUE_TYPE d;
     976                 :             : 
     977                 :    14793378 :   if (((!warn_narrowing || !(complain & tf_warning))
     978                 :     2414951 :        && cxx_dialect == cxx98)
     979                 :    14794267 :       || !ARITHMETIC_TYPE_P (type)
     980                 :             :       /* Don't emit bogus warnings with e.g. value-dependent trees.  */
     981                 :    29516250 :       || instantiation_dependent_expression_p (init))
     982                 :      234844 :     return ok;
     983                 :             : 
     984                 :          14 :   if (BRACE_ENCLOSED_INITIALIZER_P (init)
     985                 :    14604727 :       && TREE_CODE (type) == COMPLEX_TYPE)
     986                 :             :     {
     987                 :           0 :       tree elttype = TREE_TYPE (type);
     988                 :           0 :       if (CONSTRUCTOR_NELTS (init) > 0)
     989                 :           0 :         ok &= check_narrowing (elttype, CONSTRUCTOR_ELT (init, 0)->value,
     990                 :             :                                complain);
     991                 :           0 :       if (CONSTRUCTOR_NELTS (init) > 1)
     992                 :           0 :         ok &= check_narrowing (elttype, CONSTRUCTOR_ELT (init, 1)->value,
     993                 :             :                                complain);
     994                 :           0 :       return ok;
     995                 :             :     }
     996                 :             : 
     997                 :             :   /* Even non-dependent expressions can still have template
     998                 :             :      codes like CAST_EXPR, so use *_non_dependent_expr to cope.  */
     999                 :    14604727 :   init = fold_non_dependent_expr (init, complain, /*manifest*/true);
    1000                 :    14604727 :   if (init == error_mark_node)
    1001                 :             :     return ok;
    1002                 :             : 
    1003                 :             :   /* If we were asked to only check constants, return early.  */
    1004                 :    14604724 :   if (const_only && !TREE_CONSTANT (init))
    1005                 :             :     return ok;
    1006                 :             : 
    1007                 :    14603329 :   if (CP_INTEGRAL_TYPE_P (type)
    1008                 :    14594077 :       && SCALAR_FLOAT_TYPE_P (ftype))
    1009                 :             :     ok = false;
    1010                 :    14603107 :   else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
    1011                 :    14548844 :            && CP_INTEGRAL_TYPE_P (type))
    1012                 :             :     {
    1013                 :    14546681 :       if (TREE_CODE (ftype) == ENUMERAL_TYPE)
    1014                 :             :         /* Check for narrowing based on the values of the enumeration. */
    1015                 :      875636 :         ftype = ENUM_UNDERLYING_TYPE (ftype);
    1016                 :             :       /* Undo convert_bitfield_to_declared_type (STRIP_NOPS isn't enough).  */
    1017                 :    14546681 :       tree op = init;
    1018                 :    14546986 :       while (CONVERT_EXPR_P (op))
    1019                 :         305 :         op = TREE_OPERAND (op, 0);
    1020                 :             :       /* Core 2627 says that we shouldn't warn when "the source is a bit-field
    1021                 :             :          whose width w is less than that of its type (or, for an enumeration
    1022                 :             :          type, its underlying type) and the target type can represent all the
    1023                 :             :          values of a hypothetical extended integer type with width w and with
    1024                 :             :          the same signedness as the original type".  */
    1025                 :    14546681 :       if (is_bitfield_expr_with_lowered_type (op)
    1026                 :    14546681 :           && TYPE_PRECISION (TREE_TYPE (op)) < TYPE_PRECISION (ftype))
    1027                 :          70 :         ftype = TREE_TYPE (op);
    1028                 :    14546681 :       if ((tree_int_cst_lt (TYPE_MAX_VALUE (type),
    1029                 :    14546681 :                             TYPE_MAX_VALUE (ftype))
    1030                 :    14285477 :            || tree_int_cst_lt (TYPE_MIN_VALUE (ftype),
    1031                 :    14285477 :                                TYPE_MIN_VALUE (type)))
    1032                 :    27011732 :           && (TREE_CODE (init) != INTEGER_CST
    1033                 :    12726137 :               || !int_fits_type_p (init, type)))
    1034                 :             :         ok = false;
    1035                 :             :     }
    1036                 :             :   /* [dcl.init.list]#7.2: "from long double to double or float, or from
    1037                 :             :       double to float".  */
    1038                 :       56426 :   else if (SCALAR_FLOAT_TYPE_P (ftype)
    1039                 :        7089 :            && SCALAR_FLOAT_TYPE_P (type))
    1040                 :             :     {
    1041                 :       14196 :       if ((extended_float_type_p (ftype) || extended_float_type_p (type))
    1042                 :        7077 :           ? /* "from a floating-point type T to another floating-point type
    1043                 :             :                whose floating-point conversion rank is neither greater than
    1044                 :             :                nor equal to that of T".
    1045                 :             :                So, it is ok if
    1046                 :             :                cp_compare_floating_point_conversion_ranks (ftype, type)
    1047                 :             :                returns -2 (type has greater conversion rank than ftype)
    1048                 :             :                or [-1..1] (type has equal conversion rank as ftype, possibly
    1049                 :             :                different subrank.  Only do this if at least one of the
    1050                 :             :                types is extended floating-point type, otherwise keep doing
    1051                 :             :                what we did before (for the sake of non-standard
    1052                 :             :                backend types).  */
    1053                 :         204 :             cp_compare_floating_point_conversion_ranks (ftype, type) >= 2
    1054                 :        6873 :           : ((same_type_p (ftype, long_double_type_node)
    1055                 :         144 :               && (same_type_p (type, double_type_node)
    1056                 :         133 :                   || same_type_p (type, float_type_node)))
    1057                 :        6860 :              || (same_type_p (ftype, double_type_node)
    1058                 :        6185 :                  && same_type_p (type, float_type_node))
    1059                 :        8750 :              || (TYPE_PRECISION (type) < TYPE_PRECISION (ftype))))
    1060                 :             :         {
    1061                 :        5052 :           if (TREE_CODE (init) == REAL_CST)
    1062                 :             :             {
    1063                 :             :               /* Issue 703: Loss of precision is OK as long as the value is
    1064                 :             :                  within the representable range of the new type.  */
    1065                 :        4976 :               REAL_VALUE_TYPE r;
    1066                 :        4976 :               d = TREE_REAL_CST (init);
    1067                 :        4976 :               real_convert (&r, TYPE_MODE (type), &d);
    1068                 :        4976 :               if (real_isinf (&r))
    1069                 :           0 :                 ok = false;
    1070                 :             :             }
    1071                 :             :           else
    1072                 :             :             ok = false;
    1073                 :             :         }
    1074                 :             :     }
    1075                 :       49349 :   else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
    1076                 :        2163 :            && SCALAR_FLOAT_TYPE_P (type))
    1077                 :             :     {
    1078                 :        2128 :       ok = false;
    1079                 :        2128 :       if (TREE_CODE (init) == INTEGER_CST)
    1080                 :             :         {
    1081                 :        2088 :           d = real_value_from_int_cst (0, init);
    1082                 :        2088 :           if (exact_real_truncate (TYPE_MODE (type), &d))
    1083                 :             :             ok = true;
    1084                 :             :         }
    1085                 :             :     }
    1086                 :       47221 :   else if (TREE_CODE (type) == BOOLEAN_TYPE
    1087                 :       47221 :            && (TYPE_PTR_P (ftype) || TYPE_PTRMEM_P (ftype)))
    1088                 :             :     /* C++20 P1957R2: converting from a pointer type or a pointer-to-member
    1089                 :             :        type to bool should be considered narrowing.  This is a DR so is not
    1090                 :             :        limited to C++20 only.  */
    1091                 :             :     ok = false;
    1092                 :             : 
    1093                 :        5858 :   bool almost_ok = ok;
    1094                 :        5858 :   if (!ok && !CONSTANT_CLASS_P (init) && (complain & tf_warning_or_error))
    1095                 :             :     {
    1096                 :         161 :       tree folded = cp_fully_fold (init);
    1097                 :         161 :       if (TREE_CONSTANT (folded) && check_narrowing (type, folded, tf_none))
    1098                 :             :         almost_ok = true;
    1099                 :             :     }
    1100                 :             : 
    1101                 :         882 :   if (!ok)
    1102                 :             :     {
    1103                 :         882 :       location_t loc = cp_expr_loc_or_input_loc (init);
    1104                 :         882 :       if (cxx_dialect == cxx98)
    1105                 :             :         {
    1106                 :           1 :           if (complain & tf_warning)
    1107                 :           1 :             warning_at (loc, OPT_Wnarrowing, "narrowing conversion of %qE "
    1108                 :             :                         "from %qH to %qI is ill-formed in C++11",
    1109                 :             :                         init, ftype, type);
    1110                 :             :           ok = true;
    1111                 :             :         }
    1112                 :         881 :       else if (!CONSTANT_CLASS_P (init))
    1113                 :             :         {
    1114                 :         292 :           if (complain & tf_warning_or_error)
    1115                 :             :             {
    1116                 :         161 :               auto_diagnostic_group d;
    1117                 :           4 :               if ((!almost_ok || pedantic)
    1118                 :         304 :                   && pedwarn (loc, OPT_Wnarrowing,
    1119                 :             :                               "narrowing conversion of %qE from %qH to %qI",
    1120                 :             :                               init, ftype, type)
    1121                 :         306 :                   && almost_ok)
    1122                 :           2 :                 inform (loc, " the expression has a constant value but is not "
    1123                 :             :                         "a C++ constant-expression");
    1124                 :         161 :               ok = true;
    1125                 :         161 :             }
    1126                 :             :         }
    1127                 :         589 :       else if (complain & tf_error)
    1128                 :             :         {
    1129                 :         578 :           int savederrorcount = errorcount;
    1130                 :         578 :           permerror_opt (loc, OPT_Wnarrowing,
    1131                 :             :                          "narrowing conversion of %qE from %qH to %qI",
    1132                 :             :                          init, ftype, type);
    1133                 :         578 :           if (errorcount == savederrorcount)
    1134                 :    14838966 :             ok = true;
    1135                 :             :         }
    1136                 :             :     }
    1137                 :             : 
    1138                 :             :   return ok;
    1139                 :             : }
    1140                 :             : 
    1141                 :             : /* True iff TYPE is a C++20 "ordinary" character type.  */
    1142                 :             : 
    1143                 :             : bool
    1144                 :       38861 : ordinary_char_type_p (tree type)
    1145                 :             : {
    1146                 :       38861 :   type = TYPE_MAIN_VARIANT (type);
    1147                 :       38861 :   return (type == char_type_node
    1148                 :       19489 :           || type == signed_char_type_node
    1149                 :       58328 :           || type == unsigned_char_type_node);
    1150                 :             : }
    1151                 :             : 
    1152                 :             : /* True iff the string literal INIT has a type suitable for initializing array
    1153                 :             :    TYPE.  */
    1154                 :             : 
    1155                 :             : bool
    1156                 :      526789 : array_string_literal_compatible_p (tree type, tree init)
    1157                 :             : {
    1158                 :      526789 :   tree to_char_type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
    1159                 :      526789 :   tree from_char_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init)));
    1160                 :             : 
    1161                 :      526789 :   if (to_char_type == from_char_type)
    1162                 :             :     return true;
    1163                 :             :   /* The array element type does not match the initializing string
    1164                 :             :      literal element type; this is only allowed when both types are
    1165                 :             :      ordinary character type.  There are no string literals of
    1166                 :             :      signed or unsigned char type in the language, but we can get
    1167                 :             :      them internally from converting braced-init-lists to
    1168                 :             :      STRING_CST.  */
    1169                 :       19475 :   if (ordinary_char_type_p (to_char_type)
    1170                 :       19475 :       && ordinary_char_type_p (from_char_type))
    1171                 :             :     return true;
    1172                 :             : 
    1173                 :             :   /* P2513 (C++20/C++23): "an array of char or unsigned char may
    1174                 :             :      be initialized by a UTF-8 string literal, or by such a string
    1175                 :             :      literal enclosed in braces."  */
    1176                 :         137 :   if (from_char_type == char8_type_node
    1177                 :          36 :       && (to_char_type == char_type_node
    1178                 :          23 :           || to_char_type == unsigned_char_type_node))
    1179                 :             :     return true;
    1180                 :             : 
    1181                 :             :   return false;
    1182                 :             : }
    1183                 :             : 
    1184                 :             : /* Process the initializer INIT for a variable of type TYPE, emitting
    1185                 :             :    diagnostics for invalid initializers and converting the initializer as
    1186                 :             :    appropriate.
    1187                 :             : 
    1188                 :             :    For aggregate types, it assumes that reshape_init has already run, thus the
    1189                 :             :    initializer will have the right shape (brace elision has been undone).
    1190                 :             : 
    1191                 :             :    NESTED is non-zero iff we are being called for an element of a CONSTRUCTOR,
    1192                 :             :    2 iff the element of a CONSTRUCTOR is inside another CONSTRUCTOR.  */
    1193                 :             : 
    1194                 :             : static tree
    1195                 :    53726643 : digest_init_r (tree type, tree init, int nested, int flags,
    1196                 :             :                tsubst_flags_t complain)
    1197                 :             : {
    1198                 :    53726643 :   enum tree_code code = TREE_CODE (type);
    1199                 :             : 
    1200                 :    53726643 :   if (error_operand_p (init))
    1201                 :        1781 :     return error_mark_node;
    1202                 :             : 
    1203                 :    53724862 :   gcc_assert (init);
    1204                 :             : 
    1205                 :             :   /* We must strip the outermost array type when completing the type,
    1206                 :             :      because the its bounds might be incomplete at the moment.  */
    1207                 :    54551569 :   if (!complete_type_or_maybe_complain (code == ARRAY_TYPE
    1208                 :      826707 :                                         ? TREE_TYPE (type) : type, NULL_TREE,
    1209                 :             :                                         complain))
    1210                 :          27 :     return error_mark_node;
    1211                 :             : 
    1212                 :    53724835 :   location_t loc = cp_expr_loc_or_input_loc (init);
    1213                 :             : 
    1214                 :    53724835 :   tree stripped_init = init;
    1215                 :             : 
    1216                 :     7745051 :   if (BRACE_ENCLOSED_INITIALIZER_P (init)
    1217                 :    61466513 :       && CONSTRUCTOR_IS_PAREN_INIT (init))
    1218                 :        1279 :     flags |= LOOKUP_AGGREGATE_PAREN_INIT;
    1219                 :             : 
    1220                 :             :   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
    1221                 :             :      (g++.old-deja/g++.law/casts2.C).  */
    1222                 :    53724835 :   if (TREE_CODE (init) == NON_LVALUE_EXPR)
    1223                 :    11916982 :     stripped_init = TREE_OPERAND (init, 0);
    1224                 :             : 
    1225                 :    53724835 :   stripped_init = tree_strip_any_location_wrapper (stripped_init);
    1226                 :             : 
    1227                 :             :   /* Initialization of an array of chars from a string constant. The initializer
    1228                 :             :      can be optionally enclosed in braces, but reshape_init has already removed
    1229                 :             :      them if they were present.  */
    1230                 :    53724835 :   if (code == ARRAY_TYPE)
    1231                 :             :     {
    1232                 :      952832 :       if (nested && !TYPE_DOMAIN (type))
    1233                 :             :         /* C++ flexible array members have a null domain.  */
    1234                 :             :         {
    1235                 :         458 :           if (flags & LOOKUP_ALLOW_FLEXARRAY_INIT)
    1236                 :         407 :             pedwarn (loc, OPT_Wpedantic,
    1237                 :             :                      "initialization of a flexible array member");
    1238                 :             :           else
    1239                 :             :             {
    1240                 :          51 :               if (complain & tf_error)
    1241                 :          51 :                 error_at (loc, "non-static initialization of"
    1242                 :             :                                " a flexible array member");
    1243                 :          51 :               return error_mark_node;
    1244                 :             :             }
    1245                 :             :         }
    1246                 :             : 
    1247                 :      826656 :       tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
    1248                 :      826656 :       if (char_type_p (typ1)
    1249                 :      826656 :           && TREE_CODE (stripped_init) == STRING_CST)
    1250                 :             :         {
    1251                 :      526744 :           if (!array_string_literal_compatible_p (type, init))
    1252                 :             :             {
    1253                 :         111 :               if (complain & tf_error)
    1254                 :         111 :                 error_at (loc, "cannot initialize array of %qT from "
    1255                 :             :                           "a string literal with type array of %qT",
    1256                 :             :                           typ1,
    1257                 :         111 :                           TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init))));
    1258                 :         111 :               return error_mark_node;
    1259                 :             :             }
    1260                 :             : 
    1261                 :      527006 :           if (nested == 2 && !TYPE_DOMAIN (type))
    1262                 :             :             {
    1263                 :          24 :               if (complain & tf_error)
    1264                 :          24 :                 error_at (loc, "initialization of flexible array member "
    1265                 :             :                                "in a nested context");
    1266                 :          24 :               return error_mark_node;
    1267                 :             :             }
    1268                 :             : 
    1269                 :      526609 :           if (type != TREE_TYPE (init)
    1270                 :      526609 :               && !variably_modified_type_p (type, NULL_TREE))
    1271                 :             :             {
    1272                 :       21492 :               init = copy_node (init);
    1273                 :       21492 :               TREE_TYPE (init) = type;
    1274                 :             :               /* If we have a location wrapper, then also copy the wrapped
    1275                 :             :                  node, and update the copy's type.  */
    1276                 :       21492 :               if (location_wrapper_p (init))
    1277                 :             :                 {
    1278                 :       20633 :                   stripped_init = copy_node (stripped_init);
    1279                 :       20633 :                   TREE_OPERAND (init, 0) = stripped_init;
    1280                 :       20633 :                   TREE_TYPE (stripped_init) = type;
    1281                 :             :                 }
    1282                 :             :             }
    1283                 :      526609 :           if (TYPE_DOMAIN (type) && TREE_CONSTANT (TYPE_SIZE (type)))
    1284                 :             :             {
    1285                 :             :               /* Not a flexible array member.  */
    1286                 :      526539 :               int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
    1287                 :      526539 :               size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
    1288                 :             :               /* In C it is ok to subtract 1 from the length of the string
    1289                 :             :                  because it's ok to ignore the terminating null char that is
    1290                 :             :                  counted in the length of the constant, but in C++ this would
    1291                 :             :                  be invalid.  */
    1292                 :      526539 :               if (size < TREE_STRING_LENGTH (stripped_init))
    1293                 :             :                 {
    1294                 :         159 :                   permerror (loc, "initializer-string for %qT is too long",
    1295                 :             :                              type);
    1296                 :             : 
    1297                 :         159 :                   init = build_string (size,
    1298                 :         159 :                                        TREE_STRING_POINTER (stripped_init));
    1299                 :         159 :                   TREE_TYPE (init) = type;
    1300                 :             :                 }
    1301                 :             :             }
    1302                 :      526609 :           return init;
    1303                 :             :         }
    1304                 :             :     }
    1305                 :             : 
    1306                 :             :   /* Handle scalar types (including conversions) and references.  */
    1307                 :        1033 :   if ((code != COMPLEX_TYPE || BRACE_ENCLOSED_INITIALIZER_P (stripped_init))
    1308                 :    53198082 :       && (SCALAR_TYPE_P (type) || code == REFERENCE_TYPE))
    1309                 :             :     {
    1310                 :             :       /* Narrowing is OK when initializing an aggregate from
    1311                 :             :          a parenthesized list.  */
    1312                 :    45597849 :       if (nested && !(flags & LOOKUP_AGGREGATE_PAREN_INIT))
    1313                 :    14499541 :         flags |= LOOKUP_NO_NARROWING;
    1314                 :    45597849 :       if (TREE_CODE (init) == RAW_DATA_CST && !TYPE_UNSIGNED (type))
    1315                 :             :         {
    1316                 :           9 :           tree ret = init;
    1317                 :           9 :           if ((flags & LOOKUP_NO_NARROWING) || warn_conversion)
    1318                 :        2403 :             for (unsigned int i = 0;
    1319                 :        2412 :                  i < (unsigned) RAW_DATA_LENGTH (init); ++i)
    1320                 :        2403 :               if (RAW_DATA_SCHAR_ELT (init, i) < 0)
    1321                 :             :                 {
    1322                 :          60 :                   if ((flags & LOOKUP_NO_NARROWING))
    1323                 :             :                     {
    1324                 :          60 :                       tree elt
    1325                 :         120 :                         = build_int_cst (integer_type_node,
    1326                 :          60 :                                          RAW_DATA_UCHAR_ELT (init, i));
    1327                 :          60 :                       if (!check_narrowing (type, elt, complain, false))
    1328                 :             :                         {
    1329                 :          30 :                           if (!(complain & tf_warning_or_error))
    1330                 :           0 :                             ret = error_mark_node;
    1331                 :          30 :                           continue;
    1332                 :             :                         }
    1333                 :             :                     }
    1334                 :          30 :                   if (warn_conversion)
    1335                 :          60 :                     warning (OPT_Wconversion,
    1336                 :             :                              "conversion from %qT to %qT changes value from "
    1337                 :             :                              "%qd to %qd",
    1338                 :             :                              integer_type_node, type,
    1339                 :          30 :                              RAW_DATA_UCHAR_ELT (init, i),
    1340                 :          30 :                              RAW_DATA_SCHAR_ELT (init, i));
    1341                 :             :                 }
    1342                 :           9 :           return ret;
    1343                 :             :         }
    1344                 :    45597840 :       init = convert_for_initialization (0, type, init, flags,
    1345                 :             :                                          ICR_INIT, NULL_TREE, 0,
    1346                 :             :                                          complain);
    1347                 :             : 
    1348                 :    45597840 :       return init;
    1349                 :             :     }
    1350                 :             : 
    1351                 :             :   /* Come here only for aggregates: records, arrays, unions, complex numbers
    1352                 :             :      and vectors.  */
    1353                 :     7600191 :   gcc_assert (code == ARRAY_TYPE
    1354                 :             :               || VECTOR_TYPE_P (type)
    1355                 :             :               || code == RECORD_TYPE
    1356                 :             :               || code == UNION_TYPE
    1357                 :             :               || code == OPAQUE_TYPE
    1358                 :             :               || code == COMPLEX_TYPE);
    1359                 :             : 
    1360                 :             :   /* "If T is a class type and the initializer list has a single
    1361                 :             :      element of type cv U, where U is T or a class derived from T,
    1362                 :             :      the object is initialized from that element."  */
    1363                 :     7600191 :   if (cxx_dialect >= cxx11
    1364                 :     7573583 :       && BRACE_ENCLOSED_INITIALIZER_P (stripped_init)
    1365                 :     7365327 :       && !CONSTRUCTOR_IS_DESIGNATED_INIT (stripped_init)
    1366                 :     7121092 :       && CONSTRUCTOR_NELTS (stripped_init) == 1
    1367                 :     7968030 :       && ((CLASS_TYPE_P (type) && !CLASSTYPE_NON_AGGREGATE (type))
    1368                 :       37294 :           || VECTOR_TYPE_P (type)))
    1369                 :             :     {
    1370                 :      330831 :       tree elt = CONSTRUCTOR_ELT (stripped_init, 0)->value;
    1371                 :      330831 :       if (reference_related_p (type, TREE_TYPE (elt)))
    1372                 :             :         {
    1373                 :             :           /* In C++17, aggregates can have bases, thus participate in
    1374                 :             :              aggregate initialization.  In the following case:
    1375                 :             : 
    1376                 :             :                struct B { int c; };
    1377                 :             :                struct D : B { };
    1378                 :             :                D d{{D{{42}}}};
    1379                 :             : 
    1380                 :             :             there's an extra set of braces, so the D temporary initializes
    1381                 :             :             the first element of d, which is the B base subobject.  The base
    1382                 :             :             of type B is copy-initialized from the D temporary, causing
    1383                 :             :             object slicing.  */
    1384                 :          30 :           tree field = next_aggregate_field (TYPE_FIELDS (type));
    1385                 :          60 :           if (field && DECL_FIELD_IS_BASE (field))
    1386                 :             :             {
    1387                 :          30 :               if (warning_at (loc, 0, "initializing a base class of type %qT "
    1388                 :          30 :                               "results in object slicing", TREE_TYPE (field)))
    1389                 :          30 :                 inform (loc, "remove %<{ }%> around initializer");
    1390                 :             :             }
    1391                 :           0 :           else if (flag_checking)
    1392                 :             :             /* We should have fixed this in reshape_init.  */
    1393                 :           0 :             gcc_unreachable ();
    1394                 :             :         }
    1395                 :             :     }
    1396                 :             : 
    1397                 :     7600191 :   if (SIMPLE_TARGET_EXPR_P (stripped_init))
    1398                 :        8488 :     stripped_init = TARGET_EXPR_INITIAL (stripped_init);
    1399                 :             : 
    1400                 :     7384838 :   if (BRACE_ENCLOSED_INITIALIZER_P (stripped_init)
    1401                 :    14980707 :       && !TYPE_NON_AGGREGATE_CLASS (type))
    1402                 :     7096354 :     return process_init_constructor (type, stripped_init, nested, flags,
    1403                 :     7096354 :                                      complain);
    1404                 :             :   else
    1405                 :             :     {
    1406                 :      503837 :       if (COMPOUND_LITERAL_P (stripped_init) && code == ARRAY_TYPE)
    1407                 :             :         {
    1408                 :           0 :           if (complain & tf_error)
    1409                 :           0 :             error_at (loc, "cannot initialize aggregate of type %qT with "
    1410                 :             :                       "a compound literal", type);
    1411                 :             : 
    1412                 :           0 :           return error_mark_node;
    1413                 :             :         }
    1414                 :             : 
    1415                 :      503837 :       if (code == ARRAY_TYPE
    1416                 :      503837 :           && !BRACE_ENCLOSED_INITIALIZER_P (stripped_init))
    1417                 :             :         {
    1418                 :             :           /* Allow the result of build_array_copy and of
    1419                 :             :              build_value_init_noctor.  */
    1420                 :          94 :           if ((TREE_CODE (stripped_init) == VEC_INIT_EXPR
    1421                 :          75 :                || TREE_CODE (stripped_init) == CONSTRUCTOR)
    1422                 :         144 :               && (same_type_ignoring_top_level_qualifiers_p
    1423                 :          50 :                   (type, TREE_TYPE (init))))
    1424                 :             :             return init;
    1425                 :             : 
    1426                 :          53 :           if (complain & tf_error)
    1427                 :          53 :             error_at (loc, "array must be initialized with a brace-enclosed"
    1428                 :             :                       " initializer");
    1429                 :          53 :           return error_mark_node;
    1430                 :             :         }
    1431                 :             : 
    1432                 :      503743 :       return convert_for_initialization (NULL_TREE, type, init,
    1433                 :             :                                          flags,
    1434                 :             :                                          ICR_INIT, NULL_TREE, 0,
    1435                 :      503743 :                                          complain);
    1436                 :             :     }
    1437                 :             : }
    1438                 :             : 
    1439                 :             : tree
    1440                 :     1030155 : digest_init (tree type, tree init, tsubst_flags_t complain)
    1441                 :             : {
    1442                 :     1030155 :   return digest_init_r (type, init, 0, LOOKUP_IMPLICIT, complain);
    1443                 :             : }
    1444                 :             : 
    1445                 :             : tree
    1446                 :    36060786 : digest_init_flags (tree type, tree init, int flags, tsubst_flags_t complain)
    1447                 :             : {
    1448                 :    36060786 :   return digest_init_r (type, init, 0, flags, complain);
    1449                 :             : }
    1450                 :             : 
    1451                 :             : /* Callback to replace PLACEHOLDER_EXPRs in a TARGET_EXPR (which isn't used
    1452                 :             :    in the context of guaranteed copy elision).  */
    1453                 :             : 
    1454                 :             : static tree
    1455                 :     2218037 : replace_placeholders_for_class_temp_r (tree *tp, int *, void *)
    1456                 :             : {
    1457                 :     2218037 :   tree t = *tp;
    1458                 :             : 
    1459                 :             :   /* We're looking for a TARGET_EXPR nested in the whole expression.  */
    1460                 :     2218037 :   if (TREE_CODE (t) == TARGET_EXPR
    1461                 :             :       /* That serves as temporary materialization, not an initializer.  */
    1462                 :     2218037 :       && !TARGET_EXPR_ELIDING_P (t))
    1463                 :             :     {
    1464                 :         449 :       tree init = TARGET_EXPR_INITIAL (t);
    1465                 :         452 :       while (TREE_CODE (init) == COMPOUND_EXPR)
    1466                 :           3 :         init = TREE_OPERAND (init, 1);
    1467                 :         449 :       if (TREE_CODE (init) == CONSTRUCTOR
    1468                 :         449 :           && CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init))
    1469                 :             :         {
    1470                 :         129 :           tree obj = TARGET_EXPR_SLOT (t);
    1471                 :         129 :           replace_placeholders (init, obj);
    1472                 :             :           /* We should have dealt with all PLACEHOLDER_EXPRs.  */
    1473                 :         129 :           CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init) = false;
    1474                 :         129 :           gcc_checking_assert (!find_placeholders (init));
    1475                 :             :         }
    1476                 :             :     }
    1477                 :             : 
    1478                 :     2218037 :   return NULL_TREE;
    1479                 :             : }
    1480                 :             : 
    1481                 :             : /* Process the initializer INIT for an NSDMI DECL (a FIELD_DECL).  */
    1482                 :             : tree
    1483                 :      444808 : digest_nsdmi_init (tree decl, tree init, tsubst_flags_t complain)
    1484                 :             : {
    1485                 :      444808 :   gcc_assert (TREE_CODE (decl) == FIELD_DECL);
    1486                 :             : 
    1487                 :      444808 :   tree type = TREE_TYPE (decl);
    1488                 :      444808 :   if (DECL_BIT_FIELD_TYPE (decl))
    1489                 :        2880 :     type = DECL_BIT_FIELD_TYPE (decl);
    1490                 :      444808 :   int flags = LOOKUP_IMPLICIT;
    1491                 :      444808 :   if (DIRECT_LIST_INIT_P (init))
    1492                 :             :     {
    1493                 :       49336 :       flags = LOOKUP_NORMAL;
    1494                 :       49336 :       complain |= tf_no_cleanup;
    1495                 :             :     }
    1496                 :      163360 :   if (BRACE_ENCLOSED_INITIALIZER_P (init)
    1497                 :      608168 :       && CP_AGGREGATE_TYPE_P (type))
    1498                 :      130778 :     init = reshape_init (type, init, complain);
    1499                 :      444808 :   init = digest_init_flags (type, init, flags, complain);
    1500                 :      444808 :   set_target_expr_eliding (init);
    1501                 :             : 
    1502                 :             :   /* We may have temporary materialization in a NSDMI, if the initializer
    1503                 :             :      has something like A{} in it.  Digesting the {} could have introduced
    1504                 :             :      a PLACEHOLDER_EXPR referring to A.  Now that we've got a TARGET_EXPR,
    1505                 :             :      we have an object we can refer to.  The reason we bother doing this
    1506                 :             :      here is for code like
    1507                 :             : 
    1508                 :             :        struct A {
    1509                 :             :          int x;
    1510                 :             :          int y = x;
    1511                 :             :        };
    1512                 :             : 
    1513                 :             :        struct B {
    1514                 :             :          int x = 0;
    1515                 :             :          int y = A{x}.y; // #1
    1516                 :             :        };
    1517                 :             : 
    1518                 :             :      where in #1 we don't want to end up with two PLACEHOLDER_EXPRs for
    1519                 :             :      different types on the same level in a {} when lookup_placeholder
    1520                 :             :      wouldn't find a named object for the PLACEHOLDER_EXPR for A.  Note,
    1521                 :             :      temporary materialization does not occur when initializing an object
    1522                 :             :      from a prvalue of the same type, therefore we must not replace the
    1523                 :             :      placeholder with a temporary object so that it can be elided.  */
    1524                 :      444808 :   cp_walk_tree_without_duplicates (&init, replace_placeholders_for_class_temp_r,
    1525                 :             :                                    nullptr);
    1526                 :             : 
    1527                 :      444808 :   return init;
    1528                 :             : }
    1529                 :             : 
    1530                 :             : /* Set of flags used within process_init_constructor to describe the
    1531                 :             :    initializers.  */
    1532                 :             : #define PICFLAG_ERRONEOUS 1
    1533                 :             : #define PICFLAG_NOT_ALL_CONSTANT 2
    1534                 :             : #define PICFLAG_NOT_ALL_SIMPLE 4
    1535                 :             : #define PICFLAG_SIDE_EFFECTS 8
    1536                 :             : #define PICFLAG_VEC_INIT 16
    1537                 :             : 
    1538                 :             : /* Given an initializer INIT, return the flag (PICFLAG_*) which better
    1539                 :             :    describe it.  */
    1540                 :             : 
    1541                 :             : static int
    1542                 :    17126420 : picflag_from_initializer (tree init)
    1543                 :             : {
    1544                 :    17126420 :   if (init == error_mark_node)
    1545                 :             :     return PICFLAG_ERRONEOUS;
    1546                 :    17125999 :   else if (!TREE_CONSTANT (init))
    1547                 :             :     {
    1548                 :     1149907 :       if (TREE_SIDE_EFFECTS (init))
    1549                 :             :         return PICFLAG_SIDE_EFFECTS;
    1550                 :             :       else
    1551                 :     1075993 :         return PICFLAG_NOT_ALL_CONSTANT;
    1552                 :             :     }
    1553                 :    15976092 :   else if (!initializer_constant_valid_p (init, TREE_TYPE (init)))
    1554                 :       12390 :     return PICFLAG_NOT_ALL_SIMPLE;
    1555                 :             :   return 0;
    1556                 :             : }
    1557                 :             : 
    1558                 :             : /* Adjust INIT for going into a CONSTRUCTOR.  */
    1559                 :             : 
    1560                 :             : static tree
    1561                 :    16635702 : massage_init_elt (tree type, tree init, int nested, int flags,
    1562                 :             :                   tsubst_flags_t complain)
    1563                 :             : {
    1564                 :    16635702 :   int new_flags = LOOKUP_IMPLICIT;
    1565                 :    16635702 :   if (flags & LOOKUP_ALLOW_FLEXARRAY_INIT)
    1566                 :    13121905 :     new_flags |= LOOKUP_ALLOW_FLEXARRAY_INIT;
    1567                 :    16635702 :   if (flags & LOOKUP_AGGREGATE_PAREN_INIT)
    1568                 :        2017 :     new_flags |= LOOKUP_AGGREGATE_PAREN_INIT;
    1569                 :    29050457 :   init = digest_init_r (type, init, nested ? 2 : 1, new_flags, complain);
    1570                 :             :   /* When we defer constant folding within a statement, we may want to
    1571                 :             :      defer this folding as well.  Don't call this on CONSTRUCTORs because
    1572                 :             :      their elements have already been folded, and we must avoid folding
    1573                 :             :      the result of get_nsdmi.  */
    1574                 :    16635702 :   if (TREE_CODE (init) != CONSTRUCTOR)
    1575                 :             :     {
    1576                 :    14806681 :       tree t = fold_non_dependent_init (init, complain);
    1577                 :    14806681 :       if (TREE_CONSTANT (t))
    1578                 :    13646449 :         init = t;
    1579                 :    14806681 :       set_target_expr_eliding (init);
    1580                 :             :     }
    1581                 :    16635702 :   return init;
    1582                 :             : }
    1583                 :             : 
    1584                 :             : /* Subroutine of process_init_constructor, which will process an initializer
    1585                 :             :    INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
    1586                 :             :    which describe the initializers.  */
    1587                 :             : 
    1588                 :             : static int
    1589                 :      340784 : process_init_constructor_array (tree type, tree init, int nested, int flags,
    1590                 :             :                                 tsubst_flags_t complain)
    1591                 :             : {
    1592                 :      340784 :   unsigned HOST_WIDE_INT i, j, len = 0;
    1593                 :      340784 :   int picflags = 0;
    1594                 :      340784 :   bool unbounded = false;
    1595                 :      340784 :   constructor_elt *ce;
    1596                 :      340784 :   vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (init);
    1597                 :             : 
    1598                 :      340784 :   gcc_assert (TREE_CODE (type) == ARRAY_TYPE
    1599                 :             :               || VECTOR_TYPE_P (type));
    1600                 :             : 
    1601                 :      340784 :   if (TREE_CODE (type) == ARRAY_TYPE)
    1602                 :             :     {
    1603                 :             :       /* C++ flexible array members have a null domain.  */
    1604                 :      299818 :       tree domain = TYPE_DOMAIN (type);
    1605                 :      299818 :       if (domain && TREE_CONSTANT (TYPE_MAX_VALUE (domain)))
    1606                 :      598756 :         len = wi::ext (wi::to_offset (TYPE_MAX_VALUE (domain))
    1607                 :      598756 :                        - wi::to_offset (TYPE_MIN_VALUE (domain)) + 1,
    1608                 :      299378 :                        TYPE_PRECISION (TREE_TYPE (domain)),
    1609                 :      598756 :                        TYPE_SIGN (TREE_TYPE (domain))).to_uhwi ();
    1610                 :             :       else
    1611                 :             :         unbounded = true;  /* Take as many as there are.  */
    1612                 :             : 
    1613                 :      299818 :       if (nested == 2 && !domain && !vec_safe_is_empty (v))
    1614                 :             :         {
    1615                 :          69 :           if (complain & tf_error)
    1616                 :         138 :             error_at (cp_expr_loc_or_input_loc (init),
    1617                 :             :                       "initialization of flexible array member "
    1618                 :             :                       "in a nested context");
    1619                 :          69 :           return PICFLAG_ERRONEOUS;
    1620                 :             :         }
    1621                 :             :     }
    1622                 :             :   else
    1623                 :             :     /* Vectors are like simple fixed-size arrays.  */
    1624                 :       40966 :     unbounded = !TYPE_VECTOR_SUBPARTS (type).is_constant (&len);
    1625                 :             : 
    1626                 :             :   /* There must not be more initializers than needed.  */
    1627                 :      340715 :   if (!unbounded && vec_safe_length (v) > len)
    1628                 :             :     {
    1629                 :          13 :       if (complain & tf_error)
    1630                 :          13 :         error ("too many initializers for %qT", type);
    1631                 :             :       else
    1632                 :             :         return PICFLAG_ERRONEOUS;
    1633                 :             :     }
    1634                 :             : 
    1635                 :      340715 :   j = 0;
    1636                 :    10903189 :   FOR_EACH_VEC_SAFE_ELT (v, i, ce)
    1637                 :             :     {
    1638                 :    10562474 :       if (!ce->index)
    1639                 :         538 :         ce->index = size_int (j);
    1640                 :    10561936 :       else if (!check_array_designated_initializer (ce, j))
    1641                 :           0 :         ce->index = error_mark_node;
    1642                 :    10562474 :       gcc_assert (ce->value);
    1643                 :    10562474 :       ce->value
    1644                 :    10562474 :         = massage_init_elt (TREE_TYPE (type), ce->value, nested, flags,
    1645                 :             :                             complain);
    1646                 :             : 
    1647                 :    10562474 :       gcc_checking_assert
    1648                 :             :         (ce->value == error_mark_node
    1649                 :             :          || (same_type_ignoring_top_level_qualifiers_p
    1650                 :             :              (strip_array_types (TREE_TYPE (type)),
    1651                 :             :               strip_array_types (TREE_TYPE (ce->value)))));
    1652                 :             : 
    1653                 :    10562474 :       picflags |= picflag_from_initializer (ce->value);
    1654                 :             :       /* Propagate CONSTRUCTOR_PLACEHOLDER_BOUNDARY to outer
    1655                 :             :          CONSTRUCTOR.  */
    1656                 :    10562474 :       if (TREE_CODE (ce->value) == CONSTRUCTOR
    1657                 :    10562474 :           && CONSTRUCTOR_PLACEHOLDER_BOUNDARY (ce->value))
    1658                 :             :         {
    1659                 :          17 :           CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init) = 1;
    1660                 :          17 :           CONSTRUCTOR_PLACEHOLDER_BOUNDARY (ce->value) = 0;
    1661                 :             :         }
    1662                 :    10562474 :       if (TREE_CODE (ce->value) == RAW_DATA_CST)
    1663                 :         163 :         j += RAW_DATA_LENGTH (ce->value);
    1664                 :             :       else
    1665                 :    10562311 :         ++j;
    1666                 :             :     }
    1667                 :             : 
    1668                 :             :   /* No more initializers. If the array is unbounded, we are done. Otherwise,
    1669                 :             :      we must add initializers ourselves.  */
    1670                 :      340715 :   if (!unbounded)
    1671                 :      340422 :     for (; i < len; ++i)
    1672                 :             :       {
    1673                 :       21380 :         tree next;
    1674                 :             : 
    1675                 :       21380 :         if (type_build_ctor_call (TREE_TYPE (type)))
    1676                 :             :           {
    1677                 :             :             /* If this type needs constructors run for default-initialization,
    1678                 :             :                we can't rely on the back end to do it for us, so make the
    1679                 :             :                initialization explicit by list-initializing from T{}.  */
    1680                 :         373 :             next = build_constructor (init_list_type_node, NULL);
    1681                 :         373 :             next = massage_init_elt (TREE_TYPE (type), next, nested, flags,
    1682                 :             :                                      complain);
    1683                 :         373 :             if (initializer_zerop (next))
    1684                 :             :               /* The default zero-initialization is fine for us; don't
    1685                 :             :                  add anything to the CONSTRUCTOR.  */
    1686                 :             :               next = NULL_TREE;
    1687                 :             :           }
    1688                 :       21007 :         else if (!zero_init_p (TREE_TYPE (type)))
    1689                 :         138 :           next = build_zero_init (TREE_TYPE (type),
    1690                 :             :                                   /*nelts=*/NULL_TREE,
    1691                 :             :                                   /*static_storage_p=*/false);
    1692                 :             :         else
    1693                 :             :           /* The default zero-initialization is fine for us; don't
    1694                 :             :              add anything to the CONSTRUCTOR.  */
    1695                 :             :           next = NULL_TREE;
    1696                 :             : 
    1697                 :         295 :         if (next)
    1698                 :             :           {
    1699                 :         295 :             if (next != error_mark_node
    1700                 :         295 :                 && (initializer_constant_valid_p (next, TREE_TYPE (next))
    1701                 :         283 :                     != null_pointer_node))
    1702                 :             :               {
    1703                 :             :                 /* Use VEC_INIT_EXPR for non-constant initialization of
    1704                 :             :                    trailing elements with no explicit initializers.  */
    1705                 :         135 :                 picflags |= PICFLAG_VEC_INIT;
    1706                 :         135 :                 break;
    1707                 :             :               }
    1708                 :             : 
    1709                 :         160 :             picflags |= picflag_from_initializer (next);
    1710                 :             :             /* Propagate CONSTRUCTOR_PLACEHOLDER_BOUNDARY to outer
    1711                 :             :                CONSTRUCTOR.  */
    1712                 :         160 :             if (TREE_CODE (next) == CONSTRUCTOR
    1713                 :         160 :                 && CONSTRUCTOR_PLACEHOLDER_BOUNDARY (next))
    1714                 :             :               {
    1715                 :           0 :                 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init) = 1;
    1716                 :           0 :                 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (next) = 0;
    1717                 :             :               }
    1718                 :         160 :             if (len > i+1)
    1719                 :             :               {
    1720                 :          82 :                 tree range = build2 (RANGE_EXPR, size_type_node,
    1721                 :          82 :                                      build_int_cst (size_type_node, i),
    1722                 :          82 :                                      build_int_cst (size_type_node, len - 1));
    1723                 :          82 :                 CONSTRUCTOR_APPEND_ELT (v, range, next);
    1724                 :          82 :                 break;
    1725                 :             :               }
    1726                 :             :             else
    1727                 :          78 :               CONSTRUCTOR_APPEND_ELT (v, size_int (i), next);
    1728                 :             :           }
    1729                 :             :         else
    1730                 :             :           /* Don't bother checking all the other elements.  */
    1731                 :             :           break;
    1732                 :             :       }
    1733                 :             : 
    1734                 :      340715 :   CONSTRUCTOR_ELTS (init) = v;
    1735                 :      340715 :   return picflags;
    1736                 :             : }
    1737                 :             : 
    1738                 :             : /* Subroutine of process_init_constructor, which will process an initializer
    1739                 :             :    INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
    1740                 :             :    the initializers.  */
    1741                 :             : 
    1742                 :             : static int
    1743                 :     6638798 : process_init_constructor_record (tree type, tree init, int nested, int flags,
    1744                 :             :                                  tsubst_flags_t complain)
    1745                 :             : {
    1746                 :     6638798 :   vec<constructor_elt, va_gc> *v = NULL;
    1747                 :     6638798 :   tree field;
    1748                 :     6638798 :   int skipped = 0;
    1749                 :             : 
    1750                 :     6638798 :   gcc_assert (TREE_CODE (type) == RECORD_TYPE);
    1751                 :     6638798 :   gcc_assert (!CLASSTYPE_VBASECLASSES (type));
    1752                 :     6638798 :   gcc_assert (!TYPE_BINFO (type)
    1753                 :             :               || cxx_dialect >= cxx17
    1754                 :             :               || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type)));
    1755                 :     6638798 :   gcc_assert (!TYPE_POLYMORPHIC_P (type));
    1756                 :             : 
    1757                 :     6638798 :  restart:
    1758                 :     6676021 :   int picflags = 0;
    1759                 :     6676021 :   unsigned HOST_WIDE_INT idx = 0;
    1760                 :     6676021 :   int designator_skip = -1;
    1761                 :             :   /* Generally, we will always have an index for each initializer (which is
    1762                 :             :      a FIELD_DECL, put by reshape_init), but compound literals don't go trough
    1763                 :             :      reshape_init. So we need to handle both cases.  */
    1764                 :    62983474 :   for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
    1765                 :             :     {
    1766                 :    56345216 :       tree next;
    1767                 :             : 
    1768                 :   105146571 :       if (TREE_CODE (field) != FIELD_DECL
    1769                 :    56345216 :           || (DECL_ARTIFICIAL (field)
    1770                 :      390597 :               && !(cxx_dialect >= cxx17 && DECL_FIELD_IS_BASE (field))))
    1771                 :    48801355 :         continue;
    1772                 :             : 
    1773                 :     7543861 :       if (DECL_UNNAMED_BIT_FIELD (field))
    1774                 :         113 :         continue;
    1775                 :             : 
    1776                 :             :       /* If this is a bitfield, first convert to the declared type.  */
    1777                 :     7543748 :       tree fldtype = TREE_TYPE (field);
    1778                 :     7543748 :       if (DECL_BIT_FIELD_TYPE (field))
    1779                 :      743748 :         fldtype = DECL_BIT_FIELD_TYPE (field);
    1780                 :     7543748 :       if (fldtype == error_mark_node)
    1781                 :             :         return PICFLAG_ERRONEOUS;
    1782                 :             : 
    1783                 :     7543733 :       next = NULL_TREE;
    1784                 :     7543733 :       if (idx < CONSTRUCTOR_NELTS (init))
    1785                 :             :         {
    1786                 :     5961860 :           constructor_elt *ce = &(*CONSTRUCTOR_ELTS (init))[idx];
    1787                 :     5961860 :           if (ce->index)
    1788                 :             :             {
    1789                 :             :               /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
    1790                 :             :                  latter case can happen in templates where lookup has to be
    1791                 :             :                  deferred.  */
    1792                 :     5960398 :               gcc_assert (TREE_CODE (ce->index) == FIELD_DECL
    1793                 :             :                           || identifier_p (ce->index));
    1794                 :     5960398 :               if (ce->index == field || ce->index == DECL_NAME (field))
    1795                 :     5960293 :                 next = ce->value;
    1796                 :             :               else
    1797                 :             :                 {
    1798                 :         105 :                   ce = NULL;
    1799                 :         105 :                   if (designator_skip == -1)
    1800                 :             :                     designator_skip = 1;
    1801                 :             :                 }
    1802                 :             :             }
    1803                 :             :           else
    1804                 :             :             {
    1805                 :        1462 :               designator_skip = 0;
    1806                 :        1462 :               next = ce->value;
    1807                 :             :             }
    1808                 :             : 
    1809                 :     5961755 :           if (ce)
    1810                 :             :             {
    1811                 :     5961755 :               gcc_assert (ce->value);
    1812                 :     5961755 :               next = massage_init_elt (fldtype, next, nested, flags, complain);
    1813                 :     5961755 :               ++idx;
    1814                 :             :             }
    1815                 :             :         }
    1816                 :     7543733 :       if (next == error_mark_node)
    1817                 :             :         /* We skip initializers for empty bases/fields, so skipping an invalid
    1818                 :             :            one could make us accept invalid code.  */
    1819                 :             :         return PICFLAG_ERRONEOUS;
    1820                 :     7543208 :       else if (next)
    1821                 :             :         /* Already handled above.  */;
    1822                 :     1581978 :       else if (DECL_INITIAL (field))
    1823                 :             :         {
    1824                 :       83295 :           if (skipped > 0)
    1825                 :             :             {
    1826                 :             :               /* We're using an NSDMI past a field with implicit
    1827                 :             :                  zero-init.  Go back and make it explicit.  */
    1828                 :       37223 :               skipped = -1;
    1829                 :       37223 :               vec_safe_truncate (v, 0);
    1830                 :       37223 :               goto restart;
    1831                 :             :             }
    1832                 :             :           /* C++14 aggregate NSDMI.  */
    1833                 :       46072 :           next = get_nsdmi (field, /*ctor*/false, complain);
    1834                 :       46072 :           if (!CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init)
    1835                 :       46072 :               && find_placeholders (next))
    1836                 :         847 :             CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init) = 1;
    1837                 :             :         }
    1838                 :     1498683 :       else if (type_build_ctor_call (fldtype))
    1839                 :             :         {
    1840                 :             :           /* If this type needs constructors run for
    1841                 :             :              default-initialization, we can't rely on the back end to do it
    1842                 :             :              for us, so build up TARGET_EXPRs.  If the type in question is
    1843                 :             :              a class, just build one up; if it's an array, recurse.  */
    1844                 :        3891 :           next = build_constructor (init_list_type_node, NULL);
    1845                 :        3891 :           next = massage_init_elt (fldtype, next, nested, flags, complain);
    1846                 :        3891 :           if (TREE_CODE (next) == TARGET_EXPR
    1847                 :        3891 :               && unsafe_copy_elision_p (field, next))
    1848                 :           0 :             TARGET_EXPR_ELIDING_P (next) = false;
    1849                 :             : 
    1850                 :             :           /* Warn when some struct elements are implicitly initialized.  */
    1851                 :        3891 :           if ((complain & tf_warning)
    1852                 :        3775 :               && !cp_unevaluated_operand
    1853                 :        7642 :               && !EMPTY_CONSTRUCTOR_P (init))
    1854                 :          24 :             warning (OPT_Wmissing_field_initializers,
    1855                 :             :                      "missing initializer for member %qD", field);
    1856                 :             :         }
    1857                 :             :       else
    1858                 :             :         {
    1859                 :     1494792 :           if (TYPE_REF_P (fldtype))
    1860                 :             :             {
    1861                 :          21 :               if (complain & tf_error)
    1862                 :          21 :                 error ("member %qD is uninitialized reference", field);
    1863                 :             :               else
    1864                 :             :                 return PICFLAG_ERRONEOUS;
    1865                 :             :             }
    1866                 :     1494771 :           else if (CLASSTYPE_REF_FIELDS_NEED_INIT (fldtype))
    1867                 :             :             {
    1868                 :           1 :               if (complain & tf_error)
    1869                 :           1 :                 error ("member %qD with uninitialized reference fields", field);
    1870                 :             :               else
    1871                 :             :                 return PICFLAG_ERRONEOUS;
    1872                 :             :             }
    1873                 :             :           /* Do nothing for flexible array members since they need not have any
    1874                 :             :              elements.  Don't worry about 'skipped' because a flexarray has to
    1875                 :             :              be the last field.  */
    1876                 :     1494770 :           else if (TREE_CODE (fldtype) == ARRAY_TYPE && !TYPE_DOMAIN (fldtype))
    1877                 :         103 :             continue;
    1878                 :             : 
    1879                 :             :           /* Warn when some struct elements are implicitly initialized
    1880                 :             :              to zero.  */
    1881                 :     1494689 :           if ((complain & tf_warning)
    1882                 :     1365924 :               && !cp_unevaluated_operand
    1883                 :     1365391 :               && !EMPTY_CONSTRUCTOR_P (init)
    1884                 :     1495841 :               && !is_really_empty_class (fldtype, /*ignore_vptr*/false))
    1885                 :        1075 :             warning (OPT_Wmissing_field_initializers,
    1886                 :             :                      "missing initializer for member %qD", field);
    1887                 :             : 
    1888                 :     1494689 :           if (!zero_init_p (fldtype) || skipped < 0)
    1889                 :             :             {
    1890                 :      445765 :               if (TYPE_REF_P (fldtype))
    1891                 :           3 :                 next = build_zero_cst (fldtype);
    1892                 :             :               else
    1893                 :      445762 :                 next = build_zero_init (fldtype, /*nelts=*/NULL_TREE,
    1894                 :             :                                         /*static_storage_p=*/false);
    1895                 :             :             }
    1896                 :             :           else
    1897                 :             :             {
    1898                 :             :               /* The default zero-initialization is fine for us; don't
    1899                 :             :                  add anything to the CONSTRUCTOR.  */
    1900                 :     1048924 :               skipped = 1;
    1901                 :     1048924 :               continue;
    1902                 :             :             }
    1903                 :             :         }
    1904                 :             : 
    1905                 :             :       /* We can't actually elide the temporary when initializing a
    1906                 :             :          potentially-overlapping field from a function that returns by
    1907                 :             :          value.  */
    1908                 :     6456958 :       if (TREE_CODE (next) == TARGET_EXPR
    1909                 :     6456958 :           && unsafe_copy_elision_p (field, next))
    1910                 :          25 :         TARGET_EXPR_ELIDING_P (next) = false;
    1911                 :             : 
    1912                 :     6456958 :       if (is_empty_field (field)
    1913                 :     6456958 :           && !TREE_SIDE_EFFECTS (next))
    1914                 :             :         /* Don't add trivial initialization of an empty base/field to the
    1915                 :             :            constructor, as they might not be ordered the way the back-end
    1916                 :             :            expects.  */
    1917                 :         382 :         continue;
    1918                 :             : 
    1919                 :             :       /* If this is a bitfield, now convert to the lowered type.  */
    1920                 :     6456576 :       if (fldtype != TREE_TYPE (field))
    1921                 :      372178 :         next = cp_convert_and_check (TREE_TYPE (field), next, complain);
    1922                 :     6456576 :       picflags |= picflag_from_initializer (next);
    1923                 :             :       /* Propagate CONSTRUCTOR_PLACEHOLDER_BOUNDARY to outer CONSTRUCTOR.  */
    1924                 :     6456576 :       if (TREE_CODE (next) == CONSTRUCTOR
    1925                 :     6456576 :           && CONSTRUCTOR_PLACEHOLDER_BOUNDARY (next))
    1926                 :             :         {
    1927                 :          66 :           CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init) = 1;
    1928                 :          66 :           CONSTRUCTOR_PLACEHOLDER_BOUNDARY (next) = 0;
    1929                 :             :         }
    1930                 :    62764029 :       CONSTRUCTOR_APPEND_ELT (v, field, next);
    1931                 :             :     }
    1932                 :             : 
    1933                 :     6638258 :   if (idx < CONSTRUCTOR_NELTS (init))
    1934                 :             :     {
    1935                 :          91 :       if (complain & tf_error)
    1936                 :             :         {
    1937                 :          24 :           constructor_elt *ce = &(*CONSTRUCTOR_ELTS (init))[idx];
    1938                 :             :           /* For better diagnostics, try to find out if it is really
    1939                 :             :              the case of too many initializers or if designators are
    1940                 :             :              in incorrect order.  */
    1941                 :          24 :           if (designator_skip == 1 && ce->index)
    1942                 :             :             {
    1943                 :          15 :               gcc_assert (TREE_CODE (ce->index) == FIELD_DECL
    1944                 :             :                           || identifier_p (ce->index));
    1945                 :          15 :               for (field = TYPE_FIELDS (type);
    1946                 :          54 :                    field; field = DECL_CHAIN (field))
    1947                 :             :                 {
    1948                 :          90 :                   if (TREE_CODE (field) != FIELD_DECL
    1949                 :          54 :                       || (DECL_ARTIFICIAL (field)
    1950                 :           0 :                           && !(cxx_dialect >= cxx17
    1951                 :           0 :                                && DECL_FIELD_IS_BASE (field))))
    1952                 :          36 :                     continue;
    1953                 :             : 
    1954                 :          18 :                   if (DECL_UNNAMED_BIT_FIELD (field))
    1955                 :           0 :                     continue;
    1956                 :             : 
    1957                 :          18 :                   if (ce->index == field || ce->index == DECL_NAME (field))
    1958                 :             :                     break;
    1959                 :             :                 }
    1960                 :             :             }
    1961                 :          24 :           if (field)
    1962                 :          15 :             error ("designator order for field %qD does not match declaration "
    1963                 :             :                    "order in %qT", field, type);
    1964                 :             :           else
    1965                 :           9 :             error ("too many initializers for %qT", type);
    1966                 :             :         }
    1967                 :             :       else
    1968                 :             :         return PICFLAG_ERRONEOUS;
    1969                 :             :     }
    1970                 :             : 
    1971                 :     6638191 :   CONSTRUCTOR_ELTS (init) = v;
    1972                 :     6638191 :   return picflags;
    1973                 :             : }
    1974                 :             : 
    1975                 :             : /* Subroutine of process_init_constructor, which will process a single
    1976                 :             :    initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
    1977                 :             :    which describe the initializer.  */
    1978                 :             : 
    1979                 :             : static int
    1980                 :      116772 : process_init_constructor_union (tree type, tree init, int nested, int flags,
    1981                 :             :                                 tsubst_flags_t complain)
    1982                 :             : {
    1983                 :      116772 :   constructor_elt *ce;
    1984                 :      116772 :   int len;
    1985                 :             : 
    1986                 :             :   /* If the initializer was empty, use the union's NSDMI if it has one.
    1987                 :             :      Otherwise use default zero initialization.  */
    1988                 :      116772 :   if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init)))
    1989                 :             :     {
    1990                 :      105358 :       for (tree field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
    1991                 :             :         {
    1992                 :       95796 :           if (TREE_CODE (field) == FIELD_DECL
    1993                 :       95796 :               && DECL_INITIAL (field) != NULL_TREE)
    1994                 :             :             {
    1995                 :          26 :               tree val = get_nsdmi (field, /*in_ctor=*/false, complain);
    1996                 :          26 :               if (!CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init)
    1997                 :          26 :                   && find_placeholders (val))
    1998                 :          20 :                 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init) = 1;
    1999                 :          26 :               CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (init), field, val);
    2000                 :          26 :               break;
    2001                 :             :             }
    2002                 :             :         }
    2003                 :             : 
    2004                 :        9588 :       if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init)))
    2005                 :             :         return 0;
    2006                 :             :     }
    2007                 :             : 
    2008                 :      107210 :   len = CONSTRUCTOR_ELTS (init)->length ();
    2009                 :      107210 :   if (len > 1)
    2010                 :             :     {
    2011                 :           3 :       if (!(complain & tf_error))
    2012                 :             :         return PICFLAG_ERRONEOUS;
    2013                 :           3 :       error ("too many initializers for %qT", type);
    2014                 :           3 :       CONSTRUCTOR_ELTS (init)->block_remove (1, len-1);
    2015                 :             :     }
    2016                 :             : 
    2017                 :      107210 :   ce = &(*CONSTRUCTOR_ELTS (init))[0];
    2018                 :             : 
    2019                 :             :   /* If this element specifies a field, initialize via that field.  */
    2020                 :      107210 :   if (ce->index)
    2021                 :             :     {
    2022                 :      107202 :       if (TREE_CODE (ce->index) == FIELD_DECL)
    2023                 :             :         ;
    2024                 :           0 :       else if (identifier_p (ce->index))
    2025                 :             :         {
    2026                 :             :           /* This can happen within a cast, see g++.dg/opt/cse2.C.  */
    2027                 :           0 :           tree name = ce->index;
    2028                 :           0 :           tree field;
    2029                 :           0 :           for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
    2030                 :           0 :             if (DECL_NAME (field) == name)
    2031                 :             :               break;
    2032                 :           0 :           if (!field)
    2033                 :             :             {
    2034                 :           0 :               if (complain & tf_error)
    2035                 :           0 :                 error ("no field %qD found in union being initialized",
    2036                 :             :                        field);
    2037                 :           0 :               ce->value = error_mark_node;
    2038                 :             :             }
    2039                 :           0 :           ce->index = field;
    2040                 :             :         }
    2041                 :             :       else
    2042                 :             :         {
    2043                 :           0 :           gcc_assert (TREE_CODE (ce->index) == INTEGER_CST
    2044                 :             :                       || TREE_CODE (ce->index) == RANGE_EXPR);
    2045                 :           0 :           if (complain & tf_error)
    2046                 :           0 :             error ("index value instead of field name in union initializer");
    2047                 :           0 :           ce->value = error_mark_node;
    2048                 :             :         }
    2049                 :             :     }
    2050                 :             :   else
    2051                 :             :     {
    2052                 :             :       /* Find the first named field.  ANSI decided in September 1990
    2053                 :             :          that only named fields count here.  */
    2054                 :           8 :       tree field = TYPE_FIELDS (type);
    2055                 :          90 :       while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
    2056                 :          82 :         field = TREE_CHAIN (field);
    2057                 :           8 :       if (field == NULL_TREE)
    2058                 :             :         {
    2059                 :           1 :           if (complain & tf_error)
    2060                 :           1 :             error ("too many initializers for %qT", type);
    2061                 :           1 :           ce->value = error_mark_node;
    2062                 :             :         }
    2063                 :           8 :       ce->index = field;
    2064                 :             :     }
    2065                 :             : 
    2066                 :      107210 :   if (ce->value && ce->value != error_mark_node)
    2067                 :      107209 :     ce->value = massage_init_elt (TREE_TYPE (ce->index), ce->value, nested,
    2068                 :             :                                   flags, complain);
    2069                 :             : 
    2070                 :             :   /* Propagate CONSTRUCTOR_PLACEHOLDER_BOUNDARY to outer CONSTRUCTOR.  */
    2071                 :      107210 :   if (ce->value
    2072                 :      107210 :       && TREE_CODE (ce->value) == CONSTRUCTOR
    2073                 :      174623 :       && CONSTRUCTOR_PLACEHOLDER_BOUNDARY (ce->value))
    2074                 :             :     {
    2075                 :           0 :       CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init) = 1;
    2076                 :           0 :       CONSTRUCTOR_PLACEHOLDER_BOUNDARY (ce->value) = 0;
    2077                 :             :     }
    2078                 :      107210 :   return picflag_from_initializer (ce->value);
    2079                 :             : }
    2080                 :             : 
    2081                 :             : /* Process INIT, a constructor for a variable of aggregate type TYPE. The
    2082                 :             :    constructor is a brace-enclosed initializer, and will be modified in-place.
    2083                 :             : 
    2084                 :             :    Each element is converted to the right type through digest_init, and
    2085                 :             :    missing initializers are added following the language rules (zero-padding,
    2086                 :             :    etc.).
    2087                 :             : 
    2088                 :             :    After the execution, the initializer will have TREE_CONSTANT if all elts are
    2089                 :             :    constant, and TREE_STATIC set if, in addition, all elts are simple enough
    2090                 :             :    constants that the assembler and linker can compute them.
    2091                 :             : 
    2092                 :             :    The function returns the initializer itself, or error_mark_node in case
    2093                 :             :    of error.  */
    2094                 :             : 
    2095                 :             : static tree
    2096                 :     7096354 : process_init_constructor (tree type, tree init, int nested, int flags,
    2097                 :             :                           tsubst_flags_t complain)
    2098                 :             : {
    2099                 :     7096354 :   int picflags;
    2100                 :             : 
    2101                 :     7096354 :   gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
    2102                 :             : 
    2103                 :     7096354 :   if (TREE_CODE (type) == ARRAY_TYPE || VECTOR_TYPE_P (type))
    2104                 :      340784 :     picflags = process_init_constructor_array (type, init, nested, flags,
    2105                 :             :                                                complain);
    2106                 :     6755570 :   else if (TREE_CODE (type) == RECORD_TYPE)
    2107                 :     6638798 :     picflags = process_init_constructor_record (type, init, nested, flags,
    2108                 :             :                                                 complain);
    2109                 :      116772 :   else if (TREE_CODE (type) == UNION_TYPE)
    2110                 :      116772 :     picflags = process_init_constructor_union (type, init, nested, flags,
    2111                 :             :                                                complain);
    2112                 :             :   else
    2113                 :           0 :     gcc_unreachable ();
    2114                 :             : 
    2115                 :     7096354 :   if (picflags & PICFLAG_ERRONEOUS)
    2116                 :        1038 :     return error_mark_node;
    2117                 :             : 
    2118                 :     7095316 :   TREE_TYPE (init) = type;
    2119                 :     7095316 :   if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
    2120                 :         310 :     cp_complete_array_type (&TREE_TYPE (init), init, /*do_default=*/0);
    2121                 :     7095316 :   if (picflags & PICFLAG_SIDE_EFFECTS)
    2122                 :             :     {
    2123                 :       53484 :       TREE_CONSTANT (init) = false;
    2124                 :       53484 :       TREE_SIDE_EFFECTS (init) = true;
    2125                 :             :     }
    2126                 :     7041832 :   else if (picflags & PICFLAG_NOT_ALL_CONSTANT)
    2127                 :             :     {
    2128                 :             :       /* Make sure TREE_CONSTANT isn't set from build_constructor.  */
    2129                 :      677716 :       TREE_CONSTANT (init) = false;
    2130                 :      677716 :       TREE_SIDE_EFFECTS (init) = false;
    2131                 :             :     }
    2132                 :             :   else
    2133                 :             :     {
    2134                 :     6364116 :       TREE_CONSTANT (init) = 1;
    2135                 :     6364116 :       TREE_SIDE_EFFECTS (init) = false;
    2136                 :     6364116 :       if (!(picflags & PICFLAG_NOT_ALL_SIMPLE))
    2137                 :     6351803 :         TREE_STATIC (init) = 1;
    2138                 :             :     }
    2139                 :     7095316 :   if (picflags & PICFLAG_VEC_INIT)
    2140                 :             :     {
    2141                 :             :       /* Defer default-initialization of array elements with no corresponding
    2142                 :             :          initializer-clause until later so we can use a loop.  */
    2143                 :         135 :       TREE_TYPE (init) = init_list_type_node;
    2144                 :         135 :       init = build_vec_init_expr (type, init, complain);
    2145                 :         135 :       init = get_target_expr (init);
    2146                 :             :     }
    2147                 :             :   return init;
    2148                 :             : }
    2149                 :             : 
    2150                 :             : /* Given a structure or union value DATUM, construct and return
    2151                 :             :    the structure or union component which results from narrowing
    2152                 :             :    that value to the base specified in BASETYPE.  For example, given the
    2153                 :             :    hierarchy
    2154                 :             : 
    2155                 :             :    class L { int ii; };
    2156                 :             :    class A : L { ... };
    2157                 :             :    class B : L { ... };
    2158                 :             :    class C : A, B { ... };
    2159                 :             : 
    2160                 :             :    and the declaration
    2161                 :             : 
    2162                 :             :    C x;
    2163                 :             : 
    2164                 :             :    then the expression
    2165                 :             : 
    2166                 :             :    x.A::ii refers to the ii member of the L part of
    2167                 :             :    the A part of the C object named by X.  In this case,
    2168                 :             :    DATUM would be x, and BASETYPE would be A.
    2169                 :             : 
    2170                 :             :    I used to think that this was nonconformant, that the standard specified
    2171                 :             :    that first we look up ii in A, then convert x to an L& and pull out the
    2172                 :             :    ii part.  But in fact, it does say that we convert x to an A&; A here
    2173                 :             :    is known as the "naming class".  (jason 2000-12-19)
    2174                 :             : 
    2175                 :             :    BINFO_P points to a variable initialized either to NULL_TREE or to the
    2176                 :             :    binfo for the specific base subobject we want to convert to.  */
    2177                 :             : 
    2178                 :             : tree
    2179                 :       14480 : build_scoped_ref (tree datum, tree basetype, tree* binfo_p)
    2180                 :             : {
    2181                 :       14480 :   tree binfo;
    2182                 :             : 
    2183                 :       14480 :   if (datum == error_mark_node)
    2184                 :             :     return error_mark_node;
    2185                 :       14480 :   if (*binfo_p)
    2186                 :             :     binfo = *binfo_p;
    2187                 :             :   else
    2188                 :       14480 :     binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check,
    2189                 :             :                          NULL, tf_warning_or_error);
    2190                 :             : 
    2191                 :       14480 :   if (!binfo || binfo == error_mark_node)
    2192                 :             :     {
    2193                 :           6 :       *binfo_p = NULL_TREE;
    2194                 :           6 :       if (!binfo)
    2195                 :           0 :         error_not_base_type (basetype, TREE_TYPE (datum));
    2196                 :           6 :       return error_mark_node;
    2197                 :             :     }
    2198                 :             : 
    2199                 :       14474 :   *binfo_p = binfo;
    2200                 :       14474 :   return build_base_path (PLUS_EXPR, datum, binfo, 1,
    2201                 :       14474 :                           tf_warning_or_error);
    2202                 :             : }
    2203                 :             : 
    2204                 :             : /* Build a reference to an object specified by the C++ `->' operator.
    2205                 :             :    Usually this just involves dereferencing the object, but if the
    2206                 :             :    `->' operator is overloaded, then such overloads must be
    2207                 :             :    performed until an object which does not have the `->' operator
    2208                 :             :    overloaded is found.  An error is reported when circular pointer
    2209                 :             :    delegation is detected.  */
    2210                 :             : 
    2211                 :             : tree
    2212                 :    34889564 : build_x_arrow (location_t loc, tree expr, tsubst_flags_t complain)
    2213                 :             : {
    2214                 :    34889564 :   tree orig_expr = expr;
    2215                 :    34889564 :   tree type = TREE_TYPE (expr);
    2216                 :    34889564 :   tree last_rval = NULL_TREE;
    2217                 :    34889564 :   vec<tree, va_gc> *types_memoized = NULL;
    2218                 :             : 
    2219                 :    34889564 :   if (type == error_mark_node)
    2220                 :             :     return error_mark_node;
    2221                 :             : 
    2222                 :    34889510 :   if (processing_template_decl)
    2223                 :             :     {
    2224                 :    31136979 :       tree ttype = NULL_TREE;
    2225                 :    31136979 :       if (type && TYPE_PTR_P (type))
    2226                 :    25296797 :         ttype = TREE_TYPE (type);
    2227                 :    25296797 :       if (ttype && !dependent_scope_p (ttype))
    2228                 :             :         /* Pointer to current instantiation, don't treat as dependent.  */;
    2229                 :     9752760 :       else if (type_dependent_expression_p (expr))
    2230                 :             :         {
    2231                 :     9680416 :           expr = build_min_nt_loc (loc, ARROW_EXPR, expr);
    2232                 :     9680416 :           TREE_TYPE (expr) = ttype;
    2233                 :     9680416 :           return expr;
    2234                 :             :         }
    2235                 :             :     }
    2236                 :             : 
    2237                 :    25209094 :   if (MAYBE_CLASS_TYPE_P (type))
    2238                 :             :     {
    2239                 :      182699 :       struct tinst_level *actual_inst = current_instantiation ();
    2240                 :      182699 :       tree fn = NULL;
    2241                 :             : 
    2242                 :      368160 :       while ((expr = build_new_op (loc, COMPONENT_REF,
    2243                 :             :                                    LOOKUP_NORMAL, expr, NULL_TREE, NULL_TREE,
    2244                 :             :                                    NULL_TREE, &fn, complain)))
    2245                 :             :         {
    2246                 :      185477 :           if (expr == error_mark_node)
    2247                 :          22 :             return error_mark_node;
    2248                 :             : 
    2249                 :             :           /* This provides a better instantiation backtrace in case of
    2250                 :             :              error.  */
    2251                 :      185461 :           if (fn && DECL_USE_TEMPLATE (fn))
    2252                 :      153923 :             push_tinst_level_loc (fn,
    2253                 :      151140 :                                   (current_instantiation () != actual_inst)
    2254                 :        2783 :                                   ? DECL_SOURCE_LOCATION (fn)
    2255                 :             :                                   : input_location);
    2256                 :      185461 :           fn = NULL;
    2257                 :             : 
    2258                 :      185461 :           if (vec_member (TREE_TYPE (expr), types_memoized))
    2259                 :             :             {
    2260                 :           0 :               if (complain & tf_error)
    2261                 :           0 :                 error ("circular pointer delegation detected");
    2262                 :           0 :               return error_mark_node;
    2263                 :             :             }
    2264                 :             : 
    2265                 :      185461 :           vec_safe_push (types_memoized, TREE_TYPE (expr));
    2266                 :      185461 :           last_rval = expr;
    2267                 :             :         }
    2268                 :             : 
    2269                 :      331120 :       while (current_instantiation () != actual_inst)
    2270                 :      148440 :         pop_tinst_level ();
    2271                 :             : 
    2272                 :      182680 :       if (last_rval == NULL_TREE)
    2273                 :             :         {
    2274                 :           6 :           if (complain & tf_error)
    2275                 :           6 :             error ("base operand of %<->%> has non-pointer type %qT", type);
    2276                 :           6 :           return error_mark_node;
    2277                 :             :         }
    2278                 :             : 
    2279                 :      182674 :       if (TYPE_REF_P (TREE_TYPE (last_rval)))
    2280                 :           0 :         last_rval = convert_from_reference (last_rval);
    2281                 :             :     }
    2282                 :             :   else
    2283                 :             :     {
    2284                 :    25026395 :       last_rval = decay_conversion (expr, complain);
    2285                 :    25026395 :       if (last_rval == error_mark_node)
    2286                 :             :         return error_mark_node;
    2287                 :             :     }
    2288                 :             : 
    2289                 :    25209066 :   if (TYPE_PTR_P (TREE_TYPE (last_rval)))
    2290                 :             :     {
    2291                 :    25209063 :       if (processing_template_decl)
    2292                 :             :         {
    2293                 :    21456560 :           expr = build_min (ARROW_EXPR, TREE_TYPE (TREE_TYPE (last_rval)),
    2294                 :             :                             orig_expr);
    2295                 :    21456560 :           TREE_SIDE_EFFECTS (expr) = TREE_SIDE_EFFECTS (last_rval);
    2296                 :    21456560 :           return expr;
    2297                 :             :         }
    2298                 :             : 
    2299                 :     3752503 :       return cp_build_indirect_ref (loc, last_rval, RO_ARROW, complain);
    2300                 :             :     }
    2301                 :             : 
    2302                 :           3 :   if (complain & tf_error)
    2303                 :             :     {
    2304                 :           3 :       if (types_memoized)
    2305                 :           0 :         error ("result of %<operator->()%> yields non-pointer result");
    2306                 :             :       else
    2307                 :           3 :         error ("base operand of %<->%> is not a pointer");
    2308                 :             :     }
    2309                 :           3 :   return error_mark_node;
    2310                 :             : }
    2311                 :             : 
    2312                 :             : /* Return an expression for "DATUM .* COMPONENT".  DATUM has not
    2313                 :             :    already been checked out to be of aggregate type.  */
    2314                 :             : 
    2315                 :             : tree
    2316                 :      107273 : build_m_component_ref (tree datum, tree component, tsubst_flags_t complain)
    2317                 :             : {
    2318                 :      107273 :   tree ptrmem_type;
    2319                 :      107273 :   tree objtype;
    2320                 :      107273 :   tree type;
    2321                 :      107273 :   tree binfo;
    2322                 :      107273 :   tree ctype;
    2323                 :             : 
    2324                 :      107273 :   datum = mark_lvalue_use (datum);
    2325                 :      107273 :   component = mark_rvalue_use (component);
    2326                 :             : 
    2327                 :      107273 :   if (error_operand_p (datum) || error_operand_p (component))
    2328                 :          82 :     return error_mark_node;
    2329                 :             : 
    2330                 :      107191 :   ptrmem_type = TREE_TYPE (component);
    2331                 :      107191 :   if (!TYPE_PTRMEM_P (ptrmem_type))
    2332                 :             :     {
    2333                 :           6 :       if (complain & tf_error)
    2334                 :           3 :         error ("%qE cannot be used as a member pointer, since it is of "
    2335                 :             :                "type %qT", component, ptrmem_type);
    2336                 :           6 :       return error_mark_node;
    2337                 :             :     }
    2338                 :             : 
    2339                 :      107185 :   objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
    2340                 :      107185 :   if (! MAYBE_CLASS_TYPE_P (objtype))
    2341                 :             :     {
    2342                 :          12 :       if (complain & tf_error)
    2343                 :           0 :         error ("cannot apply member pointer %qE to %qE, which is of "
    2344                 :             :                "non-class type %qT", component, datum, objtype);
    2345                 :          12 :       return error_mark_node;
    2346                 :             :     }
    2347                 :             : 
    2348                 :      107173 :   type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type);
    2349                 :      107173 :   ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type));
    2350                 :             : 
    2351                 :      107173 :   if (!COMPLETE_TYPE_P (ctype))
    2352                 :             :     {
    2353                 :          91 :       if (!same_type_p (ctype, objtype))
    2354                 :           0 :         goto mismatch;
    2355                 :             :       binfo = NULL;
    2356                 :             :     }
    2357                 :             :   else
    2358                 :             :     {
    2359                 :      107082 :       binfo = lookup_base (objtype, ctype, ba_check, NULL, complain);
    2360                 :             : 
    2361                 :      107082 :       if (!binfo)
    2362                 :             :         {
    2363                 :          30 :         mismatch:
    2364                 :          30 :           if (complain & tf_error)
    2365                 :           0 :             error ("pointer to member type %qT incompatible with object "
    2366                 :             :                    "type %qT", type, objtype);
    2367                 :          30 :           return error_mark_node;
    2368                 :             :         }
    2369                 :      107052 :       else if (binfo == error_mark_node)
    2370                 :             :         return error_mark_node;
    2371                 :             :     }
    2372                 :             : 
    2373                 :      107134 :   if (TYPE_PTRDATAMEM_P (ptrmem_type))
    2374                 :             :     {
    2375                 :        1495 :       bool is_lval = real_lvalue_p (datum);
    2376                 :        1495 :       tree ptype;
    2377                 :             : 
    2378                 :             :       /* Compute the type of the field, as described in [expr.ref].
    2379                 :             :          There's no such thing as a mutable pointer-to-member, so
    2380                 :             :          things are not as complex as they are for references to
    2381                 :             :          non-static data members.  */
    2382                 :        1495 :       type = cp_build_qualified_type (type,
    2383                 :        1495 :                                       (cp_type_quals (type)
    2384                 :        1495 :                                        | cp_type_quals (TREE_TYPE (datum))));
    2385                 :             : 
    2386                 :        1495 :       datum = build_address (datum);
    2387                 :             : 
    2388                 :             :       /* Convert object to the correct base.  */
    2389                 :        1495 :       if (binfo)
    2390                 :             :         {
    2391                 :        1462 :           datum = build_base_path (PLUS_EXPR, datum, binfo, 1, complain);
    2392                 :        1462 :           if (datum == error_mark_node)
    2393                 :             :             return error_mark_node;
    2394                 :             :         }
    2395                 :             : 
    2396                 :             :       /* Build an expression for "object + offset" where offset is the
    2397                 :             :          value stored in the pointer-to-data-member.  */
    2398                 :        1495 :       ptype = build_pointer_type (type);
    2399                 :        1495 :       datum = convert (ptype, datum);
    2400                 :        1495 :       if (!processing_template_decl)
    2401                 :        1474 :         datum = build2 (POINTER_PLUS_EXPR, ptype,
    2402                 :             :                         datum, convert_to_ptrofftype (component));
    2403                 :        1495 :       datum = cp_fully_fold (datum);
    2404                 :        1495 :       datum = cp_build_fold_indirect_ref (datum);
    2405                 :        1495 :       if (datum == error_mark_node)
    2406                 :             :         return error_mark_node;
    2407                 :             : 
    2408                 :             :       /* If the object expression was an rvalue, return an rvalue.  */
    2409                 :        1495 :       if (!is_lval)
    2410                 :         115 :         datum = move (datum);
    2411                 :        1495 :       return datum;
    2412                 :             :     }
    2413                 :             :   else
    2414                 :             :     {
    2415                 :             :       /* 5.5/6: In a .* expression whose object expression is an rvalue, the
    2416                 :             :          program is ill-formed if the second operand is a pointer to member
    2417                 :             :          function with ref-qualifier & (for C++20: unless its cv-qualifier-seq
    2418                 :             :          is const). In a .* expression whose object expression is an lvalue,
    2419                 :             :          the program is ill-formed if the second operand is a pointer to member
    2420                 :             :          function with ref-qualifier &&.  */
    2421                 :      105639 :       if (FUNCTION_REF_QUALIFIED (type))
    2422                 :             :         {
    2423                 :         116 :           bool lval = lvalue_p (datum);
    2424                 :         116 :           if (lval && FUNCTION_RVALUE_QUALIFIED (type))
    2425                 :             :             {
    2426                 :           9 :               if (complain & tf_error)
    2427                 :           6 :                 error ("pointer-to-member-function type %qT requires an rvalue",
    2428                 :             :                        ptrmem_type);
    2429                 :           9 :               return error_mark_node;
    2430                 :             :             }
    2431                 :         107 :           else if (!lval && !FUNCTION_RVALUE_QUALIFIED (type))
    2432                 :             :             {
    2433                 :          33 :               if ((type_memfn_quals (type)
    2434                 :          33 :                    & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE))
    2435                 :             :                   != TYPE_QUAL_CONST)
    2436                 :             :                 {
    2437                 :          27 :                   if (complain & tf_error)
    2438                 :          24 :                     error ("pointer-to-member-function type %qT requires "
    2439                 :             :                            "an lvalue", ptrmem_type);
    2440                 :          27 :                   return error_mark_node;
    2441                 :             :                 }
    2442                 :           6 :               else if (cxx_dialect < cxx20)
    2443                 :             :                 {
    2444                 :           4 :                   if (complain & tf_warning_or_error)
    2445                 :           4 :                     pedwarn (input_location, OPT_Wpedantic,
    2446                 :             :                              "pointer-to-member-function type %qT requires "
    2447                 :             :                              "an lvalue before C++20", ptrmem_type);
    2448                 :             :                   else
    2449                 :           0 :                     return error_mark_node;
    2450                 :             :                 }
    2451                 :             :             }
    2452                 :             :         }
    2453                 :      105603 :       return build2 (OFFSET_REF, type, datum, component);
    2454                 :             :     }
    2455                 :             : }
    2456                 :             : 
    2457                 :             : /* Return a tree node for the expression TYPENAME '(' PARMS ')'.  */
    2458                 :             : 
    2459                 :             : static tree
    2460                 :    63260772 : build_functional_cast_1 (location_t loc, tree exp, tree parms,
    2461                 :             :                          tsubst_flags_t complain)
    2462                 :             : {
    2463                 :             :   /* This is either a call to a constructor,
    2464                 :             :      or a C cast in C++'s `functional' notation.  */
    2465                 :             : 
    2466                 :             :   /* The type to which we are casting.  */
    2467                 :    63260772 :   tree type;
    2468                 :             : 
    2469                 :    63260772 :   if (error_operand_p (exp) || parms == error_mark_node)
    2470                 :        1381 :     return error_mark_node;
    2471                 :             : 
    2472                 :    63259391 :   if (TREE_CODE (exp) == TYPE_DECL)
    2473                 :             :     {
    2474                 :    36389194 :       type = TREE_TYPE (exp);
    2475                 :             : 
    2476                 :    36389194 :       if (DECL_ARTIFICIAL (exp))
    2477                 :    24349318 :         cp_handle_deprecated_or_unavailable (type);
    2478                 :             :     }
    2479                 :             :   else
    2480                 :             :     type = exp;
    2481                 :             : 
    2482                 :             :   /* We need to check this explicitly, since value-initialization of
    2483                 :             :      arrays is allowed in other situations.  */
    2484                 :    63259391 :   if (TREE_CODE (type) == ARRAY_TYPE)
    2485                 :             :     {
    2486                 :          12 :       if (complain & tf_error)
    2487                 :           6 :         error_at (loc, "functional cast to array type %qT", type);
    2488                 :          12 :       return error_mark_node;
    2489                 :             :     }
    2490                 :             : 
    2491                 :    63259379 :   if (tree anode = type_uses_auto (type))
    2492                 :             :     {
    2493                 :      164510 :       tree init;
    2494                 :      164510 :       if (CLASS_PLACEHOLDER_TEMPLATE (anode))
    2495                 :             :         init = parms;
    2496                 :             :       /* C++23 auto(x).  */
    2497                 :        5862 :       else if (!AUTO_IS_DECLTYPE (anode)
    2498                 :        5862 :                && list_length (parms) == 1)
    2499                 :             :         {
    2500                 :        5851 :           init = TREE_VALUE (parms);
    2501                 :        5851 :           if (is_constrained_auto (anode))
    2502                 :             :             {
    2503                 :           2 :               if (complain & tf_error)
    2504                 :           2 :                 error_at (loc, "%<auto(x)%> cannot be constrained");
    2505                 :           2 :               return error_mark_node;
    2506                 :             :             }
    2507                 :        5849 :           else if (cxx_dialect < cxx23)
    2508                 :          18 :             pedwarn (loc, OPT_Wc__23_extensions,
    2509                 :             :                      "%<auto(x)%> only available with "
    2510                 :             :                      "%<-std=c++2b%> or %<-std=gnu++2b%>");
    2511                 :             :         }
    2512                 :             :       else
    2513                 :             :         {
    2514                 :          11 :           if (complain & tf_error)
    2515                 :          11 :             error_at (loc, "invalid use of %qT", anode);
    2516                 :          11 :           return error_mark_node;
    2517                 :             :         }
    2518                 :      164497 :       type = do_auto_deduction (type, init, anode, complain,
    2519                 :             :                                 adc_variable_type);
    2520                 :      164497 :       if (type == error_mark_node)
    2521                 :             :         return error_mark_node;
    2522                 :             :     }
    2523                 :             : 
    2524                 :    63259278 :   if (processing_template_decl)
    2525                 :             :     {
    2526                 :    34732102 :       tree t;
    2527                 :             : 
    2528                 :             :       /* Diagnose this even in a template.  We could also try harder
    2529                 :             :          to give all the usual errors when the type and args are
    2530                 :             :          non-dependent...  */
    2531                 :    34732102 :       if (TYPE_REF_P (type) && !parms)
    2532                 :             :         {
    2533                 :           3 :           if (complain & tf_error)
    2534                 :           3 :             error_at (loc, "invalid value-initialization of reference type");
    2535                 :           3 :           return error_mark_node;
    2536                 :             :         }
    2537                 :             : 
    2538                 :    34732099 :       t = build_min (CAST_EXPR, type, parms);
    2539                 :             :       /* We don't know if it will or will not have side effects.  */
    2540                 :    34732099 :       TREE_SIDE_EFFECTS (t) = 1;
    2541                 :    34732099 :       return t;
    2542                 :             :     }
    2543                 :             : 
    2544                 :    28527176 :   if (! MAYBE_CLASS_TYPE_P (type))
    2545                 :             :     {
    2546                 :    26070915 :       if (parms == NULL_TREE)
    2547                 :             :         {
    2548                 :      482422 :           if (VOID_TYPE_P (type))
    2549                 :        4033 :             return void_node;
    2550                 :      478389 :           return build_value_init (cv_unqualified (type), complain);
    2551                 :             :         }
    2552                 :             : 
    2553                 :             :       /* This must build a C cast.  */
    2554                 :    25588493 :       parms = build_x_compound_expr_from_list (parms, ELK_FUNC_CAST, complain);
    2555                 :    25588493 :       return cp_build_c_cast (loc, type, parms, complain);
    2556                 :             :     }
    2557                 :             : 
    2558                 :             :   /* Prepare to evaluate as a call to a constructor.  If this expression
    2559                 :             :      is actually used, for example,
    2560                 :             : 
    2561                 :             :      return X (arg1, arg2, ...);
    2562                 :             : 
    2563                 :             :      then the slot being initialized will be filled in.  */
    2564                 :             : 
    2565                 :     2456261 :   if (!complete_type_or_maybe_complain (type, NULL_TREE, complain))
    2566                 :          18 :     return error_mark_node;
    2567                 :     2456240 :   if (abstract_virtuals_error (ACU_CAST, type, complain))
    2568                 :          15 :     return error_mark_node;
    2569                 :             : 
    2570                 :             :   /* [expr.type.conv]
    2571                 :             : 
    2572                 :             :      If the expression list is a single-expression, the type
    2573                 :             :      conversion is equivalent (in definedness, and if defined in
    2574                 :             :      meaning) to the corresponding cast expression.  */
    2575                 :     2456225 :   if (parms && TREE_CHAIN (parms) == NULL_TREE)
    2576                 :     1239727 :     return cp_build_c_cast (loc, type, TREE_VALUE (parms), complain);
    2577                 :             : 
    2578                 :             :   /* [expr.type.conv]
    2579                 :             : 
    2580                 :             :      The expression T(), where T is a simple-type-specifier for a
    2581                 :             :      non-array complete object type or the (possibly cv-qualified)
    2582                 :             :      void type, creates an rvalue of the specified type, which is
    2583                 :             :      value-initialized.  */
    2584                 :             : 
    2585                 :     1216498 :   if (parms == NULL_TREE)
    2586                 :             :     {
    2587                 :      875789 :       exp = build_value_init (type, complain);
    2588                 :      875789 :       exp = get_target_expr (exp, complain);
    2589                 :      875789 :       return exp;
    2590                 :             :     }
    2591                 :             : 
    2592                 :             :   /* Call the constructor.  */
    2593                 :      340709 :   releasing_vec parmvec;
    2594                 :     1058142 :   for (; parms != NULL_TREE; parms = TREE_CHAIN (parms))
    2595                 :      717433 :     vec_safe_push (parmvec, TREE_VALUE (parms));
    2596                 :      340709 :   exp = build_special_member_call (NULL_TREE, complete_ctor_identifier,
    2597                 :             :                                    &parmvec, type, LOOKUP_NORMAL, complain);
    2598                 :             : 
    2599                 :      340709 :   if (exp == error_mark_node)
    2600                 :             :     return error_mark_node;
    2601                 :             : 
    2602                 :      340694 :   return build_cplus_new (type, exp, complain);
    2603                 :      340709 : }
    2604                 :             : 
    2605                 :             : tree
    2606                 :    63260772 : build_functional_cast (location_t loc, tree exp, tree parms,
    2607                 :             :                        tsubst_flags_t complain)
    2608                 :             : {
    2609                 :    63260772 :   tree result = build_functional_cast_1 (loc, exp, parms, complain);
    2610                 :    63260769 :   protected_set_expr_location (result, loc);
    2611                 :    63260769 :   return result;
    2612                 :             : }
    2613                 :             : 
    2614                 :             : 
    2615                 :             : /* Add new exception specifier SPEC, to the LIST we currently have.
    2616                 :             :    If it's already in LIST then do nothing.
    2617                 :             :    Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
    2618                 :             :    know what we're doing.  */
    2619                 :             : 
    2620                 :             : tree
    2621                 :       14980 : add_exception_specifier (tree list, tree spec, tsubst_flags_t complain)
    2622                 :             : {
    2623                 :       14980 :   bool ok;
    2624                 :       14980 :   tree core = spec;
    2625                 :       14980 :   bool is_ptr;
    2626                 :       14980 :   diagnostic_t diag_type = DK_UNSPECIFIED; /* none */
    2627                 :             : 
    2628                 :       14980 :   if (spec == error_mark_node)
    2629                 :             :     return list;
    2630                 :             : 
    2631                 :       15005 :   gcc_assert (spec && (!list || TREE_VALUE (list)));
    2632                 :             : 
    2633                 :             :   /* [except.spec] 1, type in an exception specifier shall not be
    2634                 :             :      incomplete, or pointer or ref to incomplete other than pointer
    2635                 :             :      to cv void.  */
    2636                 :       14966 :   is_ptr = TYPE_PTR_P (core);
    2637                 :       14966 :   if (is_ptr || TYPE_REF_P (core))
    2638                 :          19 :     core = TREE_TYPE (core);
    2639                 :       14966 :   if (complain < 0)
    2640                 :             :     ok = true;
    2641                 :        1271 :   else if (VOID_TYPE_P (core))
    2642                 :             :     ok = is_ptr;
    2643                 :        1263 :   else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
    2644                 :             :     ok = true;
    2645                 :        1253 :   else if (processing_template_decl)
    2646                 :             :     ok = true;
    2647                 :        1216 :   else if (!verify_type_context (input_location, TCTX_EXCEPTIONS, core,
    2648                 :             :                                  !(complain & tf_error)))
    2649                 :           0 :     return error_mark_node;
    2650                 :             :   else
    2651                 :             :     {
    2652                 :        1216 :       ok = true;
    2653                 :             :       /* 15.4/1 says that types in an exception specifier must be complete,
    2654                 :             :          but it seems more reasonable to only require this on definitions
    2655                 :             :          and calls.  So just give a pedwarn at this point; we will give an
    2656                 :             :          error later if we hit one of those two cases.  */
    2657                 :        1216 :       if (!COMPLETE_TYPE_P (complete_type (core)))
    2658                 :       14966 :         diag_type = DK_PEDWARN; /* pedwarn */
    2659                 :             :     }
    2660                 :             : 
    2661                 :       14966 :   if (ok)
    2662                 :             :     {
    2663                 :             :       tree probe;
    2664                 :             : 
    2665                 :       15005 :       for (probe = list; probe; probe = TREE_CHAIN (probe))
    2666                 :          47 :         if (same_type_p (TREE_VALUE (probe), spec))
    2667                 :             :           break;
    2668                 :       14960 :       if (!probe)
    2669                 :       14958 :         list = tree_cons (NULL_TREE, spec, list);
    2670                 :             :     }
    2671                 :             :   else
    2672                 :             :     diag_type = DK_ERROR; /* error */
    2673                 :             : 
    2674                 :       14960 :   if (diag_type != DK_UNSPECIFIED
    2675                 :          12 :       && (complain & tf_warning_or_error))
    2676                 :          10 :     cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
    2677                 :             : 
    2678                 :             :   return list;
    2679                 :             : }
    2680                 :             : 
    2681                 :             : /* Like nothrow_spec_p, but don't abort on deferred noexcept.  */
    2682                 :             : 
    2683                 :             : static bool
    2684                 :     3799482 : nothrow_spec_p_uninst (const_tree spec)
    2685                 :             : {
    2686                 :     7598964 :   if (DEFERRED_NOEXCEPT_SPEC_P (spec))
    2687                 :             :     return false;
    2688                 :     3799480 :   return nothrow_spec_p (spec);
    2689                 :             : }
    2690                 :             : 
    2691                 :             : /* Combine the two exceptions specifier lists LIST and ADD, and return
    2692                 :             :    their union.  */
    2693                 :             : 
    2694                 :             : tree
    2695                 :    11130137 : merge_exception_specifiers (tree list, tree add)
    2696                 :             : {
    2697                 :    11130137 :   tree noex, orig_list;
    2698                 :             : 
    2699                 :    11130137 :   if (list == error_mark_node || add == error_mark_node)
    2700                 :             :     return error_mark_node;
    2701                 :             : 
    2702                 :             :   /* No exception-specifier or noexcept(false) are less strict than
    2703                 :             :      anything else.  Prefer the newer variant (LIST).  */
    2704                 :    11130137 :   if (!list || list == noexcept_false_spec)
    2705                 :             :     return list;
    2706                 :     3865722 :   else if (!add || add == noexcept_false_spec)
    2707                 :             :     return add;
    2708                 :             : 
    2709                 :             :   /* noexcept(true) and throw() are stricter than anything else.
    2710                 :             :      As above, prefer the more recent one (LIST).  */
    2711                 :     3761209 :   if (nothrow_spec_p_uninst (add))
    2712                 :             :     return list;
    2713                 :             : 
    2714                 :             :   /* Two implicit noexcept specs (e.g. on a destructor) are equivalent.  */
    2715                 :       38275 :   if (UNEVALUATED_NOEXCEPT_SPEC_P (add)
    2716                 :           2 :       && UNEVALUATED_NOEXCEPT_SPEC_P (list))
    2717                 :             :     return list;
    2718                 :             :   /* We should have instantiated other deferred noexcept specs by now.  */
    2719                 :       38273 :   gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (add));
    2720                 :             : 
    2721                 :       38273 :   if (nothrow_spec_p_uninst (list))
    2722                 :             :     return add;
    2723                 :       38270 :   noex = TREE_PURPOSE (list);
    2724                 :       38270 :   gcc_checking_assert (!TREE_PURPOSE (add)
    2725                 :             :                        || errorcount || !flag_exceptions
    2726                 :             :                        || cp_tree_equal (noex, TREE_PURPOSE (add)));
    2727                 :             : 
    2728                 :             :   /* Combine the dynamic-exception-specifiers, if any.  */
    2729                 :             :   orig_list = list;
    2730                 :       76576 :   for (; add && TREE_VALUE (add); add = TREE_CHAIN (add))
    2731                 :             :     {
    2732                 :          41 :       tree spec = TREE_VALUE (add);
    2733                 :             :       tree probe;
    2734                 :             : 
    2735                 :          76 :       for (probe = orig_list; probe && TREE_VALUE (probe);
    2736                 :          12 :            probe = TREE_CHAIN (probe))
    2737                 :          35 :         if (same_type_p (TREE_VALUE (probe), spec))
    2738                 :             :           break;
    2739                 :          29 :       if (!probe)
    2740                 :             :         {
    2741                 :           6 :           spec = build_tree_list (NULL_TREE, spec);
    2742                 :           6 :           TREE_CHAIN (spec) = list;
    2743                 :           6 :           list = spec;
    2744                 :             :         }
    2745                 :             :     }
    2746                 :             : 
    2747                 :             :   /* Keep the noexcept-specifier at the beginning of the list.  */
    2748                 :       38270 :   if (noex != TREE_PURPOSE (list))
    2749                 :           0 :     list = tree_cons (noex, TREE_VALUE (list), TREE_CHAIN (list));
    2750                 :             : 
    2751                 :             :   return list;
    2752                 :             : }
    2753                 :             : 
    2754                 :             : /* Subroutine of build_call.  Ensure that each of the types in the
    2755                 :             :    exception specification is complete.  Technically, 15.4/1 says that
    2756                 :             :    they need to be complete when we see a declaration of the function,
    2757                 :             :    but we should be able to get away with only requiring this when the
    2758                 :             :    function is defined or called.  See also add_exception_specifier.  */
    2759                 :             : 
    2760                 :             : void
    2761                 :   105279640 : require_complete_eh_spec_types (tree fntype, tree decl)
    2762                 :             : {
    2763                 :   105279640 :   tree raises;
    2764                 :             :   /* Don't complain about calls to op new.  */
    2765                 :   105279640 :   if (decl && DECL_ARTIFICIAL (decl))
    2766                 :             :     return;
    2767                 :   145281889 :   for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
    2768                 :    49366267 :        raises = TREE_CHAIN (raises))
    2769                 :             :     {
    2770                 :    49366267 :       tree type = TREE_VALUE (raises);
    2771                 :    49366267 :       if (type && !COMPLETE_TYPE_P (type))
    2772                 :             :         {
    2773                 :           1 :           if (decl)
    2774                 :           1 :             error
    2775                 :           1 :               ("call to function %qD which throws incomplete type %q#T",
    2776                 :             :                decl, type);
    2777                 :             :           else
    2778                 :           0 :             error ("call to function which throws incomplete type %q#T",
    2779                 :             :                    decl);
    2780                 :             :         }
    2781                 :             :     }
    2782                 :             : }
    2783                 :             : 
    2784                 :             : /* Record that any TARGET_EXPR in T are going to be elided in
    2785                 :             :    cp_gimplify_init_expr (or sooner).  */
    2786                 :             : 
    2787                 :             : void
    2788                 :    94389381 : set_target_expr_eliding (tree t)
    2789                 :             : {
    2790                 :    96140805 :   if (!t)
    2791                 :             :     return;
    2792                 :    95512584 :   switch (TREE_CODE (t))
    2793                 :             :     {
    2794                 :     8333406 :     case TARGET_EXPR:
    2795                 :     8333406 :       TARGET_EXPR_ELIDING_P (t) = true;
    2796                 :     8333406 :       break;
    2797                 :      814993 :     case COMPOUND_EXPR:
    2798                 :      814993 :       set_target_expr_eliding (TREE_OPERAND (t, 1));
    2799                 :      814993 :       break;
    2800                 :      936431 :     case COND_EXPR:
    2801                 :      936431 :       set_target_expr_eliding (TREE_OPERAND (t, 1));
    2802                 :      936431 :       set_target_expr_eliding (TREE_OPERAND (t, 2));
    2803                 :      936431 :       break;
    2804                 :             : 
    2805                 :             :     default:
    2806                 :             :       break;
    2807                 :             :     }
    2808                 :             : }
    2809                 :             : 
    2810                 :             : /* Call the above in the process of building an INIT_EXPR.  */
    2811                 :             : 
    2812                 :             : tree
    2813                 :    48735469 : cp_build_init_expr (location_t loc, tree target, tree init)
    2814                 :             : {
    2815                 :    48735469 :   set_target_expr_eliding (init);
    2816                 :    48735469 :   tree ie = build2_loc (loc, INIT_EXPR, TREE_TYPE (target),
    2817                 :             :                         target, init);
    2818                 :    48735469 :   TREE_SIDE_EFFECTS (ie) = true;
    2819                 :    48735469 :   return ie;
    2820                 :             : }
        

Generated by: LCOV version 2.1-beta

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,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.