LCOV - code coverage report
Current view: top level - gcc/cp - typeck2.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 995 1080 92.1 %
Date: 2020-03-28 11:57:23 Functions: 38 38 100.0 %
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-2020 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                 :         50 : error_not_base_type (tree basetype, tree type)
      48                 :            : {
      49                 :         50 :   if (TREE_CODE (basetype) == FUNCTION_DECL)
      50                 :          0 :     basetype = DECL_CONTEXT (basetype);
      51                 :         50 :   error ("type %qT is not a base type for type %qT", basetype, type);
      52                 :         50 :   return error_mark_node;
      53                 :            : }
      54                 :            : 
      55                 :            : tree
      56                 :        978 : binfo_or_else (tree base, tree type)
      57                 :            : {
      58                 :        978 :   tree binfo = lookup_base (type, base, ba_unique,
      59                 :            :                             NULL, tf_warning_or_error);
      60                 :            : 
      61                 :        978 :   if (binfo == error_mark_node)
      62                 :            :     return NULL_TREE;
      63                 :        978 :   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                 :        109 : 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                 :        109 :   if (VAR_P (arg)
     103                 :         17 :       && DECL_LANG_SPECIFIC (arg)
     104                 :          0 :       && DECL_IN_AGGR_P (arg)
     105                 :        109 :       && !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                 :        109 :   else if (INDIRECT_REF_P (arg)
     113                 :         15 :            && TYPE_REF_P (TREE_TYPE (TREE_OPERAND (arg, 0)))
     114                 :        116 :            && (VAR_P (TREE_OPERAND (arg, 0))
     115                 :          4 :                || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL))
     116                 :          3 :     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                 :        106 :     readonly_error (loc, arg, errstring);
     124                 :        109 : }
     125                 :            : 
     126                 :            : /* Structure that holds information about declarations whose type was
     127                 :            :    incomplete and we could not check whether it was abstract or not.  */
     128                 :            : 
     129                 :            : struct GTY((chain_next ("%h.next"), for_user)) pending_abstract_type {
     130                 :            :   /* Declaration which we are checking for abstractness. It is either
     131                 :            :      a DECL node, or an IDENTIFIER_NODE if we do not have a full
     132                 :            :      declaration available.  */
     133                 :            :   tree decl;
     134                 :            : 
     135                 :            :   /* Type which will be checked for abstractness.  */
     136                 :            :   tree type;
     137                 :            : 
     138                 :            :   /* Kind of use in an unnamed declarator.  */
     139                 :            :   enum abstract_class_use use;
     140                 :            : 
     141                 :            :   /* Position of the declaration. This is only needed for IDENTIFIER_NODEs,
     142                 :            :      because DECLs already carry locus information.  */
     143                 :            :   location_t locus;
     144                 :            : 
     145                 :            :   /* Link to the next element in list.  */
     146                 :            :   struct pending_abstract_type* next;
     147                 :            : };
     148                 :            : 
     149                 :            : struct abstract_type_hasher : ggc_ptr_hash<pending_abstract_type>
     150                 :            : {
     151                 :            :   typedef tree compare_type;
     152                 :            :   static hashval_t hash (pending_abstract_type *);
     153                 :            :   static bool equal (pending_abstract_type *, tree);
     154                 :            : };
     155                 :            : 
     156                 :            : /* Compute the hash value of the node VAL. This function is used by the
     157                 :            :    hash table abstract_pending_vars.  */
     158                 :            : 
     159                 :            : hashval_t
     160                 :   69579000 : abstract_type_hasher::hash (pending_abstract_type *pat)
     161                 :            : {
     162                 :   69579000 :   return (hashval_t) TYPE_UID (pat->type);
     163                 :            : }
     164                 :            : 
     165                 :            : 
     166                 :            : /* Compare node VAL1 with the type VAL2. This function is used by the
     167                 :            :    hash table abstract_pending_vars.  */
     168                 :            : 
     169                 :            : bool
     170                 :   88865600 : abstract_type_hasher::equal (pending_abstract_type *pat1, tree type2)
     171                 :            : {
     172                 :   88865600 :   return (pat1->type == type2);
     173                 :            : }
     174                 :            : 
     175                 :            : /* Hash table that maintains pending_abstract_type nodes, for which we still
     176                 :            :    need to check for type abstractness.  The key of the table is the type
     177                 :            :    of the declaration.  */
     178                 :            : static GTY (()) hash_table<abstract_type_hasher> *abstract_pending_vars = NULL;
     179                 :            : 
     180                 :            : static int abstract_virtuals_error_sfinae (tree, tree, abstract_class_use, tsubst_flags_t);
     181                 :            : 
     182                 :            : /* This function is called after TYPE is completed, and will check if there
     183                 :            :    are pending declarations for which we still need to verify the abstractness
     184                 :            :    of TYPE, and emit a diagnostic (through abstract_virtuals_error) if TYPE
     185                 :            :    turned out to be incomplete.  */
     186                 :            : 
     187                 :            : void
     188                 :   14242200 : complete_type_check_abstract (tree type)
     189                 :            : {
     190                 :   14242200 :   struct pending_abstract_type *pat;
     191                 :   14242200 :   location_t cur_loc = input_location;
     192                 :            : 
     193                 :   14242200 :   gcc_assert (COMPLETE_TYPE_P (type));
     194                 :            : 
     195                 :   14242200 :   if (!abstract_pending_vars)
     196                 :            :     return;
     197                 :            : 
     198                 :            :   /* Retrieve the list of pending declarations for this type.  */
     199                 :   13860200 :   pending_abstract_type **slot
     200                 :   13860200 :     = abstract_pending_vars->find_slot_with_hash (type, TYPE_UID (type),
     201                 :            :                                                   NO_INSERT);
     202                 :   13860200 :   if (!slot)
     203                 :            :     return;
     204                 :     173744 :   pat = *slot;
     205                 :     173744 :   gcc_assert (pat);
     206                 :            : 
     207                 :            :   /* If the type is not abstract, do not do anything.  */
     208                 :     173744 :   if (CLASSTYPE_PURE_VIRTUALS (type))
     209                 :            :     {
     210                 :            :       struct pending_abstract_type *prev = 0, *next;
     211                 :            : 
     212                 :            :       /* Reverse the list to emit the errors in top-down order.  */
     213                 :         60 :       for (; pat; pat = next)
     214                 :            :         {
     215                 :         48 :           next = pat->next;
     216                 :         48 :           pat->next = prev;
     217                 :         48 :           prev = pat;
     218                 :            :         }
     219                 :            :       pat = prev;
     220                 :            : 
     221                 :            :       /* Go through the list, and call abstract_virtuals_error for each
     222                 :            :         element: it will issue a diagnostic if the type is abstract.  */
     223                 :         60 :       while (pat)
     224                 :            :         {
     225                 :         48 :           gcc_assert (type == pat->type);
     226                 :            : 
     227                 :            :           /* Tweak input_location so that the diagnostic appears at the correct
     228                 :            :             location. Notice that this is only needed if the decl is an
     229                 :            :             IDENTIFIER_NODE.  */
     230                 :         48 :           input_location = pat->locus;
     231                 :         48 :           abstract_virtuals_error_sfinae (pat->decl, pat->type, pat->use,
     232                 :            :                                           tf_warning_or_error);
     233                 :         48 :           pat = pat->next;
     234                 :            :         }
     235                 :            :     }
     236                 :            : 
     237                 :     173744 :   abstract_pending_vars->clear_slot (slot);
     238                 :            : 
     239                 :     173744 :   input_location = cur_loc;
     240                 :            : }
     241                 :            : 
     242                 :            : 
     243                 :            : /* If TYPE has abstract virtual functions, issue an error about trying
     244                 :            :    to create an object of that type.  DECL is the object declared, or
     245                 :            :    NULL_TREE if the declaration is unavailable, in which case USE specifies
     246                 :            :    the kind of invalid use.  Returns 1 if an error occurred; zero if
     247                 :            :    all was well.  */
     248                 :            : 
     249                 :            : static int
     250                 :  130388000 : abstract_virtuals_error_sfinae (tree decl, tree type, abstract_class_use use,
     251                 :            :                                 tsubst_flags_t complain)
     252                 :            : {
     253                 :  130388000 :   vec<tree, va_gc> *pure;
     254                 :            : 
     255                 :            :   /* This function applies only to classes. Any other entity can never
     256                 :            :      be abstract.  */
     257                 :  130388000 :   if (!CLASS_TYPE_P (type))
     258                 :            :     return 0;
     259                 :   14929200 :   type = TYPE_MAIN_VARIANT (type);
     260                 :            : 
     261                 :            : #if 0
     262                 :            :   /* Instantiation here seems to be required by the standard,
     263                 :            :      but breaks e.g. boost::bind.  FIXME!  */
     264                 :            :   /* In SFINAE, non-N3276 context, force instantiation.  */
     265                 :            :   if (!(complain & (tf_error|tf_decltype)))
     266                 :            :     complete_type (type);
     267                 :            : #endif
     268                 :            : 
     269                 :            :   /* If the type is incomplete, we register it within a hash table,
     270                 :            :      so that we can check again once it is completed. This makes sense
     271                 :            :      only for objects for which we have a declaration or at least a
     272                 :            :      name.  */
     273                 :   14929200 :   if (!COMPLETE_TYPE_P (type) && (complain & tf_error))
     274                 :            :     {
     275                 :    3145620 :       struct pending_abstract_type *pat;
     276                 :            : 
     277                 :    3145620 :       gcc_assert (!decl || DECL_P (decl) || identifier_p (decl));
     278                 :            : 
     279                 :    3145620 :       if (!abstract_pending_vars)
     280                 :       9384 :         abstract_pending_vars
     281                 :       9384 :           = hash_table<abstract_type_hasher>::create_ggc (31);
     282                 :            : 
     283                 :    3145620 :       pending_abstract_type **slot
     284                 :    3145620 :         = abstract_pending_vars->find_slot_with_hash (type, TYPE_UID (type),
     285                 :            :                                                       INSERT);
     286                 :            : 
     287                 :    3145620 :       pat = ggc_alloc<pending_abstract_type> ();
     288                 :    3145620 :       pat->type = type;
     289                 :    3145620 :       pat->decl = decl;
     290                 :    3145620 :       pat->use = use;
     291                 :     590565 :       pat->locus = ((decl && DECL_P (decl))
     292                 :    3736190 :                     ? DECL_SOURCE_LOCATION (decl)
     293                 :            :                     : input_location);
     294                 :            : 
     295                 :    3145620 :       pat->next = *slot;
     296                 :    3145620 :       *slot = pat;
     297                 :            : 
     298                 :    3145620 :       return 0;
     299                 :            :     }
     300                 :            : 
     301                 :   11783600 :   if (!TYPE_SIZE (type))
     302                 :            :     /* TYPE is being defined, and during that time
     303                 :            :        CLASSTYPE_PURE_VIRTUALS holds the inline friends.  */
     304                 :            :     return 0;
     305                 :            : 
     306                 :   11204700 :   pure = CLASSTYPE_PURE_VIRTUALS (type);
     307                 :   11204700 :   if (!pure)
     308                 :            :     return 0;
     309                 :            : 
     310                 :        183 :   if (!(complain & tf_error))
     311                 :            :     return 1;
     312                 :            : 
     313                 :        146 :   auto_diagnostic_group d;
     314                 :        146 :   if (decl)
     315                 :            :     {
     316                 :        111 :       if (VAR_P (decl))
     317                 :          7 :         error ("cannot declare variable %q+D to be of abstract "
     318                 :            :                "type %qT", decl, type);
     319                 :        104 :       else if (TREE_CODE (decl) == PARM_DECL)
     320                 :            :         {
     321                 :         24 :           if (DECL_NAME (decl))
     322                 :         24 :             error ("cannot declare parameter %q+D to be of abstract type %qT",
     323                 :            :                    decl, type);
     324                 :            :           else
     325                 :          0 :             error ("cannot declare parameter to be of abstract type %qT",
     326                 :            :                    type);
     327                 :            :         }
     328                 :         80 :       else if (TREE_CODE (decl) == FIELD_DECL)
     329                 :          4 :         error ("cannot declare field %q+D to be of abstract type %qT",
     330                 :            :                decl, type);
     331                 :         76 :       else if (TREE_CODE (decl) == FUNCTION_DECL
     332                 :         76 :                && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
     333                 :          0 :         error ("invalid abstract return type for member function %q+#D", decl);
     334                 :         76 :       else if (TREE_CODE (decl) == FUNCTION_DECL)
     335                 :          0 :         error ("invalid abstract return type for function %q+#D", decl);
     336                 :         76 :       else if (identifier_p (decl))
     337                 :            :         /* Here we do not have location information.  */
     338                 :         76 :         error ("invalid abstract type %qT for %qE", type, decl);
     339                 :            :       else
     340                 :          0 :         error ("invalid abstract type for %q+D", decl);
     341                 :            :     }
     342                 :         35 :   else switch (use)
     343                 :            :     {
     344                 :          4 :     case ACU_ARRAY:
     345                 :          4 :       error ("creating array of %qT, which is an abstract class type", type);
     346                 :          4 :       break;
     347                 :          0 :     case ACU_CAST:
     348                 :          0 :       error ("invalid cast to abstract class type %qT", type);
     349                 :          0 :       break;
     350                 :          0 :     case ACU_NEW:
     351                 :          0 :       error ("invalid new-expression of abstract class type %qT", type);
     352                 :          0 :       break;
     353                 :         12 :     case ACU_RETURN:
     354                 :         12 :       error ("invalid abstract return type %qT", type);
     355                 :         12 :       break;
     356                 :          0 :     case ACU_PARM:
     357                 :          0 :       error ("invalid abstract parameter type %qT", type);
     358                 :          0 :       break;
     359                 :          4 :     case ACU_THROW:
     360                 :          4 :       error ("expression of abstract class type %qT cannot "
     361                 :            :              "be used in throw-expression", type);
     362                 :          4 :       break;
     363                 :          3 :     case ACU_CATCH:
     364                 :          3 :       error ("cannot declare %<catch%> parameter to be of abstract "
     365                 :            :              "class type %qT", type);
     366                 :          3 :       break;
     367                 :         12 :     default:
     368                 :         12 :       error ("cannot allocate an object of abstract type %qT", type);
     369                 :            :     }
     370                 :            : 
     371                 :            :   /* Only go through this once.  */
     372                 :        146 :   if (pure->length ())
     373                 :            :     {
     374                 :         53 :       unsigned ix;
     375                 :         53 :       tree fn;
     376                 :            : 
     377                 :         53 :       inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
     378                 :            :               "  because the following virtual functions are pure within %qT:",
     379                 :            :               type);
     380                 :            : 
     381                 :        106 :       FOR_EACH_VEC_ELT (*pure, ix, fn)
     382                 :        106 :         if (! DECL_CLONED_FUNCTION_P (fn)
     383                 :         53 :             || DECL_COMPLETE_DESTRUCTOR_P (fn))
     384                 :         53 :           inform (DECL_SOURCE_LOCATION (fn), "    %#qD", fn);
     385                 :            : 
     386                 :            :       /* Now truncate the vector.  This leaves it non-null, so we know
     387                 :            :          there are pure virtuals, but empty so we don't list them out
     388                 :            :          again.  */
     389                 :         53 :       pure->truncate (0);
     390                 :            :     }
     391                 :            : 
     392                 :        146 :   return 1;
     393                 :            : }
     394                 :            : 
     395                 :            : int
     396                 :   56640400 : abstract_virtuals_error_sfinae (tree decl, tree type, tsubst_flags_t complain)
     397                 :            : {
     398                 :   56640400 :   return abstract_virtuals_error_sfinae (decl, type, ACU_UNKNOWN, complain);
     399                 :            : }
     400                 :            : 
     401                 :            : int
     402                 :   73747600 : abstract_virtuals_error_sfinae (abstract_class_use use, tree type,
     403                 :            :                                 tsubst_flags_t complain)
     404                 :            : {
     405                 :   73747600 :   return abstract_virtuals_error_sfinae (NULL_TREE, type, use, complain);
     406                 :            : }
     407                 :            : 
     408                 :            : 
     409                 :            : /* Wrapper for the above function in the common case of wanting errors.  */
     410                 :            : 
     411                 :            : int
     412                 :   53017100 : abstract_virtuals_error (tree decl, tree type)
     413                 :            : {
     414                 :   53017100 :   return abstract_virtuals_error_sfinae (decl, type, tf_warning_or_error);
     415                 :            : }
     416                 :            : 
     417                 :            : int
     418                 :   15112300 : abstract_virtuals_error (abstract_class_use use, tree type)
     419                 :            : {
     420                 :   15112300 :   return abstract_virtuals_error_sfinae (use, type, tf_warning_or_error);
     421                 :            : }
     422                 :            : 
     423                 :            : /* Print an inform about the declaration of the incomplete type TYPE.  */
     424                 :            : 
     425                 :            : void
     426                 :        680 : cxx_incomplete_type_inform (const_tree type)
     427                 :            : {
     428                 :        680 :   if (!TYPE_MAIN_DECL (type))
     429                 :            :     return;
     430                 :            : 
     431                 :        677 :   location_t loc = DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type));
     432                 :        677 :   tree ptype = strip_top_quals (CONST_CAST_TREE (type));
     433                 :            : 
     434                 :        677 :   if (current_class_type
     435                 :        290 :       && TYPE_BEING_DEFINED (current_class_type)
     436                 :        904 :       && same_type_p (ptype, current_class_type))
     437                 :        101 :     inform (loc, "definition of %q#T is not complete until "
     438                 :            :             "the closing brace", ptype);
     439                 :       1152 :   else if (!TYPE_TEMPLATE_INFO (ptype))
     440                 :        486 :     inform (loc, "forward declaration of %q#T", ptype);
     441                 :            :   else
     442                 :         90 :     inform (loc, "declaration of %q#T", ptype);
     443                 :            : }
     444                 :            : 
     445                 :            : /* Print an error message for invalid use of an incomplete type.
     446                 :            :    VALUE is the expression that was used (or 0 if that isn't known)
     447                 :            :    and TYPE is the type that was invalid.  DIAG_KIND indicates the
     448                 :            :    type of diagnostic (see diagnostic.def).  */
     449                 :            : 
     450                 :            : void
     451                 :        850 : cxx_incomplete_type_diagnostic (location_t loc, const_tree value,
     452                 :            :                                 const_tree type, diagnostic_t diag_kind)
     453                 :            : {
     454                 :        850 :   bool is_decl = false, complained = false;
     455                 :            : 
     456                 :        850 :   gcc_assert (diag_kind == DK_WARNING 
     457                 :            :               || diag_kind == DK_PEDWARN 
     458                 :            :               || diag_kind == DK_ERROR);
     459                 :            : 
     460                 :            :   /* Avoid duplicate error message.  */
     461                 :        850 :   if (TREE_CODE (type) == ERROR_MARK)
     462                 :            :     return;
     463                 :            : 
     464                 :        850 :   if (value)
     465                 :            :     {
     466                 :        413 :       STRIP_ANY_LOCATION_WRAPPER (value);
     467                 :            : 
     468                 :        413 :       if (VAR_P (value)
     469                 :        355 :           || TREE_CODE (value) == PARM_DECL
     470                 :        305 :           || TREE_CODE (value) == FIELD_DECL)
     471                 :            :         {
     472                 :        131 :           complained = emit_diagnostic (diag_kind, DECL_SOURCE_LOCATION (value), 0,
     473                 :            :                                         "%qD has incomplete type", value);
     474                 :        131 :           is_decl = true;
     475                 :            :         }
     476                 :            :     }
     477                 :        850 :  retry:
     478                 :            :   /* We must print an error message.  Be clever about what it says.  */
     479                 :            : 
     480                 :        856 :   switch (TREE_CODE (type))
     481                 :            :     {
     482                 :        557 :     case RECORD_TYPE:
     483                 :        557 :     case UNION_TYPE:
     484                 :        557 :     case ENUMERAL_TYPE:
     485                 :        557 :       if (!is_decl)
     486                 :        450 :         complained = emit_diagnostic (diag_kind, loc, 0,
     487                 :            :                                       "invalid use of incomplete type %q#T",
     488                 :            :                                       type);
     489                 :        557 :       if (complained)
     490                 :        551 :         cxx_incomplete_type_inform (type);
     491                 :            :       break;
     492                 :            : 
     493                 :         12 :     case VOID_TYPE:
     494                 :         12 :       emit_diagnostic (diag_kind, loc, 0,
     495                 :            :                        "invalid use of %qT", type);
     496                 :         12 :       break;
     497                 :            : 
     498                 :         50 :     case ARRAY_TYPE:
     499                 :         50 :       if (TYPE_DOMAIN (type))
     500                 :            :         {
     501                 :          6 :           type = TREE_TYPE (type);
     502                 :          6 :           goto retry;
     503                 :            :         }
     504                 :         44 :       emit_diagnostic (diag_kind, loc, 0,
     505                 :            :                        "invalid use of array with unspecified bounds");
     506                 :         44 :       break;
     507                 :            : 
     508                 :         89 :     case OFFSET_TYPE:
     509                 :         89 :     bad_member:
     510                 :         89 :       {
     511                 :         89 :         tree member = TREE_OPERAND (value, 1);
     512                 :         89 :         if (is_overloaded_fn (member))
     513                 :         89 :           member = get_first_fn (member);
     514                 :            : 
     515                 :         89 :         if (DECL_FUNCTION_MEMBER_P (member)
     516                 :         89 :             && ! flag_ms_extensions)
     517                 :            :           {
     518                 :        170 :             gcc_rich_location richloc (loc);
     519                 :            :             /* If "member" has no arguments (other than "this"), then
     520                 :            :                add a fix-it hint.  */
     521                 :         85 :             if (type_num_arguments (TREE_TYPE (member)) == 1)
     522                 :         77 :               richloc.add_fixit_insert_after ("()");
     523                 :         85 :             emit_diagnostic (diag_kind, &richloc, 0,
     524                 :            :                              "invalid use of member function %qD "
     525                 :            :                              "(did you forget the %<()%> ?)", member);
     526                 :            :           }
     527                 :            :         else
     528                 :          4 :           emit_diagnostic (diag_kind, loc, 0,
     529                 :            :                            "invalid use of member %qD "
     530                 :            :                            "(did you forget the %<&%> ?)", member);
     531                 :            :       }
     532                 :            :       break;
     533                 :            : 
     534                 :         25 :     case TEMPLATE_TYPE_PARM:
     535                 :         25 :       if (is_auto (type))
     536                 :            :         {
     537                 :         13 :           if (CLASS_PLACEHOLDER_TEMPLATE (type))
     538                 :          0 :             emit_diagnostic (diag_kind, loc, 0,
     539                 :            :                              "invalid use of placeholder %qT", type);
     540                 :            :           else
     541                 :         13 :             emit_diagnostic (diag_kind, loc, 0,
     542                 :            :                              "invalid use of %qT", type);
     543                 :            :         }
     544                 :            :       else
     545                 :         12 :         emit_diagnostic (diag_kind, loc, 0,
     546                 :            :                          "invalid use of template type parameter %qT", type);
     547                 :            :       break;
     548                 :            : 
     549                 :          4 :     case BOUND_TEMPLATE_TEMPLATE_PARM:
     550                 :          4 :       emit_diagnostic (diag_kind, loc, 0,
     551                 :            :                        "invalid use of template template parameter %qT",
     552                 :          4 :                        TYPE_NAME (type));
     553                 :          4 :       break;
     554                 :            : 
     555                 :         24 :     case TYPENAME_TYPE:
     556                 :         24 :     case DECLTYPE_TYPE:
     557                 :         24 :       emit_diagnostic (diag_kind, loc, 0,
     558                 :            :                        "invalid use of dependent type %qT", type);
     559                 :         24 :       break;
     560                 :            : 
     561                 :        184 :     case LANG_TYPE:
     562                 :        184 :       if (type == init_list_type_node)
     563                 :            :         {
     564                 :          3 :           emit_diagnostic (diag_kind, loc, 0,
     565                 :            :                            "invalid use of brace-enclosed initializer list");
     566                 :          3 :           break;
     567                 :            :         }
     568                 :        181 :       gcc_assert (type == unknown_type_node);
     569                 :        181 :       if (value && TREE_CODE (value) == COMPONENT_REF)
     570                 :         89 :         goto bad_member;
     571                 :         92 :       else if (value && TREE_CODE (value) == ADDR_EXPR)
     572                 :         36 :         emit_diagnostic (diag_kind, loc, 0,
     573                 :            :                          "address of overloaded function with no contextual "
     574                 :            :                          "type information");
     575                 :         56 :       else if (value && TREE_CODE (value) == OVERLOAD)
     576                 :         56 :         emit_diagnostic (diag_kind, loc, 0,
     577                 :            :                          "overloaded function with no contextual type information");
     578                 :            :       else
     579                 :          0 :         emit_diagnostic (diag_kind, loc, 0,
     580                 :            :                          "insufficient contextual information to determine type");
     581                 :            :       break;
     582                 :            : 
     583                 :          0 :     default:
     584                 :          0 :       gcc_unreachable ();
     585                 :            :     }
     586                 :            : }
     587                 :            : 
     588                 :            : /* Print an error message for invalid use of an incomplete type.
     589                 :            :    VALUE is the expression that was used (or 0 if that isn't known)
     590                 :            :    and TYPE is the type that was invalid.  */
     591                 :            : 
     592                 :            : void
     593                 :         58 : cxx_incomplete_type_error (location_t loc, const_tree value, const_tree type)
     594                 :            : {
     595                 :         58 :   cxx_incomplete_type_diagnostic (loc, value, type, DK_ERROR);
     596                 :         58 : }
     597                 :            : 
     598                 :            : 
     599                 :            : /* The recursive part of split_nonconstant_init.  DEST is an lvalue
     600                 :            :    expression to which INIT should be assigned.  INIT is a CONSTRUCTOR.
     601                 :            :    Return true if the whole of the value was initialized by the
     602                 :            :    generated statements.  */
     603                 :            : 
     604                 :            : static bool
     605                 :      18775 : split_nonconstant_init_1 (tree dest, tree init, bool nested)
     606                 :            : {
     607                 :      18775 :   unsigned HOST_WIDE_INT idx, tidx = HOST_WIDE_INT_M1U;
     608                 :      18775 :   tree field_index, value;
     609                 :      18775 :   tree type = TREE_TYPE (dest);
     610                 :      18775 :   tree inner_type = NULL;
     611                 :      18775 :   bool array_type_p = false;
     612                 :      18775 :   bool complete_p = true;
     613                 :      18775 :   HOST_WIDE_INT num_split_elts = 0;
     614                 :            : 
     615                 :      18775 :   switch (TREE_CODE (type))
     616                 :            :     {
     617                 :        713 :     case ARRAY_TYPE:
     618                 :        713 :       inner_type = TREE_TYPE (type);
     619                 :        713 :       array_type_p = true;
     620                 :        713 :       if ((TREE_SIDE_EFFECTS (init)
     621                 :        295 :            && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
     622                 :        905 :           || vla_type_p (type))
     623                 :            :         {
     624                 :            :           /* For an array, we only need/want a single cleanup region rather
     625                 :            :              than one per element.  */
     626                 :        181 :           tree code = build_vec_init (dest, NULL_TREE, init, false, 1,
     627                 :            :                                       tf_warning_or_error);
     628                 :        181 :           add_stmt (code);
     629                 :        181 :           if (nested)
     630                 :            :             /* Also clean up the whole array if something later in an enclosing
     631                 :            :                init-list throws.  */
     632                 :          7 :             if (tree cleanup = cxx_maybe_build_cleanup (dest,
     633                 :            :                                                         tf_warning_or_error))
     634                 :          7 :             finish_eh_cleanup (cleanup);
     635                 :        181 :           return true;
     636                 :            :         }
     637                 :            :       /* FALLTHRU */
     638                 :            : 
     639                 :      17707 :     case RECORD_TYPE:
     640                 :      17707 :     case UNION_TYPE:
     641                 :      17707 :     case QUAL_UNION_TYPE:
     642                 :     132751 :       FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx,
     643                 :            :                                 field_index, value)
     644                 :            :         {
     645                 :            :           /* The current implementation of this algorithm assumes that
     646                 :            :              the field was set for all the elements. This is usually done
     647                 :            :              by process_init_constructor.  */
     648                 :      48706 :           gcc_assert (field_index);
     649                 :            : 
     650                 :      48706 :           if (!array_type_p)
     651                 :      46965 :             inner_type = TREE_TYPE (field_index);
     652                 :            : 
     653                 :      48706 :           if (TREE_CODE (value) == CONSTRUCTOR)
     654                 :            :             {
     655                 :        476 :               tree sub;
     656                 :            : 
     657                 :        476 :               if (array_type_p)
     658                 :        213 :                 sub = build4 (ARRAY_REF, inner_type, dest, field_index,
     659                 :            :                               NULL_TREE, NULL_TREE);
     660                 :            :               else
     661                 :        263 :                 sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
     662                 :            :                               NULL_TREE);
     663                 :            : 
     664                 :        476 :               if (!split_nonconstant_init_1 (sub, value, true))
     665                 :            :                 complete_p = false;
     666                 :            :               else
     667                 :            :                 {
     668                 :            :                   /* Mark element for removal.  */
     669                 :        143 :                   CONSTRUCTOR_ELT (init, idx)->index = NULL_TREE;
     670                 :        143 :                   if (idx < tidx)
     671                 :            :                     tidx = idx;
     672                 :        143 :                   num_split_elts++;
     673                 :            :                 }
     674                 :            :             }
     675                 :      48230 :           else if (!initializer_constant_valid_p (value, inner_type))
     676                 :            :             {
     677                 :      46763 :               tree code;
     678                 :      46763 :               tree sub;
     679                 :            : 
     680                 :            :               /* Mark element for removal.  */
     681                 :      46763 :               CONSTRUCTOR_ELT (init, idx)->index = NULL_TREE;
     682                 :      46763 :               if (idx < tidx)
     683                 :            :                 tidx = idx;
     684                 :            : 
     685                 :      46763 :               if (TREE_CODE (field_index) == RANGE_EXPR)
     686                 :            :                 {
     687                 :            :                   /* Use build_vec_init to initialize a range.  */
     688                 :          0 :                   tree low = TREE_OPERAND (field_index, 0);
     689                 :          0 :                   tree hi = TREE_OPERAND (field_index, 1);
     690                 :          0 :                   sub = build4 (ARRAY_REF, inner_type, dest, low,
     691                 :            :                                 NULL_TREE, NULL_TREE);
     692                 :          0 :                   sub = cp_build_addr_expr (sub, tf_warning_or_error);
     693                 :          0 :                   tree max = size_binop (MINUS_EXPR, hi, low);
     694                 :          0 :                   code = build_vec_init (sub, max, value, false, 0,
     695                 :            :                                          tf_warning_or_error);
     696                 :          0 :                   add_stmt (code);
     697                 :          0 :                   if (tree_fits_shwi_p (max))
     698                 :          0 :                     num_split_elts += tree_to_shwi (max);
     699                 :            :                 }
     700                 :            :               else
     701                 :            :                 {
     702                 :      46763 :                   if (array_type_p)
     703                 :       1117 :                     sub = build4 (ARRAY_REF, inner_type, dest, field_index,
     704                 :            :                                   NULL_TREE, NULL_TREE);
     705                 :            :                   else
     706                 :      45646 :                     sub = build3 (COMPONENT_REF, inner_type, dest, field_index,
     707                 :            :                                   NULL_TREE);
     708                 :            : 
     709                 :      46763 :                   code = build2 (INIT_EXPR, inner_type, sub, value);
     710                 :      46763 :                   code = build_stmt (input_location, EXPR_STMT, code);
     711                 :      46763 :                   code = maybe_cleanup_point_expr_void (code);
     712                 :      46763 :                   add_stmt (code);
     713                 :      93526 :                   if (tree cleanup
     714                 :      46763 :                       = cxx_maybe_build_cleanup (sub, tf_warning_or_error))
     715                 :         69 :                     finish_eh_cleanup (cleanup);
     716                 :            :                 }
     717                 :            : 
     718                 :      46763 :               num_split_elts++;
     719                 :            :             }
     720                 :            :         }
     721                 :      17707 :       if (num_split_elts == 1)
     722                 :       2139 :         CONSTRUCTOR_ELTS (init)->ordered_remove (tidx);
     723                 :      15568 :       else if (num_split_elts > 1)
     724                 :            :         {
     725                 :            :           /* Perform the delayed ordered removal of non-constant elements
     726                 :            :              we split out.  */
     727                 :     120386 :           for (idx = tidx; idx < CONSTRUCTOR_NELTS (init); ++idx)
     728                 :      44908 :             if (CONSTRUCTOR_ELT (init, idx)->index == NULL_TREE)
     729                 :            :               ;
     730                 :            :             else
     731                 :            :               {
     732                 :        141 :                 *CONSTRUCTOR_ELT (init, tidx) = *CONSTRUCTOR_ELT (init, idx);
     733                 :        141 :                 ++tidx;
     734                 :            :               }
     735                 :      15285 :           vec_safe_truncate (CONSTRUCTOR_ELTS (init), tidx);
     736                 :            :         }
     737                 :            :       break;
     738                 :            : 
     739                 :        887 :     case VECTOR_TYPE:
     740                 :        887 :       if (!initializer_constant_valid_p (init, type))
     741                 :            :         {
     742                 :        887 :           tree code;
     743                 :        887 :           tree cons = copy_node (init);
     744                 :        887 :           CONSTRUCTOR_ELTS (init) = NULL;
     745                 :        887 :           code = build2 (MODIFY_EXPR, type, dest, cons);
     746                 :        887 :           code = build_stmt (input_location, EXPR_STMT, code);
     747                 :        887 :           add_stmt (code);
     748                 :        887 :           num_split_elts += CONSTRUCTOR_NELTS (init);
     749                 :            :         }
     750                 :            :       break;
     751                 :            : 
     752                 :          0 :     default:
     753                 :          0 :       gcc_unreachable ();
     754                 :            :     }
     755                 :            : 
     756                 :            :   /* The rest of the initializer is now a constant. */
     757                 :      18594 :   TREE_CONSTANT (init) = 1;
     758                 :      18594 :   TREE_SIDE_EFFECTS (init) = 0;
     759                 :            : 
     760                 :            :   /* We didn't split out anything.  */
     761                 :      18594 :   if (num_split_elts == 0)
     762                 :            :     return false;
     763                 :            : 
     764                 :      34811 :   return complete_p && complete_ctor_at_level_p (TREE_TYPE (init),
     765                 :            :                                                  num_split_elts, inner_type);
     766                 :            : }
     767                 :            : 
     768                 :            : /* A subroutine of store_init_value.  Splits non-constant static
     769                 :            :    initializer INIT into a constant part and generates code to
     770                 :            :    perform the non-constant part of the initialization to DEST.
     771                 :            :    Returns the code for the runtime init.  */
     772                 :            : 
     773                 :            : tree
     774                 :    1373030 : split_nonconstant_init (tree dest, tree init)
     775                 :            : {
     776                 :    1373030 :   tree code;
     777                 :            : 
     778                 :    1373030 :   if (TREE_CODE (init) == TARGET_EXPR)
     779                 :       4299 :     init = TARGET_EXPR_INITIAL (init);
     780                 :    1373030 :   if (TREE_CODE (init) == CONSTRUCTOR)
     781                 :            :     {
     782                 :      18299 :       init = cp_fully_fold_init (init);
     783                 :      18299 :       code = push_stmt_list ();
     784                 :      18299 :       if (split_nonconstant_init_1 (dest, init, false))
     785                 :      16705 :         init = NULL_TREE;
     786                 :      18299 :       code = pop_stmt_list (code);
     787                 :      18299 :       if (VAR_P (dest) && !is_local_temp (dest))
     788                 :            :         {
     789                 :      18078 :           DECL_INITIAL (dest) = init;
     790                 :      18078 :           TREE_READONLY (dest) = 0;
     791                 :            :         }
     792                 :        221 :       else if (init)
     793                 :            :         {
     794                 :         83 :           tree ie = build2 (INIT_EXPR, void_type_node, dest, init);
     795                 :         83 :           code = add_stmt_to_compound (ie, code);
     796                 :            :         }
     797                 :            :     }
     798                 :    1354730 :   else if (TREE_CODE (init) == STRING_CST
     799                 :    1354760 :            && array_of_runtime_bound_p (TREE_TYPE (dest)))
     800                 :         30 :     code = build_vec_init (dest, NULL_TREE, init, /*value-init*/false,
     801                 :            :                            /*from array*/1, tf_warning_or_error);
     802                 :            :   else
     803                 :    1354700 :     code = build2 (INIT_EXPR, TREE_TYPE (dest), dest, init);
     804                 :            : 
     805                 :    1373030 :   return code;
     806                 :            : }
     807                 :            : 
     808                 :            : /* Perform appropriate conversions on the initial value of a variable,
     809                 :            :    store it in the declaration DECL,
     810                 :            :    and print any error messages that are appropriate.
     811                 :            :    If the init is invalid, store an ERROR_MARK.
     812                 :            : 
     813                 :            :    C++: Note that INIT might be a TREE_LIST, which would mean that it is
     814                 :            :    a base class initializer for some aggregate type, hopefully compatible
     815                 :            :    with DECL.  If INIT is a single element, and DECL is an aggregate
     816                 :            :    type, we silently convert INIT into a TREE_LIST, allowing a constructor
     817                 :            :    to be called.
     818                 :            : 
     819                 :            :    If INIT is a TREE_LIST and there is no constructor, turn INIT
     820                 :            :    into a CONSTRUCTOR and use standard initialization techniques.
     821                 :            :    Perhaps a warning should be generated?
     822                 :            : 
     823                 :            :    Returns code to be executed if initialization could not be performed
     824                 :            :    for static variable.  In that case, caller must emit the code.  */
     825                 :            : 
     826                 :            : tree
     827                 :    3503490 : store_init_value (tree decl, tree init, vec<tree, va_gc>** cleanups, int flags)
     828                 :            : {
     829                 :    3503490 :   tree value, type;
     830                 :            : 
     831                 :            :   /* If variable's type was invalidly declared, just ignore it.  */
     832                 :            : 
     833                 :    3503490 :   type = TREE_TYPE (decl);
     834                 :    3503490 :   if (TREE_CODE (type) == ERROR_MARK)
     835                 :            :     return NULL_TREE;
     836                 :            : 
     837                 :    3847980 :   if (MAYBE_CLASS_TYPE_P (type))
     838                 :            :     {
     839                 :     341438 :       if (TREE_CODE (init) == TREE_LIST)
     840                 :            :         {
     841                 :          0 :           error ("constructor syntax used, but no constructor declared "
     842                 :            :                  "for type %qT", type);
     843                 :          0 :           init = build_constructor_from_list (init_list_type_node, nreverse (init));
     844                 :            :         }
     845                 :            :     }
     846                 :            : 
     847                 :            :   /* End of special C++ code.  */
     848                 :            : 
     849                 :    3503490 :   if (flags & LOOKUP_ALREADY_DIGESTED)
     850                 :            :     value = init;
     851                 :            :   else
     852                 :            :     {
     853                 :    3298870 :       if (TREE_STATIC (decl))
     854                 :    1729110 :         flags |= LOOKUP_ALLOW_FLEXARRAY_INIT;
     855                 :            :       /* Digest the specified initializer into an expression.  */
     856                 :    3298870 :       value = digest_init_flags (type, init, flags, tf_warning_or_error);
     857                 :            :     }
     858                 :            : 
     859                 :            :   /* Look for braced array initializers for character arrays and
     860                 :            :      recursively convert them into STRING_CSTs.  */
     861                 :    3503490 :   value = braced_lists_to_strings (type, value);
     862                 :            : 
     863                 :    3503490 :   current_ref_temp_count = 0;
     864                 :    3503490 :   value = extend_ref_init_temps (decl, value, cleanups);
     865                 :            : 
     866                 :            :   /* In C++11 constant expression is a semantic, not syntactic, property.
     867                 :            :      In C++98, make sure that what we thought was a constant expression at
     868                 :            :      template definition time is still constant and otherwise perform this
     869                 :            :      as optimization, e.g. to fold SIZEOF_EXPRs in the initializer.  */
     870                 :    3503490 :   if (decl_maybe_constant_var_p (decl) || TREE_STATIC (decl))
     871                 :            :     {
     872                 :    2176100 :       bool const_init;
     873                 :    2176100 :       tree oldval = value;
     874                 :    2176100 :       value = fold_non_dependent_expr (value);
     875                 :    4352200 :       if (DECL_DECLARED_CONSTEXPR_P (decl)
     876                 :    3180100 :           || (DECL_IN_AGGR_P (decl)
     877                 :    3337350 :               && DECL_INITIALIZED_IN_CLASS_P (decl)))
     878                 :            :         {
     879                 :            :           /* Diagnose a non-constant initializer for constexpr variable or
     880                 :            :              non-inline in-class-initialized static data member.  */
     881                 :    1329220 :           if (!require_constant_expression (value))
     882                 :        201 :             value = error_mark_node;
     883                 :    1329020 :           else if (processing_template_decl)
     884                 :            :             /* In a template we might not have done the necessary
     885                 :            :                transformations to make value actually constant,
     886                 :            :                e.g. extend_ref_init_temps.  */
     887                 :      46043 :             value = maybe_constant_init (value, decl, true);
     888                 :            :           else
     889                 :    1282970 :             value = cxx_constant_init (value, decl);
     890                 :            :         }
     891                 :            :       else
     892                 :     846884 :         value = maybe_constant_init (value, decl, true);
     893                 :    2176100 :       if (TREE_CODE (value) == CONSTRUCTOR && cp_has_mutable_p (type))
     894                 :            :         /* Poison this CONSTRUCTOR so it can't be copied to another
     895                 :            :            constexpr variable.  */
     896                 :         60 :         CONSTRUCTOR_MUTABLE_POISON (value) = true;
     897                 :    2176100 :       const_init = (reduced_constant_expression_p (value)
     898                 :    2537600 :                     || error_operand_p (value));
     899                 :    2176100 :       DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = const_init;
     900                 :            :       /* FIXME setting TREE_CONSTANT on refs breaks the back end.  */
     901                 :    2176100 :       if (!TYPE_REF_P (type))
     902                 :    4212670 :         TREE_CONSTANT (decl) = const_init && decl_maybe_constant_var_p (decl);
     903                 :    2176100 :       if (!const_init)
     904                 :            :         {
     905                 :            :           /* [dcl.constinit]/2 "If a variable declared with the constinit
     906                 :            :              specifier has dynamic initialization, the program is
     907                 :            :              ill-formed."  */
     908                 :     361501 :           if (flags & LOOKUP_CONSTINIT)
     909                 :            :             {
     910                 :         30 :               error_at (location_of (decl),
     911                 :            :                         "%<constinit%> variable %qD does not have a constant "
     912                 :            :                         "initializer", decl);
     913                 :         30 :               if (require_constant_expression (value))
     914                 :         18 :                 cxx_constant_init (value, decl);
     915                 :         30 :               value = error_mark_node;
     916                 :            :             }
     917                 :            :           else
     918                 :            :             value = oldval;
     919                 :            :         }
     920                 :            :     }
     921                 :            :   /* Don't fold initializers of automatic variables in constexpr functions,
     922                 :            :      that might fold away something that needs to be diagnosed at constexpr
     923                 :            :      evaluation time.  */
     924                 :    3503490 :   if (!current_function_decl
     925                 :    3569400 :       || !DECL_DECLARED_CONSTEXPR_P (current_function_decl)
     926                 :    3561690 :       || TREE_STATIC (decl))
     927                 :    3445320 :     value = cp_fully_fold_init (value);
     928                 :            : 
     929                 :            :   /* Handle aggregate NSDMI in non-constant initializers, too.  */
     930                 :    3503490 :   value = replace_placeholders (value, decl);
     931                 :            : 
     932                 :            :   /* If the initializer is not a constant, fill in DECL_INITIAL with
     933                 :            :      the bits that are constant, and then return an expression that
     934                 :            :      will perform the dynamic initialization.  */
     935                 :    3503490 :   if (value != error_mark_node
     936                 :    3503490 :       && (TREE_SIDE_EFFECTS (value)
     937                 :    3498590 :           || vla_type_p (type)
     938                 :    2617210 :           || ! reduced_constant_expression_p (value)))
     939                 :    1371140 :     return split_nonconstant_init (decl, value);
     940                 :            : 
     941                 :            :   /* DECL may change value; purge caches.  */
     942                 :    2132350 :   clear_cv_and_fold_caches (TREE_STATIC (decl));
     943                 :            : 
     944                 :            :   /* If the value is a constant, just put it in DECL_INITIAL.  If DECL
     945                 :            :      is an automatic variable, the middle end will turn this into a
     946                 :            :      dynamic initialization later.  */
     947                 :    2132350 :   DECL_INITIAL (decl) = value;
     948                 :    2132350 :   return NULL_TREE;
     949                 :            : }
     950                 :            : 
     951                 :            : 
     952                 :            : /* Give diagnostic about narrowing conversions within { }, or as part of
     953                 :            :    a converted constant expression.  If CONST_ONLY, only check
     954                 :            :    constants.  */
     955                 :            : 
     956                 :            : bool
     957                 :    1651970 : check_narrowing (tree type, tree init, tsubst_flags_t complain,
     958                 :            :                  bool const_only/*= false*/)
     959                 :            : {
     960                 :    1651970 :   tree ftype = unlowered_expr_type (init);
     961                 :    1651970 :   bool ok = true;
     962                 :    1651970 :   REAL_VALUE_TYPE d;
     963                 :            : 
     964                 :    1624500 :   if (((!warn_narrowing || !(complain & tf_warning))
     965                 :     931383 :        && cxx_dialect == cxx98)
     966                 :    1625550 :       || !ARITHMETIC_TYPE_P (type)
     967                 :            :       /* Don't emit bogus warnings with e.g. value-dependent trees.  */
     968                 :    3271270 :       || instantiation_dependent_expression_p (init))
     969                 :      42335 :     return ok;
     970                 :            : 
     971                 :          0 :   if (BRACE_ENCLOSED_INITIALIZER_P (init)
     972                 :    1609630 :       && TREE_CODE (type) == COMPLEX_TYPE)
     973                 :            :     {
     974                 :          0 :       tree elttype = TREE_TYPE (type);
     975                 :          0 :       if (CONSTRUCTOR_NELTS (init) > 0)
     976                 :          0 :         ok &= check_narrowing (elttype, CONSTRUCTOR_ELT (init, 0)->value,
     977                 :            :                                complain);
     978                 :          0 :       if (CONSTRUCTOR_NELTS (init) > 1)
     979                 :          0 :         ok &= check_narrowing (elttype, CONSTRUCTOR_ELT (init, 1)->value,
     980                 :            :                                complain);
     981                 :          0 :       return ok;
     982                 :            :     }
     983                 :            : 
     984                 :            :   /* Even non-dependent expressions can still have template
     985                 :            :      codes like CAST_EXPR, so use *_non_dependent_expr to cope.  */
     986                 :    1609630 :   init = fold_non_dependent_expr (init, complain);
     987                 :    1609630 :   if (init == error_mark_node)
     988                 :            :     return ok;
     989                 :            : 
     990                 :            :   /* If we were asked to only check constants, return early.  */
     991                 :    3099550 :   if (const_only && !TREE_CONSTANT (init))
     992                 :            :     return ok;
     993                 :            : 
     994                 :    1608300 :   if (CP_INTEGRAL_TYPE_P (type)
     995                 :    1606620 :       && TREE_CODE (ftype) == REAL_TYPE)
     996                 :            :     ok = false;
     997                 :    1608100 :   else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
     998                 :    1607090 :            && CP_INTEGRAL_TYPE_P (type))
     999                 :            :     {
    1000                 :    1606390 :       if (TREE_CODE (ftype) == ENUMERAL_TYPE)
    1001                 :            :         /* Check for narrowing based on the values of the enumeration. */
    1002                 :     324131 :         ftype = ENUM_UNDERLYING_TYPE (ftype);
    1003                 :    1606390 :       if ((tree_int_cst_lt (TYPE_MAX_VALUE (type),
    1004                 :    1606390 :                             TYPE_MAX_VALUE (ftype))
    1005                 :    1561550 :            || tree_int_cst_lt (TYPE_MIN_VALUE (ftype),
    1006                 :    1561550 :                                TYPE_MIN_VALUE (type)))
    1007                 :    2775010 :           && (TREE_CODE (init) != INTEGER_CST
    1008                 :    1212840 :               || !int_fits_type_p (init, type)))
    1009                 :            :         ok = false;
    1010                 :            :     }
    1011                 :       1719 :   else if (TREE_CODE (ftype) == REAL_TYPE
    1012                 :        974 :            && TREE_CODE (type) == REAL_TYPE)
    1013                 :            :     {
    1014                 :        965 :       if (TYPE_PRECISION (type) < TYPE_PRECISION (ftype))
    1015                 :            :         {
    1016                 :        354 :           if (TREE_CODE (init) == REAL_CST)
    1017                 :            :             {
    1018                 :            :               /* Issue 703: Loss of precision is OK as long as the value is
    1019                 :            :                  within the representable range of the new type.  */
    1020                 :        349 :               REAL_VALUE_TYPE r;
    1021                 :        349 :               d = TREE_REAL_CST (init);
    1022                 :        349 :               real_convert (&r, TYPE_MODE (type), &d);
    1023                 :        349 :               if (real_isinf (&r))
    1024                 :          0 :                 ok = false;
    1025                 :            :             }
    1026                 :            :           else
    1027                 :            :             ok = false;
    1028                 :            :         }
    1029                 :            :     }
    1030                 :        754 :   else if (INTEGRAL_OR_ENUMERATION_TYPE_P (ftype)
    1031                 :        700 :            && TREE_CODE (type) == REAL_TYPE)
    1032                 :            :     {
    1033                 :        665 :       ok = false;
    1034                 :        665 :       if (TREE_CODE (init) == INTEGER_CST)
    1035                 :            :         {
    1036                 :        638 :           d = real_value_from_int_cst (0, init);
    1037                 :        638 :           if (exact_real_truncate (TYPE_MODE (type), &d))
    1038                 :        638 :             ok = true;
    1039                 :            :         }
    1040                 :            :     }
    1041                 :         89 :   else if (TREE_CODE (type) == BOOLEAN_TYPE
    1042                 :         89 :            && (TYPE_PTR_P (ftype) || TYPE_PTRMEM_P (ftype)))
    1043                 :            :     /* This hasn't actually made it into C++20 yet, but let's add it now to get
    1044                 :            :        an idea of the impact.  */
    1045                 :         12 :     ok = (cxx_dialect < cxx2a);
    1046                 :            : 
    1047                 :    1608300 :   bool almost_ok = ok;
    1048                 :    1608300 :   if (!ok && !CONSTANT_CLASS_P (init) && (complain & tf_warning_or_error))
    1049                 :            :     {
    1050                 :        629 :       tree folded = cp_fully_fold (init);
    1051                 :        629 :       if (TREE_CONSTANT (folded) && check_narrowing (type, folded, tf_none))
    1052                 :            :         almost_ok = true;
    1053                 :            :     }
    1054                 :            : 
    1055                 :    1608300 :   if (!ok)
    1056                 :            :     {
    1057                 :       1116 :       location_t loc = cp_expr_loc_or_input_loc (init);
    1058                 :       1116 :       if (cxx_dialect == cxx98)
    1059                 :            :         {
    1060                 :          1 :           if (complain & tf_warning)
    1061                 :          1 :             warning_at (loc, OPT_Wnarrowing, "narrowing conversion of %qE "
    1062                 :            :                         "from %qH to %qI is ill-formed in C++11",
    1063                 :            :                         init, ftype, type);
    1064                 :            :           ok = true;
    1065                 :            :         }
    1066                 :       1115 :       else if (!CONSTANT_CLASS_P (init))
    1067                 :            :         {
    1068                 :        679 :           if (complain & tf_warning_or_error)
    1069                 :            :             {
    1070                 :        629 :               auto_diagnostic_group d;
    1071                 :          9 :               if ((!almost_ok || pedantic)
    1072                 :        629 :                   && pedwarn (loc, OPT_Wnarrowing,
    1073                 :            :                               "narrowing conversion of %qE from %qH to %qI",
    1074                 :            :                               init, ftype, type)
    1075                 :        768 :                   && almost_ok)
    1076                 :          6 :                 inform (loc, " the expression has a constant value but is not "
    1077                 :            :                         "a C++ constant-expression");
    1078                 :        629 :               ok = true;
    1079                 :            :             }
    1080                 :            :         }
    1081                 :        436 :       else if (complain & tf_error)
    1082                 :            :         {
    1083                 :        403 :           int savederrorcount = errorcount;
    1084                 :        403 :           global_dc->pedantic_errors = 1;
    1085                 :        403 :           pedwarn (loc, OPT_Wnarrowing,
    1086                 :            :                    "narrowing conversion of %qE from %qH to %qI",
    1087                 :            :                    init, ftype, type);
    1088                 :        403 :           if (errorcount == savederrorcount)
    1089                 :         40 :             ok = true;
    1090                 :        403 :           global_dc->pedantic_errors = flag_pedantic_errors;
    1091                 :            :         }
    1092                 :            :     }
    1093                 :            : 
    1094                 :            :   return ok;
    1095                 :            : }
    1096                 :            : 
    1097                 :            : /* True iff TYPE is a C++2a "ordinary" character type.  */
    1098                 :            : 
    1099                 :            : bool
    1100                 :        237 : ordinary_char_type_p (tree type)
    1101                 :            : {
    1102                 :        237 :   type = TYPE_MAIN_VARIANT (type);
    1103                 :        237 :   return (type == char_type_node
    1104                 :        162 :           || type == signed_char_type_node
    1105                 :        381 :           || type == unsigned_char_type_node);
    1106                 :            : }
    1107                 :            : 
    1108                 :            : /* Process the initializer INIT for a variable of type TYPE, emitting
    1109                 :            :    diagnostics for invalid initializers and converting the initializer as
    1110                 :            :    appropriate.
    1111                 :            : 
    1112                 :            :    For aggregate types, it assumes that reshape_init has already run, thus the
    1113                 :            :    initializer will have the right shape (brace elision has been undone).
    1114                 :            : 
    1115                 :            :    NESTED is non-zero iff we are being called for an element of a CONSTRUCTOR,
    1116                 :            :    2 iff the element of a CONSTRUCTOR is inside another CONSTRUCTOR.  */
    1117                 :            : 
    1118                 :            : static tree
    1119                 :    5523150 : digest_init_r (tree type, tree init, int nested, int flags,
    1120                 :            :                tsubst_flags_t complain)
    1121                 :            : {
    1122                 :    5523150 :   enum tree_code code = TREE_CODE (type);
    1123                 :            : 
    1124                 :   11044800 :   if (error_operand_p (init))
    1125                 :            :     return error_mark_node;
    1126                 :            : 
    1127                 :    5521690 :   gcc_assert (init);
    1128                 :            : 
    1129                 :            :   /* We must strip the outermost array type when completing the type,
    1130                 :            :      because the its bounds might be incomplete at the moment.  */
    1131                 :    5795160 :   if (!complete_type_or_maybe_complain (code == ARRAY_TYPE
    1132                 :     273475 :                                         ? TREE_TYPE (type) : type, NULL_TREE,
    1133                 :            :                                         complain))
    1134                 :         14 :     return error_mark_node;
    1135                 :            : 
    1136                 :    5521680 :   location_t loc = cp_expr_loc_or_input_loc (init);
    1137                 :            : 
    1138                 :    5521680 :   tree stripped_init = init;
    1139                 :            : 
    1140                 :    1343070 :   if (BRACE_ENCLOSED_INITIALIZER_P (init)
    1141                 :    6861550 :       && CONSTRUCTOR_IS_PAREN_INIT (init))
    1142                 :        140 :     flags |= LOOKUP_AGGREGATE_PAREN_INIT;
    1143                 :            : 
    1144                 :            :   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue
    1145                 :            :      (g++.old-deja/g++.law/casts2.C).  */
    1146                 :    5521680 :   if (TREE_CODE (init) == NON_LVALUE_EXPR)
    1147                 :     890947 :     stripped_init = TREE_OPERAND (init, 0);
    1148                 :            : 
    1149                 :    5521680 :   stripped_init = tree_strip_any_location_wrapper (stripped_init);
    1150                 :            : 
    1151                 :            :   /* Initialization of an array of chars from a string constant. The initializer
    1152                 :            :      can be optionally enclosed in braces, but reshape_init has already removed
    1153                 :            :      them if they were present.  */
    1154                 :    5521680 :   if (code == ARRAY_TYPE)
    1155                 :            :     {
    1156                 :     299582 :       if (nested && !TYPE_DOMAIN (type))
    1157                 :            :         /* C++ flexible array members have a null domain.  */
    1158                 :            :         {
    1159                 :        476 :           if (flags & LOOKUP_ALLOW_FLEXARRAY_INIT)
    1160                 :        415 :             pedwarn (loc, OPT_Wpedantic,
    1161                 :            :                      "initialization of a flexible array member");
    1162                 :            :           else
    1163                 :            :             {
    1164                 :         61 :               if (complain & tf_error)
    1165                 :         61 :                 error_at (loc, "non-static initialization of"
    1166                 :            :                                " a flexible array member");
    1167                 :         61 :               return error_mark_node;
    1168                 :            :             }
    1169                 :            :         }
    1170                 :            : 
    1171                 :     273414 :       tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
    1172                 :     273414 :       if (char_type_p (typ1)
    1173                 :     273414 :           && TREE_CODE (stripped_init) == STRING_CST)
    1174                 :            :         {
    1175                 :     228349 :           tree char_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (init)));
    1176                 :     228349 :           bool incompat_string_cst = false;
    1177                 :            : 
    1178                 :     228349 :           if (typ1 != char_type)
    1179                 :            :             {
    1180                 :            :               /* The array element type does not match the initializing string
    1181                 :            :                  literal element type; this is only allowed when both types are
    1182                 :            :                  ordinary character type.  There are no string literals of
    1183                 :            :                  signed or unsigned char type in the language, but we can get
    1184                 :            :                  them internally from converting braced-init-lists to
    1185                 :            :                  STRING_CST.  */
    1186                 :        160 :               if (ordinary_char_type_p (typ1)
    1187                 :        160 :                   && ordinary_char_type_p (char_type))
    1188                 :            :                 /* OK */;
    1189                 :            :               else
    1190                 :        104 :                 incompat_string_cst = true;
    1191                 :            :             }
    1192                 :            : 
    1193                 :        104 :           if (incompat_string_cst)
    1194                 :            :             {
    1195                 :        104 :               if (complain & tf_error)
    1196                 :        104 :                 error_at (loc, "cannot initialize array of %qT from "
    1197                 :            :                           "a string literal with type array of %qT",
    1198                 :            :                           typ1, char_type);
    1199                 :        104 :               return error_mark_node;
    1200                 :            :             }
    1201                 :            : 
    1202                 :     228331 :           if (nested == 2 && !TYPE_DOMAIN (type))
    1203                 :            :             {
    1204                 :         33 :               if (complain & tf_error)
    1205                 :         33 :                 error_at (loc, "initialization of flexible array member "
    1206                 :            :                                "in a nested context");
    1207                 :         33 :               return error_mark_node;
    1208                 :            :             }
    1209                 :            : 
    1210                 :     228212 :           if (type != TREE_TYPE (init)
    1211                 :     228212 :               && !variably_modified_type_p (type, NULL_TREE))
    1212                 :            :             {
    1213                 :       1706 :               init = copy_node (init);
    1214                 :       1706 :               TREE_TYPE (init) = type;
    1215                 :            :               /* If we have a location wrapper, then also copy the wrapped
    1216                 :            :                  node, and update the copy's type.  */
    1217                 :       1706 :               if (location_wrapper_p (init))
    1218                 :            :                 {
    1219                 :       1506 :                   stripped_init = copy_node (stripped_init);
    1220                 :       1506 :                   TREE_OPERAND (init, 0) = stripped_init;
    1221                 :       1506 :                   TREE_TYPE (stripped_init) = type;
    1222                 :            :                 }
    1223                 :            :             }
    1224                 :     456370 :           if (TYPE_DOMAIN (type) && TREE_CONSTANT (TYPE_SIZE (type)))
    1225                 :            :             {
    1226                 :            :               /* Not a flexible array member.  */
    1227                 :     228120 :               int size = TREE_INT_CST_LOW (TYPE_SIZE (type));
    1228                 :     228120 :               size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
    1229                 :            :               /* In C it is ok to subtract 1 from the length of the string
    1230                 :            :                  because it's ok to ignore the terminating null char that is
    1231                 :            :                  counted in the length of the constant, but in C++ this would
    1232                 :            :                  be invalid.  */
    1233                 :     228120 :               if (size < TREE_STRING_LENGTH (stripped_init))
    1234                 :            :                 {
    1235                 :         93 :                   permerror (loc, "initializer-string for %qT is too long",
    1236                 :            :                              type);
    1237                 :            : 
    1238                 :         93 :                   init = build_string (size,
    1239                 :         93 :                                        TREE_STRING_POINTER (stripped_init));
    1240                 :         93 :                   TREE_TYPE (init) = type;
    1241                 :            :                 }
    1242                 :            :             }
    1243                 :     228212 :           return init;
    1244                 :            :         }
    1245                 :            :     }
    1246                 :            : 
    1247                 :            :   /* Handle scalar types (including conversions) and references.  */
    1248                 :        442 :   if ((code != COMPLEX_TYPE || BRACE_ENCLOSED_INITIALIZER_P (stripped_init))
    1249                 :    5293300 :       && (SCALAR_TYPE_P (type) || code == REFERENCE_TYPE))
    1250                 :            :     {
    1251                 :            :       /* Narrowing is OK when initializing an aggregate from
    1252                 :            :          a parenthesized list.  */
    1253                 :    3927110 :       if (nested && !(flags & LOOKUP_AGGREGATE_PAREN_INIT))
    1254                 :    1070730 :         flags |= LOOKUP_NO_NARROWING;
    1255                 :    3927110 :       init = convert_for_initialization (0, type, init, flags,
    1256                 :            :                                          ICR_INIT, NULL_TREE, 0,
    1257                 :            :                                          complain);
    1258                 :            : 
    1259                 :    3927110 :       return init;
    1260                 :            :     }
    1261                 :            : 
    1262                 :            :   /* Come here only for aggregates: records, arrays, unions, complex numbers
    1263                 :            :      and vectors.  */
    1264                 :    1366150 :   gcc_assert (code == ARRAY_TYPE
    1265                 :            :               || VECTOR_TYPE_P (type)
    1266                 :            :               || code == RECORD_TYPE
    1267                 :            :               || code == UNION_TYPE
    1268                 :            :               || code == COMPLEX_TYPE);
    1269                 :            : 
    1270                 :            :   /* "If T is a class type and the initializer list has a single
    1271                 :            :      element of type cv U, where U is T or a class derived from T,
    1272                 :            :      the object is initialized from that element."  */
    1273                 :    1366150 :   if (cxx_dialect >= cxx11
    1274                 :    2635900 :       && BRACE_ENCLOSED_INITIALIZER_P (stripped_init)
    1275                 :    1283540 :       && CONSTRUCTOR_NELTS (stripped_init) == 1
    1276                 :    1549920 :       && ((CLASS_TYPE_P (type) && !CLASSTYPE_NON_AGGREGATE (type))
    1277                 :       7418 :           || VECTOR_TYPE_P (type)))
    1278                 :            :     {
    1279                 :      90462 :       tree elt = CONSTRUCTOR_ELT (stripped_init, 0)->value;
    1280                 :      90462 :       if (reference_related_p (type, TREE_TYPE (elt)))
    1281                 :            :         {
    1282                 :            :           /* In C++17, aggregates can have bases, thus participate in
    1283                 :            :              aggregate initialization.  In the following case:
    1284                 :            : 
    1285                 :            :                struct B { int c; };
    1286                 :            :                struct D : B { };
    1287                 :            :                D d{{D{{42}}}};
    1288                 :            : 
    1289                 :            :             there's an extra set of braces, so the D temporary initializes
    1290                 :            :             the first element of d, which is the B base subobject.  The base
    1291                 :            :             of type B is copy-initialized from the D temporary, causing
    1292                 :            :             object slicing.  */
    1293                 :         20 :           tree field = next_initializable_field (TYPE_FIELDS (type));
    1294                 :         40 :           if (field && DECL_FIELD_IS_BASE (field))
    1295                 :            :             {
    1296                 :         40 :               if (warning_at (loc, 0, "initializing a base class of type %qT "
    1297                 :         20 :                               "results in object slicing", TREE_TYPE (field)))
    1298                 :         20 :                 inform (loc, "remove %<{ }%> around initializer");
    1299                 :            :             }
    1300                 :          0 :           else if (flag_checking)
    1301                 :            :             /* We should have fixed this in reshape_init.  */
    1302                 :          0 :             gcc_unreachable ();
    1303                 :            :         }
    1304                 :            :     }
    1305                 :            : 
    1306                 :    1298800 :   if (BRACE_ENCLOSED_INITIALIZER_P (stripped_init)
    1307                 :    3882460 :       && !TYPE_NON_AGGREGATE_CLASS (type))
    1308                 :    1293340 :     return process_init_constructor (type, stripped_init, nested, flags,
    1309                 :    1293340 :                                      complain);
    1310                 :            :   else
    1311                 :            :     {
    1312                 :      72812 :       if (COMPOUND_LITERAL_P (stripped_init) && code == ARRAY_TYPE)
    1313                 :            :         {
    1314                 :          0 :           if (complain & tf_error)
    1315                 :          0 :             error_at (loc, "cannot initialize aggregate of type %qT with "
    1316                 :            :                       "a compound literal", type);
    1317                 :            : 
    1318                 :          0 :           return error_mark_node;
    1319                 :            :         }
    1320                 :            : 
    1321                 :      72812 :       if (code == ARRAY_TYPE
    1322                 :      72847 :           && !BRACE_ENCLOSED_INITIALIZER_P (stripped_init))
    1323                 :            :         {
    1324                 :            :           /* Allow the result of build_array_copy and of
    1325                 :            :              build_value_init_noctor.  */
    1326                 :        101 :           if ((TREE_CODE (stripped_init) == VEC_INIT_EXPR
    1327                 :        101 :                || TREE_CODE (stripped_init) == CONSTRUCTOR)
    1328                 :        158 :               && (same_type_ignoring_top_level_qualifiers_p
    1329                 :         57 :                   (type, TREE_TYPE (init))))
    1330                 :            :             return init;
    1331                 :            : 
    1332                 :         48 :           if (complain & tf_error)
    1333                 :         48 :             error_at (loc, "array must be initialized with a brace-enclosed"
    1334                 :            :                       " initializer");
    1335                 :         48 :           return error_mark_node;
    1336                 :            :         }
    1337                 :            : 
    1338                 :      72711 :       return convert_for_initialization (NULL_TREE, type, init,
    1339                 :            :                                          flags,
    1340                 :            :                                          ICR_INIT, NULL_TREE, 0,
    1341                 :      72711 :                                          complain);
    1342                 :            :     }
    1343                 :            : }
    1344                 :            : 
    1345                 :            : tree
    1346                 :     138783 : digest_init (tree type, tree init, tsubst_flags_t complain)
    1347                 :            : {
    1348                 :     138783 :   return digest_init_r (type, init, 0, LOOKUP_IMPLICIT, complain);
    1349                 :            : }
    1350                 :            : 
    1351                 :            : tree
    1352                 :    4035000 : digest_init_flags (tree type, tree init, int flags, tsubst_flags_t complain)
    1353                 :            : {
    1354                 :    4035000 :   return digest_init_r (type, init, 0, flags, complain);
    1355                 :            : }
    1356                 :            : 
    1357                 :            : /* Process the initializer INIT for an NSDMI DECL (a FIELD_DECL).  */
    1358                 :            : tree
    1359                 :      14016 : digest_nsdmi_init (tree decl, tree init, tsubst_flags_t complain)
    1360                 :            : {
    1361                 :      14016 :   gcc_assert (TREE_CODE (decl) == FIELD_DECL);
    1362                 :            : 
    1363                 :      14016 :   tree type = TREE_TYPE (decl);
    1364                 :      14016 :   if (DECL_BIT_FIELD_TYPE (decl))
    1365                 :        124 :     type = DECL_BIT_FIELD_TYPE (decl);
    1366                 :      14016 :   int flags = LOOKUP_IMPLICIT;
    1367                 :      18149 :   if (DIRECT_LIST_INIT_P (init))
    1368                 :            :     {
    1369                 :        538 :       flags = LOOKUP_NORMAL;
    1370                 :        538 :       complain |= tf_no_cleanup;
    1371                 :            :     }
    1372                 :       4133 :   if (BRACE_ENCLOSED_INITIALIZER_P (init)
    1373                 :      21656 :       && CP_AGGREGATE_TYPE_P (type))
    1374                 :       3327 :     init = reshape_init (type, init, complain);
    1375                 :      14016 :   init = digest_init_flags (type, init, flags, complain);
    1376                 :      14016 :   return init;
    1377                 :            : }
    1378                 :            : 
    1379                 :            : /* Set of flags used within process_init_constructor to describe the
    1380                 :            :    initializers.  */
    1381                 :            : #define PICFLAG_ERRONEOUS 1
    1382                 :            : #define PICFLAG_NOT_ALL_CONSTANT 2
    1383                 :            : #define PICFLAG_NOT_ALL_SIMPLE 4
    1384                 :            : #define PICFLAG_SIDE_EFFECTS 8
    1385                 :            : 
    1386                 :            : /* Given an initializer INIT, return the flag (PICFLAG_*) which better
    1387                 :            :    describe it.  */
    1388                 :            : 
    1389                 :            : static int
    1390                 :    1350020 : picflag_from_initializer (tree init)
    1391                 :            : {
    1392                 :    1350020 :   if (init == error_mark_node)
    1393                 :            :     return PICFLAG_ERRONEOUS;
    1394                 :    1349300 :   else if (!TREE_CONSTANT (init))
    1395                 :            :     {
    1396                 :     158636 :       if (TREE_SIDE_EFFECTS (init))
    1397                 :            :         return PICFLAG_SIDE_EFFECTS;
    1398                 :            :       else
    1399                 :     153478 :         return PICFLAG_NOT_ALL_CONSTANT;
    1400                 :            :     }
    1401                 :    1190670 :   else if (!initializer_constant_valid_p (init, TREE_TYPE (init)))
    1402                 :        261 :     return PICFLAG_NOT_ALL_SIMPLE;
    1403                 :            :   return 0;
    1404                 :            : }
    1405                 :            : 
    1406                 :            : /* Adjust INIT for going into a CONSTRUCTOR.  */
    1407                 :            : 
    1408                 :            : static tree
    1409                 :    1349370 : massage_init_elt (tree type, tree init, int nested, int flags,
    1410                 :            :                   tsubst_flags_t complain)
    1411                 :            : {
    1412                 :    1349370 :   int new_flags = LOOKUP_IMPLICIT;
    1413                 :    1349370 :   if (flags & LOOKUP_ALLOW_FLEXARRAY_INIT)
    1414                 :    1074670 :     new_flags |= LOOKUP_ALLOW_FLEXARRAY_INIT;
    1415                 :    1349370 :   if (flags & LOOKUP_AGGREGATE_PAREN_INIT)
    1416                 :        241 :     new_flags |= LOOKUP_AGGREGATE_PAREN_INIT;
    1417                 :    2023720 :   init = digest_init_r (type, init, nested ? 2 : 1, new_flags, complain);
    1418                 :            :   /* Strip a simple TARGET_EXPR when we know this is an initializer.  */
    1419                 :    1349370 :   if (SIMPLE_TARGET_EXPR_P (init))
    1420                 :       1602 :     init = TARGET_EXPR_INITIAL (init);
    1421                 :            :   /* When we defer constant folding within a statement, we may want to
    1422                 :            :      defer this folding as well.  */
    1423                 :    1349370 :   tree t = fold_non_dependent_init (init, complain);
    1424                 :    1349370 :   if (TREE_CONSTANT (t))
    1425                 :    1190140 :     init = t;
    1426                 :    1349370 :   return init;
    1427                 :            : }
    1428                 :            : 
    1429                 :            : /* Subroutine of process_init_constructor, which will process an initializer
    1430                 :            :    INIT for an array or vector of type TYPE. Returns the flags (PICFLAG_*)
    1431                 :            :    which describe the initializers.  */
    1432                 :            : 
    1433                 :            : static int
    1434                 :      75132 : process_init_constructor_array (tree type, tree init, int nested, int flags,
    1435                 :            :                                 tsubst_flags_t complain)
    1436                 :            : {
    1437                 :      75132 :   unsigned HOST_WIDE_INT i, len = 0;
    1438                 :      75132 :   int picflags = 0;
    1439                 :      75132 :   bool unbounded = false;
    1440                 :      75132 :   constructor_elt *ce;
    1441                 :      75132 :   vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (init);
    1442                 :            : 
    1443                 :      75132 :   gcc_assert (TREE_CODE (type) == ARRAY_TYPE
    1444                 :            :               || VECTOR_TYPE_P (type));
    1445                 :            : 
    1446                 :      75132 :   if (TREE_CODE (type) == ARRAY_TYPE)
    1447                 :            :     {
    1448                 :            :       /* C++ flexible array members have a null domain.  */
    1449                 :      44964 :       tree domain = TYPE_DOMAIN (type);
    1450                 :      44964 :       if (domain && TREE_CONSTANT (TYPE_MAX_VALUE (domain)))
    1451                 :      89094 :         len = wi::ext (wi::to_offset (TYPE_MAX_VALUE (domain))
    1452                 :     133641 :                        - wi::to_offset (TYPE_MIN_VALUE (domain)) + 1,
    1453                 :      44547 :                        TYPE_PRECISION (TREE_TYPE (domain)),
    1454                 :      89094 :                        TYPE_SIGN (TREE_TYPE (domain))).to_uhwi ();
    1455                 :            :       else
    1456                 :            :         unbounded = true;  /* Take as many as there are.  */
    1457                 :            : 
    1458                 :      44964 :       if (nested == 2 && !domain && !vec_safe_is_empty (v))
    1459                 :            :         {
    1460                 :         95 :           if (complain & tf_error)
    1461                 :        190 :             error_at (cp_expr_loc_or_input_loc (init),
    1462                 :            :                       "initialization of flexible array member "
    1463                 :            :                       "in a nested context");
    1464                 :         95 :           return PICFLAG_ERRONEOUS;
    1465                 :            :         }
    1466                 :            :     }
    1467                 :            :   else
    1468                 :            :     /* Vectors are like simple fixed-size arrays.  */
    1469                 :      30168 :     unbounded = !TYPE_VECTOR_SUBPARTS (type).is_constant (&len);
    1470                 :            : 
    1471                 :            :   /* There must not be more initializers than needed.  */
    1472                 :     138775 :   if (!unbounded && vec_safe_length (v) > len)
    1473                 :            :     {
    1474                 :          5 :       if (complain & tf_error)
    1475                 :          5 :         error ("too many initializers for %qT", type);
    1476                 :            :       else
    1477                 :            :         return PICFLAG_ERRONEOUS;
    1478                 :            :     }
    1479                 :            : 
    1480                 :     437987 :   FOR_EACH_VEC_SAFE_ELT (v, i, ce)
    1481                 :            :     {
    1482                 :     362950 :       if (!ce->index)
    1483                 :        162 :         ce->index = size_int (i);
    1484                 :     362788 :       else if (!check_array_designated_initializer (ce, i))
    1485                 :          0 :         ce->index = error_mark_node;
    1486                 :     362950 :       gcc_assert (ce->value);
    1487                 :     362950 :       ce->value
    1488                 :     362950 :         = massage_init_elt (TREE_TYPE (type), ce->value, nested, flags,
    1489                 :            :                             complain);
    1490                 :            : 
    1491                 :     362950 :       gcc_checking_assert
    1492                 :            :         (ce->value == error_mark_node
    1493                 :            :          || (same_type_ignoring_top_level_qualifiers_p
    1494                 :            :              (strip_array_types (TREE_TYPE (type)),
    1495                 :            :               strip_array_types (TREE_TYPE (ce->value)))));
    1496                 :            : 
    1497                 :     362950 :       picflags |= picflag_from_initializer (ce->value);
    1498                 :            :     }
    1499                 :            : 
    1500                 :            :   /* No more initializers. If the array is unbounded, we are done. Otherwise,
    1501                 :            :      we must add initializers ourselves.  */
    1502                 :      75037 :   if (!unbounded)
    1503                 :      74837 :     for (; i < len; ++i)
    1504                 :            :       {
    1505                 :      20049 :         tree next;
    1506                 :            : 
    1507                 :      20049 :         if (type_build_ctor_call (TREE_TYPE (type)))
    1508                 :            :           {
    1509                 :            :             /* If this type needs constructors run for default-initialization,
    1510                 :            :                we can't rely on the back end to do it for us, so make the
    1511                 :            :                initialization explicit by list-initializing from T{}.  */
    1512                 :        278 :             next = build_constructor (init_list_type_node, NULL);
    1513                 :        278 :             next = massage_init_elt (TREE_TYPE (type), next, nested, flags,
    1514                 :            :                                      complain);
    1515                 :        278 :             if (initializer_zerop (next))
    1516                 :            :               /* The default zero-initialization is fine for us; don't
    1517                 :            :                  add anything to the CONSTRUCTOR.  */
    1518                 :            :               next = NULL_TREE;
    1519                 :            :           }
    1520                 :      19771 :         else if (!zero_init_p (TREE_TYPE (type)))
    1521                 :         48 :           next = build_zero_init (TREE_TYPE (type),
    1522                 :            :                                   /*nelts=*/NULL_TREE,
    1523                 :            :                                   /*static_storage_p=*/false);
    1524                 :            :         else
    1525                 :            :           /* The default zero-initialization is fine for us; don't
    1526                 :            :              add anything to the CONSTRUCTOR.  */
    1527                 :            :           next = NULL_TREE;
    1528                 :            : 
    1529                 :        173 :         if (next)
    1530                 :            :           {
    1531                 :        173 :             picflags |= picflag_from_initializer (next);
    1532                 :        173 :             if (len > i+1
    1533                 :        306 :                 && (initializer_constant_valid_p (next, TREE_TYPE (next))
    1534                 :        133 :                     == null_pointer_node))
    1535                 :            :               {
    1536                 :         51 :                 tree range = build2 (RANGE_EXPR, size_type_node,
    1537                 :            :                                      build_int_cst (size_type_node, i),
    1538                 :         51 :                                      build_int_cst (size_type_node, len - 1));
    1539                 :         51 :                 CONSTRUCTOR_APPEND_ELT (v, range, next);
    1540                 :         51 :                 break;
    1541                 :            :               }
    1542                 :            :             else
    1543                 :        122 :               CONSTRUCTOR_APPEND_ELT (v, size_int (i), next);
    1544                 :            :           }
    1545                 :            :         else
    1546                 :            :           /* Don't bother checking all the other elements.  */
    1547                 :            :           break;
    1548                 :            :       }
    1549                 :            : 
    1550                 :      75037 :   CONSTRUCTOR_ELTS (init) = v;
    1551                 :      75037 :   return picflags;
    1552                 :            : }
    1553                 :            : 
    1554                 :            : /* Subroutine of process_init_constructor, which will process an initializer
    1555                 :            :    INIT for a class of type TYPE. Returns the flags (PICFLAG_*) which describe
    1556                 :            :    the initializers.  */
    1557                 :            : 
    1558                 :            : static int
    1559                 :    1213020 : process_init_constructor_record (tree type, tree init, int nested, int flags,
    1560                 :            :                                  tsubst_flags_t complain)
    1561                 :            : {
    1562                 :    1213020 :   vec<constructor_elt, va_gc> *v = NULL;
    1563                 :    1213020 :   tree field;
    1564                 :    1213020 :   int skipped = 0;
    1565                 :            : 
    1566                 :    1213020 :   gcc_assert (TREE_CODE (type) == RECORD_TYPE);
    1567                 :    1213020 :   gcc_assert (!CLASSTYPE_VBASECLASSES (type));
    1568                 :    1213020 :   gcc_assert (!TYPE_BINFO (type)
    1569                 :            :               || cxx_dialect >= cxx17
    1570                 :            :               || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type)));
    1571                 :    1213020 :   gcc_assert (!TYPE_POLYMORPHIC_P (type));
    1572                 :            : 
    1573                 :    1213020 :  restart:
    1574                 :    1213130 :   int picflags = 0;
    1575                 :    1213130 :   unsigned HOST_WIDE_INT idx = 0;
    1576                 :    1213130 :   int designator_skip = -1;
    1577                 :            :   /* Generally, we will always have an index for each initializer (which is
    1578                 :            :      a FIELD_DECL, put by reshape_init), but compound literals don't go trough
    1579                 :            :      reshape_init. So we need to handle both cases.  */
    1580                 :   10656000 :   for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
    1581                 :            :     {
    1582                 :    9442950 :       tree next;
    1583                 :    9442950 :       tree type;
    1584                 :            : 
    1585                 :   17853100 :       if (TREE_CODE (field) != FIELD_DECL
    1586                 :    9442950 :           || (DECL_ARTIFICIAL (field)
    1587                 :    1032790 :               && !(cxx_dialect >= cxx17 && DECL_FIELD_IS_BASE (field))))
    1588                 :    8410160 :         continue;
    1589                 :            : 
    1590                 :    1033330 :       if (DECL_UNNAMED_BIT_FIELD (field))
    1591                 :         18 :         continue;
    1592                 :            : 
    1593                 :            :       /* If this is a bitfield, first convert to the declared type.  */
    1594                 :    1032770 :       type = TREE_TYPE (field);
    1595                 :    1032770 :       if (DECL_BIT_FIELD_TYPE (field))
    1596                 :        526 :         type = DECL_BIT_FIELD_TYPE (field);
    1597                 :    1032770 :       if (type == error_mark_node)
    1598                 :            :         return PICFLAG_ERRONEOUS;
    1599                 :            : 
    1600                 :    1032750 :       next = NULL_TREE;
    1601                 :    2014020 :       if (idx < CONSTRUCTOR_NELTS (init))
    1602                 :            :         {
    1603                 :     980602 :           constructor_elt *ce = &(*CONSTRUCTOR_ELTS (init))[idx];
    1604                 :     980602 :           if (ce->index)
    1605                 :            :             {
    1606                 :            :               /* We can have either a FIELD_DECL or an IDENTIFIER_NODE. The
    1607                 :            :                  latter case can happen in templates where lookup has to be
    1608                 :            :                  deferred.  */
    1609                 :     980440 :               gcc_assert (TREE_CODE (ce->index) == FIELD_DECL
    1610                 :            :                           || identifier_p (ce->index));
    1611                 :     980440 :               if (ce->index == field || ce->index == DECL_NAME (field))
    1612                 :     980343 :                 next = ce->value;
    1613                 :         28 :               else if (ANON_AGGR_TYPE_P (type)
    1614                 :        153 :                        && search_anon_aggr (type,
    1615                 :            :                                             TREE_CODE (ce->index) == FIELD_DECL
    1616                 :         28 :                                             ? DECL_NAME (ce->index)
    1617                 :            :                                             : ce->index))
    1618                 :            :                 /* If the element is an anonymous union object and the
    1619                 :            :                    initializer list is a designated-initializer-list, the
    1620                 :            :                    anonymous union object is initialized by the
    1621                 :            :                    designated-initializer-list { D }, where D is the
    1622                 :            :                    designated-initializer-clause naming a member of the
    1623                 :            :                    anonymous union object.  */
    1624                 :         28 :                 next = build_constructor_single (init_list_type_node,
    1625                 :            :                                                  ce->index, ce->value);
    1626                 :            :               else
    1627                 :            :                 {
    1628                 :         69 :                   ce = NULL;
    1629                 :         69 :                   if (designator_skip == -1)
    1630                 :         59 :                     designator_skip = 1;
    1631                 :            :                 }
    1632                 :            :             }
    1633                 :            :           else
    1634                 :            :             {
    1635                 :        162 :               designator_skip = 0;
    1636                 :        162 :               next = ce->value;
    1637                 :            :             }
    1638                 :            : 
    1639                 :     980602 :           if (ce)
    1640                 :            :             {
    1641                 :     980533 :               gcc_assert (ce->value);
    1642                 :     980533 :               next = massage_init_elt (type, next, nested, flags, complain);
    1643                 :     980533 :               ++idx;
    1644                 :            :             }
    1645                 :            :         }
    1646                 :    1032750 :       if (next)
    1647                 :            :         /* Already handled above.  */;
    1648                 :      52221 :       else if (DECL_INITIAL (field))
    1649                 :            :         {
    1650                 :        780 :           if (skipped > 0)
    1651                 :            :             {
    1652                 :            :               /* We're using an NSDMI past a field with implicit
    1653                 :            :                  zero-init.  Go back and make it explicit.  */
    1654                 :        113 :               skipped = -1;
    1655                 :        113 :               vec_safe_truncate (v, 0);
    1656                 :        113 :               goto restart;
    1657                 :            :             }
    1658                 :            :           /* C++14 aggregate NSDMI.  */
    1659                 :        667 :           next = get_nsdmi (field, /*ctor*/false, complain);
    1660                 :        667 :           if (!CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init)
    1661                 :        667 :               && find_placeholders (next))
    1662                 :        121 :             CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init) = 1;
    1663                 :            :         }
    1664                 :      51441 :       else if (type_build_ctor_call (TREE_TYPE (field)))
    1665                 :            :         {
    1666                 :            :           /* If this type needs constructors run for
    1667                 :            :              default-initialization, we can't rely on the back end to do it
    1668                 :            :              for us, so build up TARGET_EXPRs.  If the type in question is
    1669                 :            :              a class, just build one up; if it's an array, recurse.  */
    1670                 :        446 :           next = build_constructor (init_list_type_node, NULL);
    1671                 :        446 :           next = massage_init_elt (TREE_TYPE (field), next, nested, flags,
    1672                 :            :                                    complain);
    1673                 :            : 
    1674                 :            :           /* Warn when some struct elements are implicitly initialized.  */
    1675                 :        446 :           if ((complain & tf_warning)
    1676                 :        446 :               && !EMPTY_CONSTRUCTOR_P (init))
    1677                 :         20 :             warning (OPT_Wmissing_field_initializers,
    1678                 :            :                      "missing initializer for member %qD", field);
    1679                 :            :         }
    1680                 :            :       else
    1681                 :            :         {
    1682                 :      50995 :           const_tree fldtype = TREE_TYPE (field);
    1683                 :      50995 :           if (TYPE_REF_P (fldtype))
    1684                 :            :             {
    1685                 :         23 :               if (complain & tf_error)
    1686                 :         23 :                 error ("member %qD is uninitialized reference", field);
    1687                 :            :               else
    1688                 :            :                 return PICFLAG_ERRONEOUS;
    1689                 :            :             }
    1690                 :      50972 :           else if (CLASSTYPE_REF_FIELDS_NEED_INIT (fldtype))
    1691                 :            :             {
    1692                 :          1 :               if (complain & tf_error)
    1693                 :          1 :                 error ("member %qD with uninitialized reference fields", field);
    1694                 :            :               else
    1695                 :            :                 return PICFLAG_ERRONEOUS;
    1696                 :            :             }
    1697                 :            :           /* Do nothing for flexible array members since they need not have any
    1698                 :            :              elements.  Don't worry about 'skipped' because a flexarray has to
    1699                 :            :              be the last field.  */
    1700                 :      50971 :           else if (TREE_CODE (fldtype) == ARRAY_TYPE && !TYPE_DOMAIN (fldtype))
    1701                 :        102 :             continue;
    1702                 :            : 
    1703                 :            :           /* Warn when some struct elements are implicitly initialized
    1704                 :            :              to zero.  */
    1705                 :      50893 :           if ((complain & tf_warning)
    1706                 :      50893 :               && !EMPTY_CONSTRUCTOR_P (init))
    1707                 :        574 :             warning (OPT_Wmissing_field_initializers,
    1708                 :            :                      "missing initializer for member %qD", field);
    1709                 :            : 
    1710                 :      50893 :           if (!zero_init_p (fldtype)
    1711                 :      50893 :               || skipped < 0)
    1712                 :        170 :             next = build_zero_init (TREE_TYPE (field), /*nelts=*/NULL_TREE,
    1713                 :            :                                     /*static_storage_p=*/false);
    1714                 :            :           else
    1715                 :            :             {
    1716                 :            :               /* The default zero-initialization is fine for us; don't
    1717                 :            :                  add anything to the CONSTRUCTOR.  */
    1718                 :      50723 :               skipped = 1;
    1719                 :      50723 :               continue;
    1720                 :            :             }
    1721                 :            :         }
    1722                 :            : 
    1723                 :    1963150 :       if (DECL_SIZE (field) && integer_zerop (DECL_SIZE (field))
    1724                 :     981906 :           && !TREE_SIDE_EFFECTS (next))
    1725                 :            :         /* Don't add trivial initialization of an empty base/field to the
    1726                 :            :            constructor, as they might not be ordered the way the back-end
    1727                 :            :            expects.  */
    1728                 :         79 :         continue;
    1729                 :            : 
    1730                 :            :       /* If this is a bitfield, now convert to the lowered type.  */
    1731                 :     981737 :       if (type != TREE_TYPE (field))
    1732                 :        406 :         next = cp_convert_and_check (TREE_TYPE (field), next, complain);
    1733                 :     981737 :       picflags |= picflag_from_initializer (next);
    1734                 :     981737 :       CONSTRUCTOR_APPEND_ELT (v, field, next);
    1735                 :            :     }
    1736                 :            : 
    1737                 :    1661410 :   if (idx < CONSTRUCTOR_NELTS (init))
    1738                 :            :     {
    1739                 :         45 :       if (complain & tf_error)
    1740                 :            :         {
    1741                 :         22 :           constructor_elt *ce = &(*CONSTRUCTOR_ELTS (init))[idx];
    1742                 :            :           /* For better diagnostics, try to find out if it is really
    1743                 :            :              the case of too many initializers or if designators are
    1744                 :            :              in incorrect order.  */
    1745                 :         22 :           if (designator_skip == 1 && ce->index)
    1746                 :            :             {
    1747                 :         18 :               gcc_assert (TREE_CODE (ce->index) == FIELD_DECL
    1748                 :            :                           || identifier_p (ce->index));
    1749                 :         75 :               for (field = TYPE_FIELDS (type);
    1750                 :         75 :                    field; field = DECL_CHAIN (field))
    1751                 :            :                 {
    1752                 :        129 :                   if (TREE_CODE (field) != FIELD_DECL
    1753                 :         75 :                       || (DECL_ARTIFICIAL (field)
    1754                 :          0 :                           && !(cxx_dialect >= cxx17
    1755                 :         21 :                                && DECL_FIELD_IS_BASE (field))))
    1756                 :         54 :                     continue;
    1757                 :            : 
    1758                 :         21 :                   if (DECL_UNNAMED_BIT_FIELD (field))
    1759                 :          0 :                     continue;
    1760                 :            : 
    1761                 :         21 :                   if (ce->index == field || ce->index == DECL_NAME (field))
    1762                 :            :                     break;
    1763                 :          3 :                   if (ANON_AGGR_TYPE_P (TREE_TYPE (field)))
    1764                 :            :                     {
    1765                 :          0 :                       tree t
    1766                 :          0 :                         = search_anon_aggr (TREE_TYPE (field),
    1767                 :          0 :                                             TREE_CODE (ce->index) == FIELD_DECL
    1768                 :          0 :                                             ? DECL_NAME (ce->index)
    1769                 :            :                                             : ce->index);
    1770                 :          0 :                       if (t)
    1771                 :            :                         {
    1772                 :            :                           field = t;
    1773                 :            :                           break;
    1774                 :            :                         }
    1775                 :            :                     }
    1776                 :            :                 }
    1777                 :            :             }
    1778                 :         22 :           if (field)
    1779                 :         18 :             error ("designator order for field %qD does not match declaration "
    1780                 :            :                    "order in %qT", field, type);
    1781                 :            :           else
    1782                 :          4 :             error ("too many initializers for %qT", type);
    1783                 :            :         }
    1784                 :            :       else
    1785                 :            :         return PICFLAG_ERRONEOUS;
    1786                 :            :     }
    1787                 :            : 
    1788                 :    1212980 :   CONSTRUCTOR_ELTS (init) = v;
    1789                 :    1212980 :   return picflags;
    1790                 :            : }
    1791                 :            : 
    1792                 :            : /* Subroutine of process_init_constructor, which will process a single
    1793                 :            :    initializer INIT for a union of type TYPE. Returns the flags (PICFLAG_*)
    1794                 :            :    which describe the initializer.  */
    1795                 :            : 
    1796                 :            : static int
    1797                 :       5194 : process_init_constructor_union (tree type, tree init, int nested, int flags,
    1798                 :            :                                 tsubst_flags_t complain)
    1799                 :            : {
    1800                 :       5194 :   constructor_elt *ce;
    1801                 :       5194 :   int len;
    1802                 :            : 
    1803                 :            :   /* If the initializer was empty, use the union's NSDMI if it has one.
    1804                 :            :      Otherwise use default zero initialization.  */
    1805                 :       5194 :   if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init)))
    1806                 :            :     {
    1807                 :        487 :       for (tree field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
    1808                 :            :         {
    1809                 :        397 :           if (TREE_CODE (field) == FIELD_DECL
    1810                 :        477 :               && DECL_INITIAL (field) != NULL_TREE)
    1811                 :            :             {
    1812                 :         26 :               tree val = get_nsdmi (field, /*in_ctor=*/false, complain);
    1813                 :         26 :               if (!CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init)
    1814                 :         26 :                   && find_placeholders (val))
    1815                 :         20 :                 CONSTRUCTOR_PLACEHOLDER_BOUNDARY (init) = 1;
    1816                 :         26 :               CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (init), field, val);
    1817                 :         26 :               break;
    1818                 :            :             }
    1819                 :            :         }
    1820                 :            : 
    1821                 :         58 :       if (vec_safe_is_empty (CONSTRUCTOR_ELTS (init)))
    1822                 :            :         return 0;
    1823                 :            :     }
    1824                 :            : 
    1825                 :       5162 :   len = CONSTRUCTOR_ELTS (init)->length ();
    1826                 :       5162 :   if (len > 1)
    1827                 :            :     {
    1828                 :          1 :       if (!(complain & tf_error))
    1829                 :            :         return PICFLAG_ERRONEOUS;
    1830                 :          1 :       error ("too many initializers for %qT", type);
    1831                 :          1 :       CONSTRUCTOR_ELTS (init)->block_remove (1, len-1);
    1832                 :            :     }
    1833                 :            : 
    1834                 :       5162 :   ce = &(*CONSTRUCTOR_ELTS (init))[0];
    1835                 :            : 
    1836                 :            :   /* If this element specifies a field, initialize via that field.  */
    1837                 :       5162 :   if (ce->index)
    1838                 :            :     {
    1839                 :       5158 :       if (TREE_CODE (ce->index) == FIELD_DECL)
    1840                 :            :         ;
    1841                 :          0 :       else if (identifier_p (ce->index))
    1842                 :            :         {
    1843                 :            :           /* This can happen within a cast, see g++.dg/opt/cse2.C.  */
    1844                 :          0 :           tree name = ce->index;
    1845                 :          0 :           tree field;
    1846                 :          0 :           for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
    1847                 :          0 :             if (DECL_NAME (field) == name)
    1848                 :            :               break;
    1849                 :          0 :           if (!field)
    1850                 :            :             {
    1851                 :          0 :               if (complain & tf_error)
    1852                 :          0 :                 error ("no field %qD found in union being initialized",
    1853                 :            :                        field);
    1854                 :          0 :               ce->value = error_mark_node;
    1855                 :            :             }
    1856                 :          0 :           ce->index = field;
    1857                 :            :         }
    1858                 :            :       else
    1859                 :            :         {
    1860                 :          0 :           gcc_assert (TREE_CODE (ce->index) == INTEGER_CST
    1861                 :            :                       || TREE_CODE (ce->index) == RANGE_EXPR);
    1862                 :          0 :           if (complain & tf_error)
    1863                 :          0 :             error ("index value instead of field name in union initializer");
    1864                 :          0 :           ce->value = error_mark_node;
    1865                 :            :         }
    1866                 :            :     }
    1867                 :            :   else
    1868                 :            :     {
    1869                 :            :       /* Find the first named field.  ANSI decided in September 1990
    1870                 :            :          that only named fields count here.  */
    1871                 :          8 :       tree field = TYPE_FIELDS (type);
    1872                 :         87 :       while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL))
    1873                 :         40 :         field = TREE_CHAIN (field);
    1874                 :          4 :       if (field == NULL_TREE)
    1875                 :            :         {
    1876                 :          1 :           if (complain & tf_error)
    1877                 :          1 :             error ("too many initializers for %qT", type);
    1878                 :          1 :           ce->value = error_mark_node;
    1879                 :            :         }
    1880                 :          4 :       ce->index = field;
    1881                 :            :     }
    1882                 :            : 
    1883                 :       5162 :   if (ce->value && ce->value != error_mark_node)
    1884                 :       5161 :     ce->value = massage_init_elt (TREE_TYPE (ce->index), ce->value, nested,
    1885                 :            :                                   flags, complain);
    1886                 :            : 
    1887                 :       5162 :   return picflag_from_initializer (ce->value);
    1888                 :            : }
    1889                 :            : 
    1890                 :            : /* Process INIT, a constructor for a variable of aggregate type TYPE. The
    1891                 :            :    constructor is a brace-enclosed initializer, and will be modified in-place.
    1892                 :            : 
    1893                 :            :    Each element is converted to the right type through digest_init, and
    1894                 :            :    missing initializers are added following the language rules (zero-padding,
    1895                 :            :    etc.).
    1896                 :            : 
    1897                 :            :    After the execution, the initializer will have TREE_CONSTANT if all elts are
    1898                 :            :    constant, and TREE_STATIC set if, in addition, all elts are simple enough
    1899                 :            :    constants that the assembler and linker can compute them.
    1900                 :            : 
    1901                 :            :    The function returns the initializer itself, or error_mark_node in case
    1902                 :            :    of error.  */
    1903                 :            : 
    1904                 :            : static tree
    1905                 :    1293340 : process_init_constructor (tree type, tree init, int nested, int flags,
    1906                 :            :                           tsubst_flags_t complain)
    1907                 :            : {
    1908                 :    1293340 :   int picflags;
    1909                 :            : 
    1910                 :    2586680 :   gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
    1911                 :            : 
    1912                 :    1293340 :   if (TREE_CODE (type) == ARRAY_TYPE || VECTOR_TYPE_P (type))
    1913                 :      75132 :     picflags = process_init_constructor_array (type, init, nested, flags,
    1914                 :            :                                                complain);
    1915                 :    1218210 :   else if (TREE_CODE (type) == RECORD_TYPE)
    1916                 :    1213020 :     picflags = process_init_constructor_record (type, init, nested, flags,
    1917                 :            :                                                 complain);
    1918                 :       5194 :   else if (TREE_CODE (type) == UNION_TYPE)
    1919                 :       5194 :     picflags = process_init_constructor_union (type, init, nested, flags,
    1920                 :            :                                                complain);
    1921                 :            :   else
    1922                 :          0 :     gcc_unreachable ();
    1923                 :            : 
    1924                 :    1293340 :   if (picflags & PICFLAG_ERRONEOUS)
    1925                 :        795 :     return error_mark_node;
    1926                 :            : 
    1927                 :    1292550 :   TREE_TYPE (init) = type;
    1928                 :    1292550 :   if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)
    1929                 :        245 :     cp_complete_array_type (&TREE_TYPE (init), init, /*do_default=*/0);
    1930                 :    1292550 :   if (picflags & PICFLAG_SIDE_EFFECTS)
    1931                 :            :     {
    1932                 :       3592 :       TREE_CONSTANT (init) = false;
    1933                 :       3592 :       TREE_SIDE_EFFECTS (init) = true;
    1934                 :            :     }
    1935                 :    1288950 :   else if (picflags & PICFLAG_NOT_ALL_CONSTANT)
    1936                 :            :     {
    1937                 :            :       /* Make sure TREE_CONSTANT isn't set from build_constructor.  */
    1938                 :      53889 :       TREE_CONSTANT (init) = false;
    1939                 :      53889 :       TREE_SIDE_EFFECTS (init) = false;
    1940                 :            :     }
    1941                 :            :   else
    1942                 :            :     {
    1943                 :    1235060 :       TREE_CONSTANT (init) = 1;
    1944                 :    1235060 :       TREE_SIDE_EFFECTS (init) = false;
    1945                 :    1235060 :       if (!(picflags & PICFLAG_NOT_ALL_SIMPLE))
    1946                 :    1234840 :         TREE_STATIC (init) = 1;
    1947                 :            :     }
    1948                 :            :   return init;
    1949                 :            : }
    1950                 :            : 
    1951                 :            : /* Given a structure or union value DATUM, construct and return
    1952                 :            :    the structure or union component which results from narrowing
    1953                 :            :    that value to the base specified in BASETYPE.  For example, given the
    1954                 :            :    hierarchy
    1955                 :            : 
    1956                 :            :    class L { int ii; };
    1957                 :            :    class A : L { ... };
    1958                 :            :    class B : L { ... };
    1959                 :            :    class C : A, B { ... };
    1960                 :            : 
    1961                 :            :    and the declaration
    1962                 :            : 
    1963                 :            :    C x;
    1964                 :            : 
    1965                 :            :    then the expression
    1966                 :            : 
    1967                 :            :    x.A::ii refers to the ii member of the L part of
    1968                 :            :    the A part of the C object named by X.  In this case,
    1969                 :            :    DATUM would be x, and BASETYPE would be A.
    1970                 :            : 
    1971                 :            :    I used to think that this was nonconformant, that the standard specified
    1972                 :            :    that first we look up ii in A, then convert x to an L& and pull out the
    1973                 :            :    ii part.  But in fact, it does say that we convert x to an A&; A here
    1974                 :            :    is known as the "naming class".  (jason 2000-12-19)
    1975                 :            : 
    1976                 :            :    BINFO_P points to a variable initialized either to NULL_TREE or to the
    1977                 :            :    binfo for the specific base subobject we want to convert to.  */
    1978                 :            : 
    1979                 :            : tree
    1980                 :       3132 : build_scoped_ref (tree datum, tree basetype, tree* binfo_p)
    1981                 :            : {
    1982                 :       3132 :   tree binfo;
    1983                 :            : 
    1984                 :       3132 :   if (datum == error_mark_node)
    1985                 :            :     return error_mark_node;
    1986                 :       3132 :   if (*binfo_p)
    1987                 :            :     binfo = *binfo_p;
    1988                 :            :   else
    1989                 :       3132 :     binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check,
    1990                 :            :                          NULL, tf_warning_or_error);
    1991                 :            : 
    1992                 :       3132 :   if (!binfo || binfo == error_mark_node)
    1993                 :            :     {
    1994                 :          8 :       *binfo_p = NULL_TREE;
    1995                 :          8 :       if (!binfo)
    1996                 :          0 :         error_not_base_type (basetype, TREE_TYPE (datum));
    1997                 :          8 :       return error_mark_node;
    1998                 :            :     }
    1999                 :            : 
    2000                 :       3124 :   *binfo_p = binfo;
    2001                 :       3124 :   return build_base_path (PLUS_EXPR, datum, binfo, 1,
    2002                 :       3124 :                           tf_warning_or_error);
    2003                 :            : }
    2004                 :            : 
    2005                 :            : /* Build a reference to an object specified by the C++ `->' operator.
    2006                 :            :    Usually this just involves dereferencing the object, but if the
    2007                 :            :    `->' operator is overloaded, then such overloads must be
    2008                 :            :    performed until an object which does not have the `->' operator
    2009                 :            :    overloaded is found.  An error is reported when circular pointer
    2010                 :            :    delegation is detected.  */
    2011                 :            : 
    2012                 :            : tree
    2013                 :    3102200 : build_x_arrow (location_t loc, tree expr, tsubst_flags_t complain)
    2014                 :            : {
    2015                 :    3102200 :   tree orig_expr = expr;
    2016                 :    3102200 :   tree type = TREE_TYPE (expr);
    2017                 :    3102200 :   tree last_rval = NULL_TREE;
    2018                 :    3102200 :   vec<tree, va_gc> *types_memoized = NULL;
    2019                 :            : 
    2020                 :    3102200 :   if (type == error_mark_node)
    2021                 :            :     return error_mark_node;
    2022                 :            : 
    2023                 :    3102150 :   if (processing_template_decl)
    2024                 :            :     {
    2025                 :    2096990 :       if (type && TYPE_PTR_P (type)
    2026                 :    4161990 :           && !dependent_scope_p (TREE_TYPE (type)))
    2027                 :            :         /* Pointer to current instantiation, don't treat as dependent.  */;
    2028                 :     656593 :       else if (type_dependent_expression_p (expr))
    2029                 :     654057 :         return build_min_nt_loc (loc, ARROW_EXPR, expr);
    2030                 :    1535610 :       expr = build_non_dependent_expr (expr);
    2031                 :            :     }
    2032                 :            : 
    2033                 :    2480180 :   if (MAYBE_CLASS_TYPE_P (type))
    2034                 :            :     {
    2035                 :      32092 :       struct tinst_level *actual_inst = current_instantiation ();
    2036                 :      32092 :       tree fn = NULL;
    2037                 :            : 
    2038                 :      35682 :       while ((expr = build_new_op (loc, COMPONENT_REF,
    2039                 :            :                                    LOOKUP_NORMAL, expr, NULL_TREE, NULL_TREE,
    2040                 :      67774 :                                    &fn, complain)))
    2041                 :            :         {
    2042                 :      35682 :           if (expr == error_mark_node)
    2043                 :          8 :             return error_mark_node;
    2044                 :            : 
    2045                 :            :           /* This provides a better instantiation backtrace in case of
    2046                 :            :              error.  */
    2047                 :      35682 :           if (fn && DECL_USE_TEMPLATE (fn))
    2048                 :      38615 :             push_tinst_level_loc (fn, 
    2049                 :      35018 :                                   (current_instantiation () != actual_inst)
    2050                 :       3597 :                                   ? DECL_SOURCE_LOCATION (fn)
    2051                 :            :                                   : input_location);
    2052                 :      35682 :           fn = NULL;
    2053                 :            : 
    2054                 :      35682 :           if (vec_member (TREE_TYPE (expr), types_memoized))
    2055                 :            :             {
    2056                 :          0 :               if (complain & tf_error)
    2057                 :          0 :                 error ("circular pointer delegation detected");
    2058                 :          0 :               return error_mark_node;
    2059                 :            :             }
    2060                 :            : 
    2061                 :      35682 :           vec_safe_push (types_memoized, TREE_TYPE (expr));
    2062                 :      35682 :           last_rval = expr;
    2063                 :            :         }
    2064                 :            : 
    2065                 :      63506 :       while (current_instantiation () != actual_inst)
    2066                 :      31418 :         pop_tinst_level ();
    2067                 :            : 
    2068                 :      32088 :       if (last_rval == NULL_TREE)
    2069                 :            :         {
    2070                 :          8 :           if (complain & tf_error)
    2071                 :          8 :             error ("base operand of %<->%> has non-pointer type %qT", type);
    2072                 :          8 :           return error_mark_node;
    2073                 :            :         }
    2074                 :            : 
    2075                 :      32080 :       if (TYPE_REF_P (TREE_TYPE (last_rval)))
    2076                 :          0 :         last_rval = convert_from_reference (last_rval);
    2077                 :            :     }
    2078                 :            :   else
    2079                 :            :     {
    2080                 :    2416000 :       last_rval = decay_conversion (expr, complain);
    2081                 :    2416000 :       if (last_rval == error_mark_node)
    2082                 :            :         return error_mark_node;
    2083                 :            :     }
    2084                 :            : 
    2085                 :    2448080 :   if (TYPE_PTR_P (TREE_TYPE (last_rval)))
    2086                 :            :     {
    2087                 :    2448070 :       if (processing_template_decl)
    2088                 :            :         {
    2089                 :    1535610 :           expr = build_min (ARROW_EXPR, TREE_TYPE (TREE_TYPE (last_rval)),
    2090                 :            :                             orig_expr);
    2091                 :    1535610 :           TREE_SIDE_EFFECTS (expr) = TREE_SIDE_EFFECTS (last_rval);
    2092                 :    1535610 :           return expr;
    2093                 :            :         }
    2094                 :            : 
    2095                 :     912468 :       return cp_build_indirect_ref (loc, last_rval, RO_ARROW, complain);
    2096                 :            :     }
    2097                 :            : 
    2098                 :          1 :   if (complain & tf_error)
    2099                 :            :     {
    2100                 :          1 :       if (types_memoized)
    2101                 :          0 :         error ("result of %<operator->()%> yields non-pointer result");
    2102                 :            :       else
    2103                 :          1 :         error ("base operand of %<->%> is not a pointer");
    2104                 :            :     }
    2105                 :          1 :   return error_mark_node;
    2106                 :            : }
    2107                 :            : 
    2108                 :            : /* Return an expression for "DATUM .* COMPONENT".  DATUM has not
    2109                 :            :    already been checked out to be of aggregate type.  */
    2110                 :            : 
    2111                 :            : tree
    2112                 :      53375 : build_m_component_ref (tree datum, tree component, tsubst_flags_t complain)
    2113                 :            : {
    2114                 :      53375 :   tree ptrmem_type;
    2115                 :      53375 :   tree objtype;
    2116                 :      53375 :   tree type;
    2117                 :      53375 :   tree binfo;
    2118                 :      53375 :   tree ctype;
    2119                 :            : 
    2120                 :      53375 :   datum = mark_lvalue_use (datum);
    2121                 :      53375 :   component = mark_rvalue_use (component);
    2122                 :            : 
    2123                 :     160054 :   if (error_operand_p (datum) || error_operand_p (component))
    2124                 :            :     return error_mark_node;
    2125                 :            : 
    2126                 :      53325 :   ptrmem_type = TREE_TYPE (component);
    2127                 :      53325 :   if (!TYPE_PTRMEM_P (ptrmem_type))
    2128                 :            :     {
    2129                 :          7 :       if (complain & tf_error)
    2130                 :          4 :         error ("%qE cannot be used as a member pointer, since it is of "
    2131                 :            :                "type %qT", component, ptrmem_type);
    2132                 :          7 :       return error_mark_node;
    2133                 :            :     }
    2134                 :            : 
    2135                 :      53318 :   objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum));
    2136                 :     106636 :   if (! MAYBE_CLASS_TYPE_P (objtype))
    2137                 :            :     {
    2138                 :          0 :       if (complain & tf_error)
    2139                 :          0 :         error ("cannot apply member pointer %qE to %qE, which is of "
    2140                 :            :                "non-class type %qT", component, datum, objtype);
    2141                 :          0 :       return error_mark_node;
    2142                 :            :     }
    2143                 :            : 
    2144                 :      54019 :   type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type);
    2145                 :     105935 :   ctype = complete_type (TYPE_PTRMEM_CLASS_TYPE (ptrmem_type));
    2146                 :            : 
    2147                 :      53318 :   if (!COMPLETE_TYPE_P (ctype))
    2148                 :            :     {
    2149                 :         74 :       if (!same_type_p (ctype, objtype))
    2150                 :          0 :         goto mismatch;
    2151                 :            :       binfo = NULL;
    2152                 :            :     }
    2153                 :            :   else
    2154                 :            :     {
    2155                 :      53244 :       binfo = lookup_base (objtype, ctype, ba_check, NULL, complain);
    2156                 :            : 
    2157                 :      53244 :       if (!binfo)
    2158                 :            :         {
    2159                 :          3 :         mismatch:
    2160                 :          3 :           if (complain & tf_error)
    2161                 :          0 :             error ("pointer to member type %qT incompatible with object "
    2162                 :            :                    "type %qT", type, objtype);
    2163                 :          3 :           return error_mark_node;
    2164                 :            :         }
    2165                 :      53241 :       else if (binfo == error_mark_node)
    2166                 :            :         return error_mark_node;
    2167                 :            :     }
    2168                 :            : 
    2169                 :      53309 :   if (TYPE_PTRDATAMEM_P (ptrmem_type))
    2170                 :            :     {
    2171                 :        693 :       bool is_lval = real_lvalue_p (datum);
    2172                 :        693 :       tree ptype;
    2173                 :            : 
    2174                 :            :       /* Compute the type of the field, as described in [expr.ref].
    2175                 :            :          There's no such thing as a mutable pointer-to-member, so
    2176                 :            :          things are not as complex as they are for references to
    2177                 :            :          non-static data members.  */
    2178                 :        693 :       type = cp_build_qualified_type (type,
    2179                 :            :                                       (cp_type_quals (type)
    2180                 :            :                                        | cp_type_quals (TREE_TYPE (datum))));
    2181                 :            : 
    2182                 :        693 :       datum = build_address (datum);
    2183                 :            : 
    2184                 :            :       /* Convert object to the correct base.  */
    2185                 :        693 :       if (binfo)
    2186                 :            :         {
    2187                 :        665 :           datum = build_base_path (PLUS_EXPR, datum, binfo, 1, complain);
    2188                 :        665 :           if (datum == error_mark_node)
    2189                 :            :             return error_mark_node;
    2190                 :            :         }
    2191                 :            : 
    2192                 :            :       /* Build an expression for "object + offset" where offset is the
    2193                 :            :          value stored in the pointer-to-data-member.  */
    2194                 :        693 :       ptype = build_pointer_type (type);
    2195                 :        693 :       datum = fold_build_pointer_plus (fold_convert (ptype, datum), component);
    2196                 :        693 :       datum = cp_build_fold_indirect_ref (datum);
    2197                 :        693 :       if (datum == error_mark_node)
    2198                 :            :         return error_mark_node;
    2199                 :            : 
    2200                 :            :       /* If the object expression was an rvalue, return an rvalue.  */
    2201                 :        693 :       if (!is_lval)
    2202                 :         30 :         datum = move (datum);
    2203                 :        693 :       return datum;
    2204                 :            :     }
    2205                 :            :   else
    2206                 :            :     {
    2207                 :            :       /* 5.5/6: In a .* expression whose object expression is an rvalue, the
    2208                 :            :          program is ill-formed if the second operand is a pointer to member
    2209                 :            :          function with ref-qualifier & (for C++2A: unless its cv-qualifier-seq
    2210                 :            :          is const). In a .* expression whose object expression is an lvalue,
    2211                 :            :          the program is ill-formed if the second operand is a pointer to member
    2212                 :            :          function with ref-qualifier &&.  */
    2213                 :     157848 :       if (FUNCTION_REF_QUALIFIED (type))
    2214                 :            :         {
    2215                 :        116 :           bool lval = lvalue_p (datum);
    2216                 :        232 :           if (lval && FUNCTION_RVALUE_QUALIFIED (type))
    2217                 :            :             {
    2218                 :          9 :               if (complain & tf_error)
    2219                 :          6 :                 error ("pointer-to-member-function type %qT requires an rvalue",
    2220                 :            :                        ptrmem_type);
    2221                 :          9 :               return error_mark_node;
    2222                 :            :             }
    2223                 :        223 :           else if (!lval && !FUNCTION_RVALUE_QUALIFIED (type))
    2224                 :            :             {
    2225                 :         33 :               if ((type_memfn_quals (type)
    2226                 :         33 :                    & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE))
    2227                 :            :                   != TYPE_QUAL_CONST)
    2228                 :            :                 {
    2229                 :         27 :                   if (complain & tf_error)
    2230                 :         24 :                     error ("pointer-to-member-function type %qT requires "
    2231                 :            :                            "an lvalue", ptrmem_type);
    2232                 :         27 :                   return error_mark_node;
    2233                 :            :                 }
    2234                 :          6 :               else if (cxx_dialect < cxx2a)
    2235                 :            :                 {
    2236                 :          4 :                   if (complain & tf_warning_or_error)
    2237                 :          4 :                     pedwarn (input_location, OPT_Wpedantic,
    2238                 :            :                              "pointer-to-member-function type %qT requires "
    2239                 :            :                              "an lvalue before C++2a", ptrmem_type);
    2240                 :            :                   else
    2241                 :          0 :                     return error_mark_node;
    2242                 :            :                 }
    2243                 :            :             }
    2244                 :            :         }
    2245                 :      52580 :       return build2 (OFFSET_REF, type, datum, component);
    2246                 :            :     }
    2247                 :            : }
    2248                 :            : 
    2249                 :            : /* Return a tree node for the expression TYPENAME '(' PARMS ')'.  */
    2250                 :            : 
    2251                 :            : static tree
    2252                 :    4114380 : build_functional_cast_1 (location_t loc, tree exp, tree parms,
    2253                 :            :                          tsubst_flags_t complain)
    2254                 :            : {
    2255                 :            :   /* This is either a call to a constructor,
    2256                 :            :      or a C cast in C++'s `functional' notation.  */
    2257                 :            : 
    2258                 :            :   /* The type to which we are casting.  */
    2259                 :    4114380 :   tree type;
    2260                 :            : 
    2261                 :    8228650 :   if (error_operand_p (exp) || parms == error_mark_node)
    2262                 :            :     return error_mark_node;
    2263                 :            : 
    2264                 :    4113900 :   if (TREE_CODE (exp) == TYPE_DECL)
    2265                 :            :     {
    2266                 :    1762680 :       type = TREE_TYPE (exp);
    2267                 :            : 
    2268                 :    1762680 :       if (DECL_ARTIFICIAL (exp))
    2269                 :    1139960 :         cp_warn_deprecated_use (type);
    2270                 :            :     }
    2271                 :            :   else
    2272                 :            :     type = exp;
    2273                 :            : 
    2274                 :            :   /* We need to check this explicitly, since value-initialization of
    2275                 :            :      arrays is allowed in other situations.  */
    2276                 :    4113900 :   if (TREE_CODE (type) == ARRAY_TYPE)
    2277                 :            :     {
    2278                 :         14 :       if (complain & tf_error)
    2279                 :          8 :         error_at (loc, "functional cast to array type %qT", type);
    2280                 :         14 :       return error_mark_node;
    2281                 :            :     }
    2282                 :            : 
    2283                 :    4113880 :   if (tree anode = type_uses_auto (type))
    2284                 :            :     {
    2285                 :       1401 :       if (!CLASS_PLACEHOLDER_TEMPLATE (anode))
    2286                 :            :         {
    2287                 :         19 :           if (complain & tf_error)
    2288                 :         19 :             error_at (loc, "invalid use of %qT", anode);
    2289                 :         19 :           return error_mark_node;
    2290                 :            :         }
    2291                 :       1382 :       else if (!parms)
    2292                 :            :         {
    2293                 :            :           /* Even if there are no parameters, we might be able to deduce from
    2294                 :            :              default template arguments.  Pass TF_NONE so that we don't
    2295                 :            :              generate redundant diagnostics.  */
    2296                 :         22 :           type = do_auto_deduction (type, parms, anode, tf_none,
    2297                 :            :                                     adc_variable_type);
    2298                 :         22 :           if (type == error_mark_node)
    2299                 :            :             {
    2300                 :         12 :               if (complain & tf_error)
    2301                 :         12 :                 error_at (loc, "cannot deduce template arguments "
    2302                 :            :                           "for %qT from %<()%>", anode);
    2303                 :         12 :               return error_mark_node;
    2304                 :            :             }
    2305                 :            :         }
    2306                 :            :       else
    2307                 :       1360 :         type = do_auto_deduction (type, parms, anode, complain,
    2308                 :            :                                   adc_variable_type);
    2309                 :            :     }
    2310                 :            : 
    2311                 :    4113850 :   if (processing_template_decl)
    2312                 :            :     {
    2313                 :    1589220 :       tree t;
    2314                 :            : 
    2315                 :            :       /* Diagnose this even in a template.  We could also try harder
    2316                 :            :          to give all the usual errors when the type and args are
    2317                 :            :          non-dependent...  */
    2318                 :    1589220 :       if (TYPE_REF_P (type) && !parms)
    2319                 :            :         {
    2320                 :          4 :           if (complain & tf_error)
    2321                 :          4 :             error_at (loc, "invalid value-initialization of reference type");
    2322                 :          4 :           return error_mark_node;
    2323                 :            :         }
    2324                 :            : 
    2325                 :    1589210 :       t = build_min (CAST_EXPR, type, parms);
    2326                 :            :       /* We don't know if it will or will not have side effects.  */
    2327                 :    1589210 :       TREE_SIDE_EFFECTS (t) = 1;
    2328                 :    1589210 :       return t;
    2329                 :            :     }
    2330                 :            : 
    2331                 :    3183180 :   if (! MAYBE_CLASS_TYPE_P (type))
    2332                 :            :     {
    2333                 :    1866120 :       if (parms == NULL_TREE)
    2334                 :            :         {
    2335                 :     135563 :           if (VOID_TYPE_P (type))
    2336                 :        104 :             return void_node;
    2337                 :     135459 :           return build_value_init (cv_unqualified (type), complain);
    2338                 :            :         }
    2339                 :            : 
    2340                 :            :       /* This must build a C cast.  */
    2341                 :    1730560 :       parms = build_x_compound_expr_from_list (parms, ELK_FUNC_CAST, complain);
    2342                 :    1730560 :       return cp_build_c_cast (loc, type, parms, complain);
    2343                 :            :     }
    2344                 :            : 
    2345                 :            :   /* Prepare to evaluate as a call to a constructor.  If this expression
    2346                 :            :      is actually used, for example,
    2347                 :            : 
    2348                 :            :      return X (arg1, arg2, ...);
    2349                 :            : 
    2350                 :            :      then the slot being initialized will be filled in.  */
    2351                 :            : 
    2352                 :     658511 :   if (!complete_type_or_maybe_complain (type, NULL_TREE, complain))
    2353                 :         20 :     return error_mark_node;
    2354                 :     658488 :   if (abstract_virtuals_error_sfinae (ACU_CAST, type, complain))
    2355                 :          9 :     return error_mark_node;
    2356                 :            : 
    2357                 :            :   /* [expr.type.conv]
    2358                 :            : 
    2359                 :            :      If the expression list is a single-expression, the type
    2360                 :            :      conversion is equivalent (in definedness, and if defined in
    2361                 :            :      meaning) to the corresponding cast expression.  */
    2362                 :     966602 :   if (parms && TREE_CHAIN (parms) == NULL_TREE)
    2363                 :     252121 :     return cp_build_c_cast (loc, type, TREE_VALUE (parms), complain);
    2364                 :            : 
    2365                 :            :   /* [expr.type.conv]
    2366                 :            : 
    2367                 :            :      The expression T(), where T is a simple-type-specifier for a
    2368                 :            :      non-array complete object type or the (possibly cv-qualified)
    2369                 :            :      void type, creates an rvalue of the specified type, which is
    2370                 :            :      value-initialized.  */
    2371                 :            : 
    2372                 :     406358 :   if (parms == NULL_TREE)
    2373                 :            :     {
    2374                 :     350356 :       exp = build_value_init (type, complain);
    2375                 :     350356 :       exp = get_target_expr_sfinae (exp, complain);
    2376                 :     350356 :       return exp;
    2377                 :            :     }
    2378                 :            : 
    2379                 :            :   /* Call the constructor.  */
    2380                 :      56002 :   releasing_vec parmvec;
    2381                 :     176394 :   for (; parms != NULL_TREE; parms = TREE_CHAIN (parms))
    2382                 :     120392 :     vec_safe_push (parmvec, TREE_VALUE (parms));
    2383                 :      56002 :   exp = build_special_member_call (NULL_TREE, complete_ctor_identifier,
    2384                 :            :                                    &parmvec, type, LOOKUP_NORMAL, complain);
    2385                 :            : 
    2386                 :      56002 :   if (exp == error_mark_node)
    2387                 :            :     return error_mark_node;
    2388                 :            : 
    2389                 :      55990 :   return build_cplus_new (type, exp, complain);
    2390                 :            : }
    2391                 :            : 
    2392                 :            : tree
    2393                 :    4114380 : build_functional_cast (location_t loc, tree exp, tree parms,
    2394                 :            :                        tsubst_flags_t complain)
    2395                 :            : {
    2396                 :    4114380 :   tree result = build_functional_cast_1 (loc, exp, parms, complain);
    2397                 :    4114370 :   protected_set_expr_location (result, loc);
    2398                 :    4114370 :   return result;  
    2399                 :            : }
    2400                 :            : 
    2401                 :            : 
    2402                 :            : /* Add new exception specifier SPEC, to the LIST we currently have.
    2403                 :            :    If it's already in LIST then do nothing.
    2404                 :            :    Moan if it's bad and we're allowed to. COMPLAIN < 0 means we
    2405                 :            :    know what we're doing.  */
    2406                 :            : 
    2407                 :            : tree
    2408                 :      12609 : add_exception_specifier (tree list, tree spec, tsubst_flags_t complain)
    2409                 :            : {
    2410                 :      12609 :   bool ok;
    2411                 :      12609 :   tree core = spec;
    2412                 :      12609 :   bool is_ptr;
    2413                 :      12609 :   diagnostic_t diag_type = DK_UNSPECIFIED; /* none */
    2414                 :            : 
    2415                 :      12609 :   if (spec == error_mark_node)
    2416                 :            :     return list;
    2417                 :            : 
    2418                 :      12741 :   gcc_assert (spec && (!list || TREE_VALUE (list)));
    2419                 :            : 
    2420                 :            :   /* [except.spec] 1, type in an exception specifier shall not be
    2421                 :            :      incomplete, or pointer or ref to incomplete other than pointer
    2422                 :            :      to cv void.  */
    2423                 :      12595 :   is_ptr = TYPE_PTR_P (core);
    2424                 :      12595 :   if (is_ptr || TYPE_REF_P (core))
    2425                 :         38 :     core = TREE_TYPE (core);
    2426                 :      12595 :   if (complain < 0)
    2427                 :            :     ok = true;
    2428                 :       1459 :   else if (VOID_TYPE_P (core))
    2429                 :            :     ok = is_ptr;
    2430                 :       1441 :   else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM)
    2431                 :            :     ok = true;
    2432                 :       1429 :   else if (processing_template_decl)
    2433                 :            :     ok = true;
    2434                 :       1392 :   else if (!verify_type_context (input_location, TCTX_EXCEPTIONS, core,
    2435                 :       1392 :                                  !(complain & tf_error)))
    2436                 :          0 :     return error_mark_node;
    2437                 :            :   else
    2438                 :            :     {
    2439                 :       1392 :       ok = true;
    2440                 :            :       /* 15.4/1 says that types in an exception specifier must be complete,
    2441                 :            :          but it seems more reasonable to only require this on definitions
    2442                 :            :          and calls.  So just give a pedwarn at this point; we will give an
    2443                 :            :          error later if we hit one of those two cases.  */
    2444                 :       1392 :       if (!COMPLETE_TYPE_P (complete_type (core)))
    2445                 :            :         diag_type = DK_PEDWARN; /* pedwarn */
    2446                 :            :     }
    2447                 :            : 
    2448                 :         18 :   if (ok)
    2449                 :            :     {
    2450                 :            :       tree probe;
    2451                 :            : 
    2452                 :      12733 :       for (probe = list; probe; probe = TREE_CHAIN (probe))
    2453                 :        156 :         if (same_type_p (TREE_VALUE (probe), spec))
    2454                 :            :           break;
    2455                 :      12581 :       if (!probe)
    2456                 :      12577 :         list = tree_cons (NULL_TREE, spec, list);
    2457                 :            :     }
    2458                 :            :   else
    2459                 :            :     diag_type = DK_ERROR; /* error */
    2460                 :            : 
    2461                 :      12581 :   if (diag_type != DK_UNSPECIFIED
    2462                 :         26 :       && (complain & tf_warning_or_error))
    2463                 :         20 :     cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
    2464                 :            : 
    2465                 :            :   return list;
    2466                 :            : }
    2467                 :            : 
    2468                 :            : /* Like nothrow_spec_p, but don't abort on deferred noexcept.  */
    2469                 :            : 
    2470                 :            : static bool
    2471                 :     464420 : nothrow_spec_p_uninst (const_tree spec)
    2472                 :            : {
    2473                 :     928840 :   if (DEFERRED_NOEXCEPT_SPEC_P (spec))
    2474                 :            :     return false;
    2475                 :     464417 :   return nothrow_spec_p (spec);
    2476                 :            : }
    2477                 :            : 
    2478                 :            : /* Combine the two exceptions specifier lists LIST and ADD, and return
    2479                 :            :    their union.  */
    2480                 :            : 
    2481                 :            : tree
    2482                 :     930594 : merge_exception_specifiers (tree list, tree add)
    2483                 :            : {
    2484                 :     930594 :   tree noex, orig_list;
    2485                 :            : 
    2486                 :     930594 :   if (list == error_mark_node || add == error_mark_node)
    2487                 :            :     return error_mark_node;
    2488                 :            : 
    2489                 :            :   /* No exception-specifier or noexcept(false) are less strict than
    2490                 :            :      anything else.  Prefer the newer variant (LIST).  */
    2491                 :     930594 :   if (!list || list == noexcept_false_spec)
    2492                 :            :     return list;
    2493                 :     497956 :   else if (!add || add == noexcept_false_spec)
    2494                 :            :     return add;
    2495                 :            : 
    2496                 :            :   /* noexcept(true) and throw() are stricter than anything else.
    2497                 :            :      As above, prefer the more recent one (LIST).  */
    2498                 :     464221 :   if (nothrow_spec_p_uninst (add))
    2499                 :            :     return list;
    2500                 :            : 
    2501                 :            :   /* Two implicit noexcept specs (e.g. on a destructor) are equivalent.  */
    2502                 :        202 :   if (UNEVALUATED_NOEXCEPT_SPEC_P (add)
    2503                 :          3 :       && UNEVALUATED_NOEXCEPT_SPEC_P (list))
    2504                 :            :     return list;
    2505                 :            :   /* We should have instantiated other deferred noexcept specs by now.  */
    2506                 :        199 :   gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (add));
    2507                 :            : 
    2508                 :        199 :   if (nothrow_spec_p_uninst (list))
    2509                 :            :     return add;
    2510                 :        194 :   noex = TREE_PURPOSE (list);
    2511                 :        194 :   gcc_checking_assert (!TREE_PURPOSE (add)
    2512                 :            :                        || errorcount || !flag_exceptions
    2513                 :            :                        || cp_tree_equal (noex, TREE_PURPOSE (add)));
    2514                 :            : 
    2515                 :            :   /* Combine the dynamic-exception-specifiers, if any.  */
    2516                 :        235 :   orig_list = list;
    2517                 :        443 :   for (; add && TREE_VALUE (add); add = TREE_CHAIN (add))
    2518                 :            :     {
    2519                 :         65 :       tree spec = TREE_VALUE (add);
    2520                 :            :       tree probe;
    2521                 :            : 
    2522                 :        142 :       for (probe = orig_list; probe && TREE_VALUE (probe);
    2523                 :         24 :            probe = TREE_CHAIN (probe))
    2524                 :         53 :         if (same_type_p (TREE_VALUE (probe), spec))
    2525                 :            :           break;
    2526                 :         41 :       if (!probe)
    2527                 :            :         {
    2528                 :         12 :           spec = build_tree_list (NULL_TREE, spec);
    2529                 :         12 :           TREE_CHAIN (spec) = list;
    2530                 :         12 :           list = spec;
    2531                 :            :         }
    2532                 :            :     }
    2533                 :            : 
    2534                 :            :   /* Keep the noexcept-specifier at the beginning of the list.  */
    2535                 :        194 :   if (noex != TREE_PURPOSE (list))
    2536                 :          0 :     list = tree_cons (noex, TREE_VALUE (list), TREE_CHAIN (list));
    2537                 :            : 
    2538                 :            :   return list;
    2539                 :            : }
    2540                 :            : 
    2541                 :            : /* Subroutine of build_call.  Ensure that each of the types in the
    2542                 :            :    exception specification is complete.  Technically, 15.4/1 says that
    2543                 :            :    they need to be complete when we see a declaration of the function,
    2544                 :            :    but we should be able to get away with only requiring this when the
    2545                 :            :    function is defined or called.  See also add_exception_specifier.  */
    2546                 :            : 
    2547                 :            : void
    2548                 :   24873900 : require_complete_eh_spec_types (tree fntype, tree decl)
    2549                 :            : {
    2550                 :   24873900 :   tree raises;
    2551                 :            :   /* Don't complain about calls to op new.  */
    2552                 :   48398400 :   if (decl && DECL_ARTIFICIAL (decl))
    2553                 :            :     return;
    2554                 :   52036900 :   for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
    2555                 :   10521400 :        raises = TREE_CHAIN (raises))
    2556                 :            :     {
    2557                 :   10521400 :       tree type = TREE_VALUE (raises);
    2558                 :   10522100 :       if (type && !COMPLETE_TYPE_P (type))
    2559                 :            :         {
    2560                 :          2 :           if (decl)
    2561                 :          2 :             error
    2562                 :          2 :               ("call to function %qD which throws incomplete type %q#T",
    2563                 :            :                decl, type);
    2564                 :            :           else
    2565                 :          0 :             error ("call to function which throws incomplete type %q#T",
    2566                 :            :                    decl);
    2567                 :            :         }
    2568                 :            :     }
    2569                 :            : }
    2570                 :            : 
    2571                 :            : 
    2572                 :            : #include "gt-cp-typeck2.h"

Generated by: LCOV version 1.0

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