gcc/cp/typeck2.cc

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