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