1 /* Handle initialization things in C++. 2 Copyright (C) 1987-2018 Free Software Foundation, Inc. 3 Contributed by Michael Tiemann (tiemann@cygnus.com) 4 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3, or (at your option) 10 any later version. 11 12 GCC is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GCC; see the file COPYING3. If not see 19 <http://www.gnu.org/licenses/>. */ 20 21 /* High-level class interface. */ 22 23 #include "config.h" 24 #include "system.h" 25 #include "coretypes.h" 26 #include "target.h" 27 #include "cp-tree.h" 28 #include "stringpool.h" 29 #include "varasm.h" 30 #include "gimplify.h" 31 #include "c-family/c-ubsan.h" 32 #include "intl.h" 33 #include "stringpool.h" 34 #include "attribs.h" 35 #include "asan.h" 36 37 static bool begin_init_stmts (tree *, tree *); 38 static tree finish_init_stmts (bool, tree, tree); 39 static void construct_virtual_base (tree, tree); 40 static void expand_aggr_init_1 (tree, tree, tree, tree, int, tsubst_flags_t); 41 static void expand_default_init (tree, tree, tree, tree, int, tsubst_flags_t); 42 static void perform_member_init (tree, tree); 43 static int member_init_ok_or_else (tree, tree, tree); 44 static void expand_virtual_init (tree, tree); 45 static tree sort_mem_initializers (tree, tree); 46 static tree initializing_context (tree); 47 static void expand_cleanup_for_base (tree, tree); 48 static tree dfs_initialize_vtbl_ptrs (tree, void *); 49 static tree build_field_list (tree, tree, int *); 50 static int diagnose_uninitialized_cst_or_ref_member_1 (tree, tree, bool, bool); 51 52 static GTY(()) tree fn; 53 54 /* We are about to generate some complex initialization code. 55 Conceptually, it is all a single expression. However, we may want 56 to include conditionals, loops, and other such statement-level 57 constructs. Therefore, we build the initialization code inside a 58 statement-expression. This function starts such an expression. 59 STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function; 60 pass them back to finish_init_stmts when the expression is 61 complete. */ 62 63 static bool 64 begin_init_stmts (tree *stmt_expr_p, tree *compound_stmt_p) 65 { 66 bool is_global = !building_stmt_list_p (); 67 68 *stmt_expr_p = begin_stmt_expr (); 69 *compound_stmt_p = begin_compound_stmt (BCS_NO_SCOPE); 70 71 return is_global; 72 } 73 74 /* Finish out the statement-expression begun by the previous call to 75 begin_init_stmts. Returns the statement-expression itself. */ 76 77 static tree 78 finish_init_stmts (bool is_global, tree stmt_expr, tree compound_stmt) 79 { 80 finish_compound_stmt (compound_stmt); 81 82 stmt_expr = finish_stmt_expr (stmt_expr, true); 83 84 gcc_assert (!building_stmt_list_p () == is_global); 85 86 return stmt_expr; 87 } 88 89 /* Constructors */ 90 91 /* Called from initialize_vtbl_ptrs via dfs_walk. BINFO is the base 92 which we want to initialize the vtable pointer for, DATA is 93 TREE_LIST whose TREE_VALUE is the this ptr expression. */ 94 95 static tree 96 dfs_initialize_vtbl_ptrs (tree binfo, void *data) 97 { 98 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo))) 99 return dfs_skip_bases; 100 101 if (!BINFO_PRIMARY_P (binfo) || BINFO_VIRTUAL_P (binfo)) 102 { 103 tree base_ptr = TREE_VALUE ((tree) data); 104 105 base_ptr = build_base_path (PLUS_EXPR, base_ptr, binfo, /*nonnull=*/1, 106 tf_warning_or_error); 107 108 expand_virtual_init (binfo, base_ptr); 109 } 110 111 return NULL_TREE; 112 } 113 114 /* Initialize all the vtable pointers in the object pointed to by 115 ADDR. */ 116 117 void 118 initialize_vtbl_ptrs (tree addr) 119 { 120 tree list; 121 tree type; 122 123 type = TREE_TYPE (TREE_TYPE (addr)); 124 list = build_tree_list (type, addr); 125 126 /* Walk through the hierarchy, initializing the vptr in each base 127 class. We do these in pre-order because we can't find the virtual 128 bases for a class until we've initialized the vtbl for that 129 class. */ 130 dfs_walk_once (TYPE_BINFO (type), dfs_initialize_vtbl_ptrs, NULL, list); 131 } 132 133 /* Return an expression for the zero-initialization of an object with 134 type T. This expression will either be a constant (in the case 135 that T is a scalar), or a CONSTRUCTOR (in the case that T is an 136 aggregate), or NULL (in the case that T does not require 137 initialization). In either case, the value can be used as 138 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static 139 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS 140 is the number of elements in the array. If STATIC_STORAGE_P is 141 TRUE, initializers are only generated for entities for which 142 zero-initialization does not simply mean filling the storage with 143 zero bytes. FIELD_SIZE, if non-NULL, is the bit size of the field, 144 subfields with bit positions at or above that bit size shouldn't 145 be added. Note that this only works when the result is assigned 146 to a base COMPONENT_REF; if we only have a pointer to the base subobject, 147 expand_assignment will end up clearing the full size of TYPE. */ 148 149 static tree 150 build_zero_init_1 (tree type, tree nelts, bool static_storage_p, 151 tree field_size) 152 { 153 tree init = NULL_TREE; 154 155 /* [dcl.init] 156 157 To zero-initialize an object of type T means: 158 159 -- if T is a scalar type, the storage is set to the value of zero 160 converted to T. 161 162 -- if T is a non-union class type, the storage for each nonstatic 163 data member and each base-class subobject is zero-initialized. 164 165 -- if T is a union type, the storage for its first data member is 166 zero-initialized. 167 168 -- if T is an array type, the storage for each element is 169 zero-initialized. 170 171 -- if T is a reference type, no initialization is performed. */ 172 173 gcc_assert (nelts == NULL_TREE || TREE_CODE (nelts) == INTEGER_CST); 174 175 if (type == error_mark_node) 176 ; 177 else if (static_storage_p && zero_init_p (type)) 178 /* In order to save space, we do not explicitly build initializers 179 for items that do not need them. GCC's semantics are that 180 items with static storage duration that are not otherwise 181 initialized are initialized to zero. */ 182 ; 183 else if (TYPE_PTR_OR_PTRMEM_P (type)) 184 init = fold (convert (type, nullptr_node)); 185 else if (NULLPTR_TYPE_P (type)) 186 init = build_int_cst (type, 0); 187 else if (SCALAR_TYPE_P (type)) 188 init = fold (convert (type, integer_zero_node)); 189 else if (RECORD_OR_UNION_CODE_P (TREE_CODE (type))) 190 { 191 tree field; 192 vec<constructor_elt, va_gc> *v = NULL; 193 194 /* Iterate over the fields, building initializations. */ 195 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field)) 196 { 197 if (TREE_CODE (field) != FIELD_DECL) 198 continue; 199 200 if (TREE_TYPE (field) == error_mark_node) 201 continue; 202 203 /* Don't add virtual bases for base classes if they are beyond 204 the size of the current field, that means it is present 205 somewhere else in the object. */ 206 if (field_size) 207 { 208 tree bitpos = bit_position (field); 209 if (TREE_CODE (bitpos) == INTEGER_CST 210 && !tree_int_cst_lt (bitpos, field_size)) 211 continue; 212 } 213 214 /* Note that for class types there will be FIELD_DECLs 215 corresponding to base classes as well. Thus, iterating 216 over TYPE_FIELDs will result in correct initialization of 217 all of the subobjects. */ 218 if (!static_storage_p || !zero_init_p (TREE_TYPE (field))) 219 { 220 tree new_field_size 221 = (DECL_FIELD_IS_BASE (field) 222 && DECL_SIZE (field) 223 && TREE_CODE (DECL_SIZE (field)) == INTEGER_CST) 224 ? DECL_SIZE (field) : NULL_TREE; 225 tree value = build_zero_init_1 (TREE_TYPE (field), 226 /*nelts=*/NULL_TREE, 227 static_storage_p, 228 new_field_size); 229 if (value) 230 CONSTRUCTOR_APPEND_ELT(v, field, value); 231 } 232 233 /* For unions, only the first field is initialized. */ 234 if (TREE_CODE (type) == UNION_TYPE) 235 break; 236 } 237 238 /* Build a constructor to contain the initializations. */ 239 init = build_constructor (type, v); 240 } 241 else if (TREE_CODE (type) == ARRAY_TYPE) 242 { 243 tree max_index; 244 vec<constructor_elt, va_gc> *v = NULL; 245 246 /* Iterate over the array elements, building initializations. */ 247 if (nelts) 248 max_index = fold_build2_loc (input_location, 249 MINUS_EXPR, TREE_TYPE (nelts), 250 nelts, integer_one_node); 251 else 252 max_index = array_type_nelts (type); 253 254 /* If we have an error_mark here, we should just return error mark 255 as we don't know the size of the array yet. */ 256 if (max_index == error_mark_node) 257 return error_mark_node; 258 gcc_assert (TREE_CODE (max_index) == INTEGER_CST); 259 260 /* A zero-sized array, which is accepted as an extension, will 261 have an upper bound of -1. */ 262 if (!tree_int_cst_equal (max_index, integer_minus_one_node)) 263 { 264 constructor_elt ce; 265 266 /* If this is a one element array, we just use a regular init. */ 267 if (tree_int_cst_equal (size_zero_node, max_index)) 268 ce.index = size_zero_node; 269 else 270 ce.index = build2 (RANGE_EXPR, sizetype, size_zero_node, 271 max_index); 272 273 ce.value = build_zero_init_1 (TREE_TYPE (type), 274 /*nelts=*/NULL_TREE, 275 static_storage_p, NULL_TREE); 276 if (ce.value) 277 { 278 vec_alloc (v, 1); 279 v->quick_push (ce); 280 } 281 } 282 283 /* Build a constructor to contain the initializations. */ 284 init = build_constructor (type, v); 285 } 286 else if (VECTOR_TYPE_P (type)) 287 init = build_zero_cst (type); 288 else 289 { 290 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE); 291 init = build_zero_cst (type); 292 } 293 294 /* In all cases, the initializer is a constant. */ 295 if (init) 296 TREE_CONSTANT (init) = 1; 297 298 return init; 299 } 300 301 /* Return an expression for the zero-initialization of an object with 302 type T. This expression will either be a constant (in the case 303 that T is a scalar), or a CONSTRUCTOR (in the case that T is an 304 aggregate), or NULL (in the case that T does not require 305 initialization). In either case, the value can be used as 306 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static 307 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS 308 is the number of elements in the array. If STATIC_STORAGE_P is 309 TRUE, initializers are only generated for entities for which 310 zero-initialization does not simply mean filling the storage with 311 zero bytes. */ 312 313 tree 314 build_zero_init (tree type, tree nelts, bool static_storage_p) 315 { 316 return build_zero_init_1 (type, nelts, static_storage_p, NULL_TREE); 317 } 318 319 /* Return a suitable initializer for value-initializing an object of type 320 TYPE, as described in [dcl.init]. */ 321 322 tree 323 build_value_init (tree type, tsubst_flags_t complain) 324 { 325 /* [dcl.init] 326 327 To value-initialize an object of type T means: 328 329 - if T is a class type (clause 9) with either no default constructor 330 (12.1) or a default constructor that is user-provided or deleted, 331 then the object is default-initialized; 332 333 - if T is a (possibly cv-qualified) class type without a user-provided 334 or deleted default constructor, then the object is zero-initialized 335 and the semantic constraints for default-initialization are checked, 336 and if T has a non-trivial default constructor, the object is 337 default-initialized; 338 339 - if T is an array type, then each element is value-initialized; 340 341 - otherwise, the object is zero-initialized. 342 343 A program that calls for default-initialization or 344 value-initialization of an entity of reference type is ill-formed. */ 345 346 /* The AGGR_INIT_EXPR tweaking below breaks in templates. */ 347 gcc_assert (!processing_template_decl 348 || (SCALAR_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)); 349 350 if (CLASS_TYPE_P (type) 351 && type_build_ctor_call (type)) 352 { 353 tree ctor = 354 build_special_member_call (NULL_TREE, complete_ctor_identifier, 355 NULL, type, LOOKUP_NORMAL, 356 complain); 357 if (ctor == error_mark_node) 358 return ctor; 359 tree fn = NULL_TREE; 360 if (TREE_CODE (ctor) == CALL_EXPR) 361 fn = get_callee_fndecl (ctor); 362 ctor = build_aggr_init_expr (type, ctor); 363 if (fn && user_provided_p (fn)) 364 return ctor; 365 else if (TYPE_HAS_COMPLEX_DFLT (type)) 366 { 367 /* This is a class that needs constructing, but doesn't have 368 a user-provided constructor. So we need to zero-initialize 369 the object and then call the implicitly defined ctor. 370 This will be handled in simplify_aggr_init_expr. */ 371 AGGR_INIT_ZERO_FIRST (ctor) = 1; 372 return ctor; 373 } 374 } 375 376 /* Discard any access checking during subobject initialization; 377 the checks are implied by the call to the ctor which we have 378 verified is OK (cpp0x/defaulted46.C). */ 379 push_deferring_access_checks (dk_deferred); 380 tree r = build_value_init_noctor (type, complain); 381 pop_deferring_access_checks (); 382 return r; 383 } 384 385 /* Like build_value_init, but don't call the constructor for TYPE. Used 386 for base initializers. */ 387 388 tree 389 build_value_init_noctor (tree type, tsubst_flags_t complain) 390 { 391 if (!COMPLETE_TYPE_P (type)) 392 { 393 if (complain & tf_error) 394 error ("value-initialization of incomplete type %qT", type); 395 return error_mark_node; 396 } 397 /* FIXME the class and array cases should just use digest_init once it is 398 SFINAE-enabled. */ 399 if (CLASS_TYPE_P (type)) 400 { 401 gcc_assert (!TYPE_HAS_COMPLEX_DFLT (type) 402 || errorcount != 0); 403 404 if (TREE_CODE (type) != UNION_TYPE) 405 { 406 tree field; 407 vec<constructor_elt, va_gc> *v = NULL; 408 409 /* Iterate over the fields, building initializations. */ 410 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field)) 411 { 412 tree ftype, value; 413 414 if (TREE_CODE (field) != FIELD_DECL) 415 continue; 416 417 ftype = TREE_TYPE (field); 418 419 if (ftype == error_mark_node) 420 continue; 421 422 /* We could skip vfields and fields of types with 423 user-defined constructors, but I think that won't improve 424 performance at all; it should be simpler in general just 425 to zero out the entire object than try to only zero the 426 bits that actually need it. */ 427 428 /* Note that for class types there will be FIELD_DECLs 429 corresponding to base classes as well. Thus, iterating 430 over TYPE_FIELDs will result in correct initialization of 431 all of the subobjects. */ 432 value = build_value_init (ftype, complain); 433 value = maybe_constant_init (value); 434 435 if (value == error_mark_node) 436 return error_mark_node; 437 438 CONSTRUCTOR_APPEND_ELT(v, field, value); 439 440 /* We shouldn't have gotten here for anything that would need 441 non-trivial initialization, and gimplify_init_ctor_preeval 442 would need to be fixed to allow it. */ 443 gcc_assert (TREE_CODE (value) != TARGET_EXPR 444 && TREE_CODE (value) != AGGR_INIT_EXPR); 445 } 446 447 /* Build a constructor to contain the zero- initializations. */ 448 return build_constructor (type, v); 449 } 450 } 451 else if (TREE_CODE (type) == ARRAY_TYPE) 452 { 453 vec<constructor_elt, va_gc> *v = NULL; 454 455 /* Iterate over the array elements, building initializations. */ 456 tree max_index = array_type_nelts (type); 457 458 /* If we have an error_mark here, we should just return error mark 459 as we don't know the size of the array yet. */ 460 if (max_index == error_mark_node) 461 { 462 if (complain & tf_error) 463 error ("cannot value-initialize array of unknown bound %qT", 464 type); 465 return error_mark_node; 466 } 467 gcc_assert (TREE_CODE (max_index) == INTEGER_CST); 468 469 /* A zero-sized array, which is accepted as an extension, will 470 have an upper bound of -1. */ 471 if (!tree_int_cst_equal (max_index, integer_minus_one_node)) 472 { 473 constructor_elt ce; 474 475 /* If this is a one element array, we just use a regular init. */ 476 if (tree_int_cst_equal (size_zero_node, max_index)) 477 ce.index = size_zero_node; 478 else 479 ce.index = build2 (RANGE_EXPR, sizetype, size_zero_node, max_index); 480 481 ce.value = build_value_init (TREE_TYPE (type), complain); 482 ce.value = maybe_constant_init (ce.value); 483 if (ce.value == error_mark_node) 484 return error_mark_node; 485 486 vec_alloc (v, 1); 487 v->quick_push (ce); 488 489 /* We shouldn't have gotten here for anything that would need 490 non-trivial initialization, and gimplify_init_ctor_preeval 491 would need to be fixed to allow it. */ 492 gcc_assert (TREE_CODE (ce.value) != TARGET_EXPR 493 && TREE_CODE (ce.value) != AGGR_INIT_EXPR); 494 } 495 496 /* Build a constructor to contain the initializations. */ 497 return build_constructor (type, v); 498 } 499 else if (TREE_CODE (type) == FUNCTION_TYPE) 500 { 501 if (complain & tf_error) 502 error ("value-initialization of function type %qT", type); 503 return error_mark_node; 504 } 505 else if (TREE_CODE (type) == REFERENCE_TYPE) 506 { 507 if (complain & tf_error) 508 error ("value-initialization of reference type %qT", type); 509 return error_mark_node; 510 } 511 512 return build_zero_init (type, NULL_TREE, /*static_storage_p=*/false); 513 } 514 515 /* Initialize current class with INIT, a TREE_LIST of 516 arguments for a target constructor. If TREE_LIST is void_type_node, 517 an empty initializer list was given. */ 518 519 static void 520 perform_target_ctor (tree init) 521 { 522 tree decl = current_class_ref; 523 tree type = current_class_type; 524 525 finish_expr_stmt (build_aggr_init (decl, init, 526 LOOKUP_NORMAL|LOOKUP_DELEGATING_CONS, 527 tf_warning_or_error)); 528 if (type_build_dtor_call (type)) 529 { 530 tree expr = build_delete (type, decl, sfk_complete_destructor, 531 LOOKUP_NORMAL 532 |LOOKUP_NONVIRTUAL 533 |LOOKUP_DESTRUCTOR, 534 0, tf_warning_or_error); 535 if (expr != error_mark_node 536 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)) 537 finish_eh_cleanup (expr); 538 } 539 } 540 541 /* Return the non-static data initializer for FIELD_DECL MEMBER. */ 542 543 static GTY((cache)) tree_cache_map *nsdmi_inst; 544 545 tree 546 get_nsdmi (tree member, bool in_ctor, tsubst_flags_t complain) 547 { 548 tree init; 549 tree save_ccp = current_class_ptr; 550 tree save_ccr = current_class_ref; 551 552 if (DECL_LANG_SPECIFIC (member) && DECL_TEMPLATE_INFO (member)) 553 { 554 init = DECL_INITIAL (DECL_TI_TEMPLATE (member)); 555 location_t expr_loc 556 = EXPR_LOC_OR_LOC (init, DECL_SOURCE_LOCATION (member)); 557 tree *slot; 558 if (TREE_CODE (init) == DEFAULT_ARG) 559 /* Unparsed. */; 560 else if (nsdmi_inst && (slot = nsdmi_inst->get (member))) 561 init = *slot; 562 /* Check recursive instantiation. */ 563 else if (DECL_INSTANTIATING_NSDMI_P (member)) 564 { 565 if (complain & tf_error) 566 error_at (expr_loc, "recursive instantiation of default member " 567 "initializer for %qD", member); 568 init = error_mark_node; 569 } 570 else 571 { 572 int un = cp_unevaluated_operand; 573 cp_unevaluated_operand = 0; 574 575 location_t sloc = input_location; 576 input_location = expr_loc; 577 578 DECL_INSTANTIATING_NSDMI_P (member) = 1; 579 580 inject_this_parameter (DECL_CONTEXT (member), TYPE_UNQUALIFIED); 581 582 start_lambda_scope (member); 583 584 /* Do deferred instantiation of the NSDMI. */ 585 init = (tsubst_copy_and_build 586 (init, DECL_TI_ARGS (member), 587 complain, member, /*function_p=*/false, 588 /*integral_constant_expression_p=*/false)); 589 init = digest_nsdmi_init (member, init, complain); 590 591 finish_lambda_scope (); 592 593 DECL_INSTANTIATING_NSDMI_P (member) = 0; 594 595 if (init != error_mark_node) 596 { 597 if (!nsdmi_inst) 598 nsdmi_inst = tree_cache_map::create_ggc (37); 599 nsdmi_inst->put (member, init); 600 } 601 602 input_location = sloc; 603 cp_unevaluated_operand = un; 604 } 605 } 606 else 607 init = DECL_INITIAL (member); 608 609 if (init && TREE_CODE (init) == DEFAULT_ARG) 610 { 611 if (complain & tf_error) 612 { 613 error ("default member initializer for %qD required before the end " 614 "of its enclosing class", member); 615 inform (location_of (init), "defined here"); 616 DECL_INITIAL (member) = error_mark_node; 617 } 618 init = error_mark_node; 619 } 620 621 if (in_ctor) 622 { 623 current_class_ptr = save_ccp; 624 current_class_ref = save_ccr; 625 } 626 else 627 { 628 /* Use a PLACEHOLDER_EXPR when we don't have a 'this' parameter to 629 refer to; constexpr evaluation knows what to do with it. */ 630 current_class_ref = build0 (PLACEHOLDER_EXPR, DECL_CONTEXT (member)); 631 current_class_ptr = build_address (current_class_ref); 632 } 633 634 /* Strip redundant TARGET_EXPR so we don't need to remap it, and 635 so the aggregate init code below will see a CONSTRUCTOR. */ 636 bool simple_target = (init && SIMPLE_TARGET_EXPR_P (init)); 637 if (simple_target) 638 init = TARGET_EXPR_INITIAL (init); 639 init = break_out_target_exprs (init, /*loc*/true); 640 if (simple_target && TREE_CODE (init) != CONSTRUCTOR) 641 /* Now put it back so C++17 copy elision works. */ 642 init = get_target_expr (init); 643 644 current_class_ptr = save_ccp; 645 current_class_ref = save_ccr; 646 return init; 647 } 648 649 /* Diagnose the flexible array MEMBER if its INITializer is non-null 650 and return true if so. Otherwise return false. */ 651 652 bool 653 maybe_reject_flexarray_init (tree member, tree init) 654 { 655 tree type = TREE_TYPE (member); 656 657 if (!init 658 || TREE_CODE (type) != ARRAY_TYPE 659 || TYPE_DOMAIN (type)) 660 return false; 661 662 /* Point at the flexible array member declaration if it's initialized 663 in-class, and at the ctor if it's initialized in a ctor member 664 initializer list. */ 665 location_t loc; 666 if (DECL_INITIAL (member) == init 667 || !current_function_decl 668 || DECL_DEFAULTED_FN (current_function_decl)) 669 loc = DECL_SOURCE_LOCATION (member); 670 else 671 loc = DECL_SOURCE_LOCATION (current_function_decl); 672 673 error_at (loc, "initializer for flexible array member %q#D", member); 674 return true; 675 } 676 677 /* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of 678 arguments. If TREE_LIST is void_type_node, an empty initializer 679 list was given; if NULL_TREE no initializer was given. */ 680 681 static void 682 perform_member_init (tree member, tree init) 683 { 684 tree decl; 685 tree type = TREE_TYPE (member); 686 687 /* Use the non-static data member initializer if there was no 688 mem-initializer for this field. */ 689 if (init == NULL_TREE) 690 init = get_nsdmi (member, /*ctor*/true, tf_warning_or_error); 691 692 if (init == error_mark_node) 693 return; 694 695 /* Effective C++ rule 12 requires that all data members be 696 initialized. */ 697 if (warn_ecpp && init == NULL_TREE && TREE_CODE (type) != ARRAY_TYPE) 698 warning_at (DECL_SOURCE_LOCATION (current_function_decl), OPT_Weffc__, 699 "%qD should be initialized in the member initialization list", 700 member); 701 702 /* Get an lvalue for the data member. */ 703 decl = build_class_member_access_expr (current_class_ref, member, 704 /*access_path=*/NULL_TREE, 705 /*preserve_reference=*/true, 706 tf_warning_or_error); 707 if (decl == error_mark_node) 708 return; 709 710 if (warn_init_self && init && TREE_CODE (init) == TREE_LIST 711 && TREE_CHAIN (init) == NULL_TREE) 712 { 713 tree val = TREE_VALUE (init); 714 /* Handle references. */ 715 if (REFERENCE_REF_P (val)) 716 val = TREE_OPERAND (val, 0); 717 if (TREE_CODE (val) == COMPONENT_REF && TREE_OPERAND (val, 1) == member 718 && TREE_OPERAND (val, 0) == current_class_ref) 719 warning_at (DECL_SOURCE_LOCATION (current_function_decl), 720 OPT_Winit_self, "%qD is initialized with itself", 721 member); 722 } 723 724 if (init == void_type_node) 725 { 726 /* mem() means value-initialization. */ 727 if (TREE_CODE (type) == ARRAY_TYPE) 728 { 729 init = build_vec_init_expr (type, init, tf_warning_or_error); 730 init = build2 (INIT_EXPR, type, decl, init); 731 finish_expr_stmt (init); 732 } 733 else 734 { 735 tree value = build_value_init (type, tf_warning_or_error); 736 if (value == error_mark_node) 737 return; 738 init = build2 (INIT_EXPR, type, decl, value); 739 finish_expr_stmt (init); 740 } 741 } 742 /* Deal with this here, as we will get confused if we try to call the 743 assignment op for an anonymous union. This can happen in a 744 synthesized copy constructor. */ 745 else if (ANON_AGGR_TYPE_P (type)) 746 { 747 if (init) 748 { 749 init = build2 (INIT_EXPR, type, decl, TREE_VALUE (init)); 750 finish_expr_stmt (init); 751 } 752 } 753 else if (init 754 && (TREE_CODE (type) == REFERENCE_TYPE 755 /* Pre-digested NSDMI. */ 756 || (((TREE_CODE (init) == CONSTRUCTOR 757 && TREE_TYPE (init) == type) 758 /* { } mem-initializer. */ 759 || (TREE_CODE (init) == TREE_LIST 760 && DIRECT_LIST_INIT_P (TREE_VALUE (init)))) 761 && (CP_AGGREGATE_TYPE_P (type) 762 || is_std_init_list (type))))) 763 { 764 /* With references and list-initialization, we need to deal with 765 extending temporary lifetimes. 12.2p5: "A temporary bound to a 766 reference member in a constructor’s ctor-initializer (12.6.2) 767 persists until the constructor exits." */ 768 unsigned i; tree t; 769 vec<tree, va_gc> *cleanups = make_tree_vector (); 770 if (TREE_CODE (init) == TREE_LIST) 771 init = build_x_compound_expr_from_list (init, ELK_MEM_INIT, 772 tf_warning_or_error); 773 if (TREE_TYPE (init) != type) 774 { 775 if (BRACE_ENCLOSED_INITIALIZER_P (init) 776 && CP_AGGREGATE_TYPE_P (type)) 777 init = reshape_init (type, init, tf_warning_or_error); 778 init = digest_init (type, init, tf_warning_or_error); 779 } 780 if (init == error_mark_node) 781 return; 782 /* A FIELD_DECL doesn't really have a suitable lifetime, but 783 make_temporary_var_for_ref_to_temp will treat it as automatic and 784 set_up_extended_ref_temp wants to use the decl in a warning. */ 785 init = extend_ref_init_temps (member, init, &cleanups); 786 if (TREE_CODE (type) == ARRAY_TYPE 787 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (type))) 788 init = build_vec_init_expr (type, init, tf_warning_or_error); 789 init = build2 (INIT_EXPR, type, decl, init); 790 finish_expr_stmt (init); 791 FOR_EACH_VEC_ELT (*cleanups, i, t) 792 push_cleanup (decl, t, false); 793 release_tree_vector (cleanups); 794 } 795 else if (type_build_ctor_call (type) 796 || (init && CLASS_TYPE_P (strip_array_types (type)))) 797 { 798 if (TREE_CODE (type) == ARRAY_TYPE) 799 { 800 if (init) 801 { 802 /* Check to make sure the member initializer is valid and 803 something like a CONSTRUCTOR in: T a[] = { 1, 2 } and 804 if it isn't, return early to avoid triggering another 805 error below. */ 806 if (maybe_reject_flexarray_init (member, init)) 807 return; 808 809 if (TREE_CODE (init) != TREE_LIST || TREE_CHAIN (init)) 810 init = error_mark_node; 811 else 812 init = TREE_VALUE (init); 813 814 if (BRACE_ENCLOSED_INITIALIZER_P (init)) 815 init = digest_init (type, init, tf_warning_or_error); 816 } 817 if (init == NULL_TREE 818 || same_type_ignoring_top_level_qualifiers_p (type, 819 TREE_TYPE (init))) 820 { 821 if (TYPE_DOMAIN (type) && TYPE_MAX_VALUE (TYPE_DOMAIN (type))) 822 { 823 /* Initialize the array only if it's not a flexible 824 array member (i.e., if it has an upper bound). */ 825 init = build_vec_init_expr (type, init, tf_warning_or_error); 826 init = build2 (INIT_EXPR, type, decl, init); 827 finish_expr_stmt (init); 828 } 829 } 830 else 831 error ("invalid initializer for array member %q#D", member); 832 } 833 else 834 { 835 int flags = LOOKUP_NORMAL; 836 if (DECL_DEFAULTED_FN (current_function_decl)) 837 flags |= LOOKUP_DEFAULTED; 838 if (CP_TYPE_CONST_P (type) 839 && init == NULL_TREE 840 && default_init_uninitialized_part (type)) 841 { 842 /* TYPE_NEEDS_CONSTRUCTING can be set just because we have a 843 vtable; still give this diagnostic. */ 844 if (permerror (DECL_SOURCE_LOCATION (current_function_decl), 845 "uninitialized const member in %q#T", type)) 846 inform (DECL_SOURCE_LOCATION (member), 847 "%q#D should be initialized", member ); 848 } 849 finish_expr_stmt (build_aggr_init (decl, init, flags, 850 tf_warning_or_error)); 851 } 852 } 853 else 854 { 855 if (init == NULL_TREE) 856 { 857 tree core_type; 858 /* member traversal: note it leaves init NULL */ 859 if (TREE_CODE (type) == REFERENCE_TYPE) 860 { 861 if (permerror (DECL_SOURCE_LOCATION (current_function_decl), 862 "uninitialized reference member in %q#T", type)) 863 inform (DECL_SOURCE_LOCATION (member), 864 "%q#D should be initialized", member); 865 } 866 else if (CP_TYPE_CONST_P (type)) 867 { 868 if (permerror (DECL_SOURCE_LOCATION (current_function_decl), 869 "uninitialized const member in %q#T", type)) 870 inform (DECL_SOURCE_LOCATION (member), 871 "%q#D should be initialized", member ); 872 } 873 874 core_type = strip_array_types (type); 875 876 if (CLASS_TYPE_P (core_type) 877 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type) 878 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))) 879 diagnose_uninitialized_cst_or_ref_member (core_type, 880 /*using_new=*/false, 881 /*complain=*/true); 882 } 883 else if (TREE_CODE (init) == TREE_LIST) 884 /* There was an explicit member initialization. Do some work 885 in that case. */ 886 init = build_x_compound_expr_from_list (init, ELK_MEM_INIT, 887 tf_warning_or_error); 888 889 /* Reject a member initializer for a flexible array member. */ 890 if (init && !maybe_reject_flexarray_init (member, init)) 891 finish_expr_stmt (cp_build_modify_expr (input_location, decl, 892 INIT_EXPR, init, 893 tf_warning_or_error)); 894 } 895 896 if (type_build_dtor_call (type)) 897 { 898 tree expr; 899 900 expr = build_class_member_access_expr (current_class_ref, member, 901 /*access_path=*/NULL_TREE, 902 /*preserve_reference=*/false, 903 tf_warning_or_error); 904 expr = build_delete (type, expr, sfk_complete_destructor, 905 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0, 906 tf_warning_or_error); 907 908 if (expr != error_mark_node 909 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)) 910 finish_eh_cleanup (expr); 911 } 912 } 913 914 /* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all 915 the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */ 916 917 static tree 918 build_field_list (tree t, tree list, int *uses_unions_or_anon_p) 919 { 920 tree fields; 921 922 /* Note whether or not T is a union. */ 923 if (TREE_CODE (t) == UNION_TYPE) 924 *uses_unions_or_anon_p = 1; 925 926 for (fields = TYPE_FIELDS (t); fields; fields = DECL_CHAIN (fields)) 927 { 928 tree fieldtype; 929 930 /* Skip CONST_DECLs for enumeration constants and so forth. */ 931 if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields)) 932 continue; 933 934 fieldtype = TREE_TYPE (fields); 935 936 /* For an anonymous struct or union, we must recursively 937 consider the fields of the anonymous type. They can be 938 directly initialized from the constructor. */ 939 if (ANON_AGGR_TYPE_P (fieldtype)) 940 { 941 /* Add this field itself. Synthesized copy constructors 942 initialize the entire aggregate. */ 943 list = tree_cons (fields, NULL_TREE, list); 944 /* And now add the fields in the anonymous aggregate. */ 945 list = build_field_list (fieldtype, list, uses_unions_or_anon_p); 946 *uses_unions_or_anon_p = 1; 947 } 948 /* Add this field. */ 949 else if (DECL_NAME (fields)) 950 list = tree_cons (fields, NULL_TREE, list); 951 } 952 953 return list; 954 } 955 956 /* Return the innermost aggregate scope for FIELD, whether that is 957 the enclosing class or an anonymous aggregate within it. */ 958 959 static tree 960 innermost_aggr_scope (tree field) 961 { 962 if (ANON_AGGR_TYPE_P (TREE_TYPE (field))) 963 return TREE_TYPE (field); 964 else 965 return DECL_CONTEXT (field); 966 } 967 968 /* The MEM_INITS are a TREE_LIST. The TREE_PURPOSE of each list gives 969 a FIELD_DECL or BINFO in T that needs initialization. The 970 TREE_VALUE gives the initializer, or list of initializer arguments. 971 972 Return a TREE_LIST containing all of the initializations required 973 for T, in the order in which they should be performed. The output 974 list has the same format as the input. */ 975 976 static tree 977 sort_mem_initializers (tree t, tree mem_inits) 978 { 979 tree init; 980 tree base, binfo, base_binfo; 981 tree sorted_inits; 982 tree next_subobject; 983 vec<tree, va_gc> *vbases; 984 int i; 985 int uses_unions_or_anon_p = 0; 986 987 /* Build up a list of initializations. The TREE_PURPOSE of entry 988 will be the subobject (a FIELD_DECL or BINFO) to initialize. The 989 TREE_VALUE will be the constructor arguments, or NULL if no 990 explicit initialization was provided. */ 991 sorted_inits = NULL_TREE; 992 993 /* Process the virtual bases. */ 994 for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0; 995 vec_safe_iterate (vbases, i, &base); i++) 996 sorted_inits = tree_cons (base, NULL_TREE, sorted_inits); 997 998 /* Process the direct bases. */ 999 for (binfo = TYPE_BINFO (t), i = 0; 1000 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i) 1001 if (!BINFO_VIRTUAL_P (base_binfo)) 1002 sorted_inits = tree_cons (base_binfo, NULL_TREE, sorted_inits); 1003 1004 /* Process the non-static data members. */ 1005 sorted_inits = build_field_list (t, sorted_inits, &uses_unions_or_anon_p); 1006 /* Reverse the entire list of initializations, so that they are in 1007 the order that they will actually be performed. */ 1008 sorted_inits = nreverse (sorted_inits); 1009 1010 /* If the user presented the initializers in an order different from 1011 that in which they will actually occur, we issue a warning. Keep 1012 track of the next subobject which can be explicitly initialized 1013 without issuing a warning. */ 1014 next_subobject = sorted_inits; 1015 1016 /* Go through the explicit initializers, filling in TREE_PURPOSE in 1017 the SORTED_INITS. */ 1018 for (init = mem_inits; init; init = TREE_CHAIN (init)) 1019 { 1020 tree subobject; 1021 tree subobject_init; 1022 1023 subobject = TREE_PURPOSE (init); 1024 1025 /* If the explicit initializers are in sorted order, then 1026 SUBOBJECT will be NEXT_SUBOBJECT, or something following 1027 it. */ 1028 for (subobject_init = next_subobject; 1029 subobject_init; 1030 subobject_init = TREE_CHAIN (subobject_init)) 1031 if (TREE_PURPOSE (subobject_init) == subobject) 1032 break; 1033 1034 /* Issue a warning if the explicit initializer order does not 1035 match that which will actually occur. 1036 ??? Are all these on the correct lines? */ 1037 if (warn_reorder && !subobject_init) 1038 { 1039 if (TREE_CODE (TREE_PURPOSE (next_subobject)) == FIELD_DECL) 1040 warning_at (DECL_SOURCE_LOCATION (TREE_PURPOSE (next_subobject)), 1041 OPT_Wreorder, "%qD will be initialized after", 1042 TREE_PURPOSE (next_subobject)); 1043 else 1044 warning (OPT_Wreorder, "base %qT will be initialized after", 1045 TREE_PURPOSE (next_subobject)); 1046 if (TREE_CODE (subobject) == FIELD_DECL) 1047 warning_at (DECL_SOURCE_LOCATION (subobject), 1048 OPT_Wreorder, " %q#D", subobject); 1049 else 1050 warning (OPT_Wreorder, " base %qT", subobject); 1051 warning_at (DECL_SOURCE_LOCATION (current_function_decl), 1052 OPT_Wreorder, " when initialized here"); 1053 } 1054 1055 /* Look again, from the beginning of the list. */ 1056 if (!subobject_init) 1057 { 1058 subobject_init = sorted_inits; 1059 while (TREE_PURPOSE (subobject_init) != subobject) 1060 subobject_init = TREE_CHAIN (subobject_init); 1061 } 1062 1063 /* It is invalid to initialize the same subobject more than 1064 once. */ 1065 if (TREE_VALUE (subobject_init)) 1066 { 1067 if (TREE_CODE (subobject) == FIELD_DECL) 1068 error_at (DECL_SOURCE_LOCATION (current_function_decl), 1069 "multiple initializations given for %qD", 1070 subobject); 1071 else 1072 error_at (DECL_SOURCE_LOCATION (current_function_decl), 1073 "multiple initializations given for base %qT", 1074 subobject); 1075 } 1076 1077 /* Record the initialization. */ 1078 TREE_VALUE (subobject_init) = TREE_VALUE (init); 1079 next_subobject = subobject_init; 1080 } 1081 1082 /* [class.base.init] 1083 1084 If a ctor-initializer specifies more than one mem-initializer for 1085 multiple members of the same union (including members of 1086 anonymous unions), the ctor-initializer is ill-formed. 1087 1088 Here we also splice out uninitialized union members. */ 1089 if (uses_unions_or_anon_p) 1090 { 1091 tree *last_p = NULL; 1092 tree *p; 1093 for (p = &sorted_inits; *p; ) 1094 { 1095 tree field; 1096 tree ctx; 1097 1098 init = *p; 1099 1100 field = TREE_PURPOSE (init); 1101 1102 /* Skip base classes. */ 1103 if (TREE_CODE (field) != FIELD_DECL) 1104 goto next; 1105 1106 /* If this is an anonymous aggregate with no explicit initializer, 1107 splice it out. */ 1108 if (!TREE_VALUE (init) && ANON_AGGR_TYPE_P (TREE_TYPE (field))) 1109 goto splice; 1110 1111 /* See if this field is a member of a union, or a member of a 1112 structure contained in a union, etc. */ 1113 ctx = innermost_aggr_scope (field); 1114 1115 /* If this field is not a member of a union, skip it. */ 1116 if (TREE_CODE (ctx) != UNION_TYPE 1117 && !ANON_AGGR_TYPE_P (ctx)) 1118 goto next; 1119 1120 /* If this union member has no explicit initializer and no NSDMI, 1121 splice it out. */ 1122 if (TREE_VALUE (init) || DECL_INITIAL (field)) 1123 /* OK. */; 1124 else 1125 goto splice; 1126 1127 /* It's only an error if we have two initializers for the same 1128 union type. */ 1129 if (!last_p) 1130 { 1131 last_p = p; 1132 goto next; 1133 } 1134 1135 /* See if LAST_FIELD and the field initialized by INIT are 1136 members of the same union (or the union itself). If so, there's 1137 a problem, unless they're actually members of the same structure 1138 which is itself a member of a union. For example, given: 1139 1140 union { struct { int i; int j; }; }; 1141 1142 initializing both `i' and `j' makes sense. */ 1143 ctx = common_enclosing_class 1144 (innermost_aggr_scope (field), 1145 innermost_aggr_scope (TREE_PURPOSE (*last_p))); 1146 1147 if (ctx && (TREE_CODE (ctx) == UNION_TYPE 1148 || ctx == TREE_TYPE (TREE_PURPOSE (*last_p)))) 1149 { 1150 /* A mem-initializer hides an NSDMI. */ 1151 if (TREE_VALUE (init) && !TREE_VALUE (*last_p)) 1152 *last_p = TREE_CHAIN (*last_p); 1153 else if (TREE_VALUE (*last_p) && !TREE_VALUE (init)) 1154 goto splice; 1155 else 1156 { 1157 error_at (DECL_SOURCE_LOCATION (current_function_decl), 1158 "initializations for multiple members of %qT", 1159 ctx); 1160 goto splice; 1161 } 1162 } 1163 1164 last_p = p; 1165 1166 next: 1167 p = &TREE_CHAIN (*p); 1168 continue; 1169 splice: 1170 *p = TREE_CHAIN (*p); 1171 continue; 1172 } 1173 } 1174 1175 return sorted_inits; 1176 } 1177 1178 /* Callback for cp_walk_tree to mark all PARM_DECLs in a tree as read. */ 1179 1180 static tree 1181 mark_exp_read_r (tree *tp, int *, void *) 1182 { 1183 tree t = *tp; 1184 if (TREE_CODE (t) == PARM_DECL) 1185 mark_exp_read (t); 1186 return NULL_TREE; 1187 } 1188 1189 /* Initialize all bases and members of CURRENT_CLASS_TYPE. MEM_INITS 1190 is a TREE_LIST giving the explicit mem-initializer-list for the 1191 constructor. The TREE_PURPOSE of each entry is a subobject (a 1192 FIELD_DECL or a BINFO) of the CURRENT_CLASS_TYPE. The TREE_VALUE 1193 is a TREE_LIST giving the arguments to the constructor or 1194 void_type_node for an empty list of arguments. */ 1195 1196 void 1197 emit_mem_initializers (tree mem_inits) 1198 { 1199 int flags = LOOKUP_NORMAL; 1200 1201 /* We will already have issued an error message about the fact that 1202 the type is incomplete. */ 1203 if (!COMPLETE_TYPE_P (current_class_type)) 1204 return; 1205 1206 if (mem_inits 1207 && TYPE_P (TREE_PURPOSE (mem_inits)) 1208 && same_type_p (TREE_PURPOSE (mem_inits), current_class_type)) 1209 { 1210 /* Delegating constructor. */ 1211 gcc_assert (TREE_CHAIN (mem_inits) == NULL_TREE); 1212 perform_target_ctor (TREE_VALUE (mem_inits)); 1213 return; 1214 } 1215 1216 if (DECL_DEFAULTED_FN (current_function_decl) 1217 && ! DECL_INHERITED_CTOR (current_function_decl)) 1218 flags |= LOOKUP_DEFAULTED; 1219 1220 /* Sort the mem-initializers into the order in which the 1221 initializations should be performed. */ 1222 mem_inits = sort_mem_initializers (current_class_type, mem_inits); 1223 1224 in_base_initializer = 1; 1225 1226 /* Initialize base classes. */ 1227 for (; (mem_inits 1228 && TREE_CODE (TREE_PURPOSE (mem_inits)) != FIELD_DECL); 1229 mem_inits = TREE_CHAIN (mem_inits)) 1230 { 1231 tree subobject = TREE_PURPOSE (mem_inits); 1232 tree arguments = TREE_VALUE (mem_inits); 1233 1234 /* We already have issued an error message. */ 1235 if (arguments == error_mark_node) 1236 continue; 1237 1238 /* Suppress access control when calling the inherited ctor. */ 1239 bool inherited_base = (DECL_INHERITED_CTOR (current_function_decl) 1240 && flag_new_inheriting_ctors 1241 && arguments); 1242 if (inherited_base) 1243 push_deferring_access_checks (dk_deferred); 1244 1245 if (arguments == NULL_TREE) 1246 { 1247 /* If these initializations are taking place in a copy constructor, 1248 the base class should probably be explicitly initialized if there 1249 is a user-defined constructor in the base class (other than the 1250 default constructor, which will be called anyway). */ 1251 if (extra_warnings 1252 && DECL_COPY_CONSTRUCTOR_P (current_function_decl) 1253 && type_has_user_nondefault_constructor (BINFO_TYPE (subobject))) 1254 warning_at (DECL_SOURCE_LOCATION (current_function_decl), 1255 OPT_Wextra, "base class %q#T should be explicitly " 1256 "initialized in the copy constructor", 1257 BINFO_TYPE (subobject)); 1258 } 1259 1260 /* Initialize the base. */ 1261 if (!BINFO_VIRTUAL_P (subobject)) 1262 { 1263 tree base_addr; 1264 1265 base_addr = build_base_path (PLUS_EXPR, current_class_ptr, 1266 subobject, 1, tf_warning_or_error); 1267 expand_aggr_init_1 (subobject, NULL_TREE, 1268 cp_build_fold_indirect_ref (base_addr), 1269 arguments, 1270 flags, 1271 tf_warning_or_error); 1272 expand_cleanup_for_base (subobject, NULL_TREE); 1273 } 1274 else if (!ABSTRACT_CLASS_TYPE_P (current_class_type)) 1275 /* C++14 DR1658 Means we do not have to construct vbases of 1276 abstract classes. */ 1277 construct_virtual_base (subobject, arguments); 1278 else 1279 /* When not constructing vbases of abstract classes, at least mark 1280 the arguments expressions as read to avoid 1281 -Wunused-but-set-parameter false positives. */ 1282 cp_walk_tree (&arguments, mark_exp_read_r, NULL, NULL); 1283 1284 if (inherited_base) 1285 pop_deferring_access_checks (); 1286 } 1287 in_base_initializer = 0; 1288 1289 /* Initialize the vptrs. */ 1290 initialize_vtbl_ptrs (current_class_ptr); 1291 1292 /* Initialize the data members. */ 1293 while (mem_inits) 1294 { 1295 perform_member_init (TREE_PURPOSE (mem_inits), 1296 TREE_VALUE (mem_inits)); 1297 mem_inits = TREE_CHAIN (mem_inits); 1298 } 1299 } 1300 1301 /* Returns the address of the vtable (i.e., the value that should be 1302 assigned to the vptr) for BINFO. */ 1303 1304 tree 1305 build_vtbl_address (tree binfo) 1306 { 1307 tree binfo_for = binfo; 1308 tree vtbl; 1309 1310 if (BINFO_VPTR_INDEX (binfo) && BINFO_VIRTUAL_P (binfo)) 1311 /* If this is a virtual primary base, then the vtable we want to store 1312 is that for the base this is being used as the primary base of. We 1313 can't simply skip the initialization, because we may be expanding the 1314 inits of a subobject constructor where the virtual base layout 1315 can be different. */ 1316 while (BINFO_PRIMARY_P (binfo_for)) 1317 binfo_for = BINFO_INHERITANCE_CHAIN (binfo_for); 1318 1319 /* Figure out what vtable BINFO's vtable is based on, and mark it as 1320 used. */ 1321 vtbl = get_vtbl_decl_for_binfo (binfo_for); 1322 TREE_USED (vtbl) = true; 1323 1324 /* Now compute the address to use when initializing the vptr. */ 1325 vtbl = unshare_expr (BINFO_VTABLE (binfo_for)); 1326 if (VAR_P (vtbl)) 1327 vtbl = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (vtbl)), vtbl); 1328 1329 return vtbl; 1330 } 1331 1332 /* This code sets up the virtual function tables appropriate for 1333 the pointer DECL. It is a one-ply initialization. 1334 1335 BINFO is the exact type that DECL is supposed to be. In 1336 multiple inheritance, this might mean "C's A" if C : A, B. */ 1337 1338 static void 1339 expand_virtual_init (tree binfo, tree decl) 1340 { 1341 tree vtbl, vtbl_ptr; 1342 tree vtt_index; 1343 1344 /* Compute the initializer for vptr. */ 1345 vtbl = build_vtbl_address (binfo); 1346 1347 /* We may get this vptr from a VTT, if this is a subobject 1348 constructor or subobject destructor. */ 1349 vtt_index = BINFO_VPTR_INDEX (binfo); 1350 if (vtt_index) 1351 { 1352 tree vtbl2; 1353 tree vtt_parm; 1354 1355 /* Compute the value to use, when there's a VTT. */ 1356 vtt_parm = current_vtt_parm; 1357 vtbl2 = fold_build_pointer_plus (vtt_parm, vtt_index); 1358 vtbl2 = cp_build_fold_indirect_ref (vtbl2); 1359 vtbl2 = convert (TREE_TYPE (vtbl), vtbl2); 1360 1361 /* The actual initializer is the VTT value only in the subobject 1362 constructor. In maybe_clone_body we'll substitute NULL for 1363 the vtt_parm in the case of the non-subobject constructor. */ 1364 vtbl = build_if_in_charge (vtbl, vtbl2); 1365 } 1366 1367 /* Compute the location of the vtpr. */ 1368 vtbl_ptr = build_vfield_ref (cp_build_fold_indirect_ref (decl), 1369 TREE_TYPE (binfo)); 1370 gcc_assert (vtbl_ptr != error_mark_node); 1371 1372 /* Assign the vtable to the vptr. */ 1373 vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl, 0, tf_warning_or_error); 1374 finish_expr_stmt (cp_build_modify_expr (input_location, vtbl_ptr, NOP_EXPR, 1375 vtbl, tf_warning_or_error)); 1376 } 1377 1378 /* If an exception is thrown in a constructor, those base classes already 1379 constructed must be destroyed. This function creates the cleanup 1380 for BINFO, which has just been constructed. If FLAG is non-NULL, 1381 it is a DECL which is nonzero when this base needs to be 1382 destroyed. */ 1383 1384 static void 1385 expand_cleanup_for_base (tree binfo, tree flag) 1386 { 1387 tree expr; 1388 1389 if (!type_build_dtor_call (BINFO_TYPE (binfo))) 1390 return; 1391 1392 /* Call the destructor. */ 1393 expr = build_special_member_call (current_class_ref, 1394 base_dtor_identifier, 1395 NULL, 1396 binfo, 1397 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL, 1398 tf_warning_or_error); 1399 1400 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo))) 1401 return; 1402 1403 if (flag) 1404 expr = fold_build3_loc (input_location, 1405 COND_EXPR, void_type_node, 1406 c_common_truthvalue_conversion (input_location, flag), 1407 expr, integer_zero_node); 1408 1409 finish_eh_cleanup (expr); 1410 } 1411 1412 /* Construct the virtual base-class VBASE passing the ARGUMENTS to its 1413 constructor. */ 1414 1415 static void 1416 construct_virtual_base (tree vbase, tree arguments) 1417 { 1418 tree inner_if_stmt; 1419 tree exp; 1420 tree flag; 1421 1422 /* If there are virtual base classes with destructors, we need to 1423 emit cleanups to destroy them if an exception is thrown during 1424 the construction process. These exception regions (i.e., the 1425 period during which the cleanups must occur) begin from the time 1426 the construction is complete to the end of the function. If we 1427 create a conditional block in which to initialize the 1428 base-classes, then the cleanup region for the virtual base begins 1429 inside a block, and ends outside of that block. This situation 1430 confuses the sjlj exception-handling code. Therefore, we do not 1431 create a single conditional block, but one for each 1432 initialization. (That way the cleanup regions always begin 1433 in the outer block.) We trust the back end to figure out 1434 that the FLAG will not change across initializations, and 1435 avoid doing multiple tests. */ 1436 flag = DECL_CHAIN (DECL_ARGUMENTS (current_function_decl)); 1437 inner_if_stmt = begin_if_stmt (); 1438 finish_if_stmt_cond (flag, inner_if_stmt); 1439 1440 /* Compute the location of the virtual base. If we're 1441 constructing virtual bases, then we must be the most derived 1442 class. Therefore, we don't have to look up the virtual base; 1443 we already know where it is. */ 1444 exp = convert_to_base_statically (current_class_ref, vbase); 1445 1446 expand_aggr_init_1 (vbase, current_class_ref, exp, arguments, 1447 0, tf_warning_or_error); 1448 finish_then_clause (inner_if_stmt); 1449 finish_if_stmt (inner_if_stmt); 1450 1451 expand_cleanup_for_base (vbase, flag); 1452 } 1453 1454 /* Find the context in which this FIELD can be initialized. */ 1455 1456 static tree 1457 initializing_context (tree field) 1458 { 1459 tree t = DECL_CONTEXT (field); 1460 1461 /* Anonymous union members can be initialized in the first enclosing 1462 non-anonymous union context. */ 1463 while (t && ANON_AGGR_TYPE_P (t)) 1464 t = TYPE_CONTEXT (t); 1465 return t; 1466 } 1467 1468 /* Function to give error message if member initialization specification 1469 is erroneous. FIELD is the member we decided to initialize. 1470 TYPE is the type for which the initialization is being performed. 1471 FIELD must be a member of TYPE. 1472 1473 MEMBER_NAME is the name of the member. */ 1474 1475 static int 1476 member_init_ok_or_else (tree field, tree type, tree member_name) 1477 { 1478 if (field == error_mark_node) 1479 return 0; 1480 if (!field) 1481 { 1482 error ("class %qT does not have any field named %qD", type, 1483 member_name); 1484 return 0; 1485 } 1486 if (VAR_P (field)) 1487 { 1488 error ("%q#D is a static data member; it can only be " 1489 "initialized at its definition", 1490 field); 1491 return 0; 1492 } 1493 if (TREE_CODE (field) != FIELD_DECL) 1494 { 1495 error ("%q#D is not a non-static data member of %qT", 1496 field, type); 1497 return 0; 1498 } 1499 if (initializing_context (field) != type) 1500 { 1501 error ("class %qT does not have any field named %qD", type, 1502 member_name); 1503 return 0; 1504 } 1505 1506 return 1; 1507 } 1508 1509 /* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it 1510 is a _TYPE node or TYPE_DECL which names a base for that type. 1511 Check the validity of NAME, and return either the base _TYPE, base 1512 binfo, or the FIELD_DECL of the member. If NAME is invalid, return 1513 NULL_TREE and issue a diagnostic. 1514 1515 An old style unnamed direct single base construction is permitted, 1516 where NAME is NULL. */ 1517 1518 tree 1519 expand_member_init (tree name) 1520 { 1521 tree basetype; 1522 tree field; 1523 1524 if (!current_class_ref) 1525 return NULL_TREE; 1526 1527 if (!name) 1528 { 1529 /* This is an obsolete unnamed base class initializer. The 1530 parser will already have warned about its use. */ 1531 switch (BINFO_N_BASE_BINFOS (TYPE_BINFO (current_class_type))) 1532 { 1533 case 0: 1534 error ("unnamed initializer for %qT, which has no base classes", 1535 current_class_type); 1536 return NULL_TREE; 1537 case 1: 1538 basetype = BINFO_TYPE 1539 (BINFO_BASE_BINFO (TYPE_BINFO (current_class_type), 0)); 1540 break; 1541 default: 1542 error ("unnamed initializer for %qT, which uses multiple inheritance", 1543 current_class_type); 1544 return NULL_TREE; 1545 } 1546 } 1547 else if (TYPE_P (name)) 1548 { 1549 basetype = TYPE_MAIN_VARIANT (name); 1550 name = TYPE_NAME (name); 1551 } 1552 else if (TREE_CODE (name) == TYPE_DECL) 1553 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (name)); 1554 else 1555 basetype = NULL_TREE; 1556 1557 if (basetype) 1558 { 1559 tree class_binfo; 1560 tree direct_binfo; 1561 tree virtual_binfo; 1562 int i; 1563 1564 if (current_template_parms 1565 || same_type_p (basetype, current_class_type)) 1566 return basetype; 1567 1568 class_binfo = TYPE_BINFO (current_class_type); 1569 direct_binfo = NULL_TREE; 1570 virtual_binfo = NULL_TREE; 1571 1572 /* Look for a direct base. */ 1573 for (i = 0; BINFO_BASE_ITERATE (class_binfo, i, direct_binfo); ++i) 1574 if (SAME_BINFO_TYPE_P (BINFO_TYPE (direct_binfo), basetype)) 1575 break; 1576 1577 /* Look for a virtual base -- unless the direct base is itself 1578 virtual. */ 1579 if (!direct_binfo || !BINFO_VIRTUAL_P (direct_binfo)) 1580 virtual_binfo = binfo_for_vbase (basetype, current_class_type); 1581 1582 /* [class.base.init] 1583 1584 If a mem-initializer-id is ambiguous because it designates 1585 both a direct non-virtual base class and an inherited virtual 1586 base class, the mem-initializer is ill-formed. */ 1587 if (direct_binfo && virtual_binfo) 1588 { 1589 error ("%qD is both a direct base and an indirect virtual base", 1590 basetype); 1591 return NULL_TREE; 1592 } 1593 1594 if (!direct_binfo && !virtual_binfo) 1595 { 1596 if (CLASSTYPE_VBASECLASSES (current_class_type)) 1597 error ("type %qT is not a direct or virtual base of %qT", 1598 basetype, current_class_type); 1599 else 1600 error ("type %qT is not a direct base of %qT", 1601 basetype, current_class_type); 1602 return NULL_TREE; 1603 } 1604 1605 return direct_binfo ? direct_binfo : virtual_binfo; 1606 } 1607 else 1608 { 1609 if (identifier_p (name)) 1610 field = lookup_field (current_class_type, name, 1, false); 1611 else 1612 field = name; 1613 1614 if (member_init_ok_or_else (field, current_class_type, name)) 1615 return field; 1616 } 1617 1618 return NULL_TREE; 1619 } 1620 1621 /* This is like `expand_member_init', only it stores one aggregate 1622 value into another. 1623 1624 INIT comes in two flavors: it is either a value which 1625 is to be stored in EXP, or it is a parameter list 1626 to go to a constructor, which will operate on EXP. 1627 If INIT is not a parameter list for a constructor, then set 1628 LOOKUP_ONLYCONVERTING. 1629 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of 1630 the initializer, if FLAGS is 0, then it is the (init) form. 1631 If `init' is a CONSTRUCTOR, then we emit a warning message, 1632 explaining that such initializations are invalid. 1633 1634 If INIT resolves to a CALL_EXPR which happens to return 1635 something of the type we are looking for, then we know 1636 that we can safely use that call to perform the 1637 initialization. 1638 1639 The virtual function table pointer cannot be set up here, because 1640 we do not really know its type. 1641 1642 This never calls operator=(). 1643 1644 When initializing, nothing is CONST. 1645 1646 A default copy constructor may have to be used to perform the 1647 initialization. 1648 1649 A constructor or a conversion operator may have to be used to 1650 perform the initialization, but not both, as it would be ambiguous. */ 1651 1652 tree 1653 build_aggr_init (tree exp, tree init, int flags, tsubst_flags_t complain) 1654 { 1655 tree stmt_expr; 1656 tree compound_stmt; 1657 int destroy_temps; 1658 tree type = TREE_TYPE (exp); 1659 int was_const = TREE_READONLY (exp); 1660 int was_volatile = TREE_THIS_VOLATILE (exp); 1661 int is_global; 1662 1663 if (init == error_mark_node) 1664 return error_mark_node; 1665 1666 location_t init_loc = (init 1667 ? EXPR_LOC_OR_LOC (init, input_location) 1668 : location_of (exp)); 1669 1670 TREE_READONLY (exp) = 0; 1671 TREE_THIS_VOLATILE (exp) = 0; 1672 1673 if (TREE_CODE (type) == ARRAY_TYPE) 1674 { 1675 tree itype = init ? TREE_TYPE (init) : NULL_TREE; 1676 int from_array = 0; 1677 1678 if (VAR_P (exp) && DECL_DECOMPOSITION_P (exp)) 1679 { 1680 from_array = 1; 1681 if (init && DECL_P (init) 1682 && !(flags & LOOKUP_ONLYCONVERTING)) 1683 { 1684 /* Wrap the initializer in a CONSTRUCTOR so that build_vec_init 1685 recognizes it as direct-initialization. */ 1686 init = build_constructor_single (init_list_type_node, 1687 NULL_TREE, init); 1688 CONSTRUCTOR_IS_DIRECT_INIT (init) = true; 1689 } 1690 } 1691 else 1692 { 1693 /* Must arrange to initialize each element of EXP 1694 from elements of INIT. */ 1695 if (cv_qualified_p (type)) 1696 TREE_TYPE (exp) = cv_unqualified (type); 1697 if (itype && cv_qualified_p (itype)) 1698 TREE_TYPE (init) = cv_unqualified (itype); 1699 from_array = (itype && same_type_p (TREE_TYPE (init), 1700 TREE_TYPE (exp))); 1701 1702 if (init && !BRACE_ENCLOSED_INITIALIZER_P (init) 1703 && (!from_array 1704 || (TREE_CODE (init) != CONSTRUCTOR 1705 /* Can happen, eg, handling the compound-literals 1706 extension (ext/complit12.C). */ 1707 && TREE_CODE (init) != TARGET_EXPR))) 1708 { 1709 if (complain & tf_error) 1710 error_at (init_loc, "array must be initialized " 1711 "with a brace-enclosed initializer"); 1712 return error_mark_node; 1713 } 1714 } 1715 1716 stmt_expr = build_vec_init (exp, NULL_TREE, init, 1717 /*explicit_value_init_p=*/false, 1718 from_array, 1719 complain); 1720 TREE_READONLY (exp) = was_const; 1721 TREE_THIS_VOLATILE (exp) = was_volatile; 1722 TREE_TYPE (exp) = type; 1723 /* Restore the type of init unless it was used directly. */ 1724 if (init && TREE_CODE (stmt_expr) != INIT_EXPR) 1725 TREE_TYPE (init) = itype; 1726 return stmt_expr; 1727 } 1728 1729 if (init && init != void_type_node 1730 && TREE_CODE (init) != TREE_LIST 1731 && !(TREE_CODE (init) == TARGET_EXPR 1732 && TARGET_EXPR_DIRECT_INIT_P (init)) 1733 && !DIRECT_LIST_INIT_P (init)) 1734 flags |= LOOKUP_ONLYCONVERTING; 1735 1736 if ((VAR_P (exp) || TREE_CODE (exp) == PARM_DECL) 1737 && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (type))) 1738 /* Just know that we've seen something for this node. */ 1739 TREE_USED (exp) = 1; 1740 1741 is_global = begin_init_stmts (&stmt_expr, &compound_stmt); 1742 destroy_temps = stmts_are_full_exprs_p (); 1743 current_stmt_tree ()->stmts_are_full_exprs_p = 0; 1744 expand_aggr_init_1 (TYPE_BINFO (type), exp, exp, 1745 init, LOOKUP_NORMAL|flags, complain); 1746 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt); 1747 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps; 1748 TREE_READONLY (exp) = was_const; 1749 TREE_THIS_VOLATILE (exp) = was_volatile; 1750 1751 return stmt_expr; 1752 } 1753 1754 static void 1755 expand_default_init (tree binfo, tree true_exp, tree exp, tree init, int flags, 1756 tsubst_flags_t complain) 1757 { 1758 tree type = TREE_TYPE (exp); 1759 1760 /* It fails because there may not be a constructor which takes 1761 its own type as the first (or only parameter), but which does 1762 take other types via a conversion. So, if the thing initializing 1763 the expression is a unit element of type X, first try X(X&), 1764 followed by initialization by X. If neither of these work 1765 out, then look hard. */ 1766 tree rval; 1767 vec<tree, va_gc> *parms; 1768 1769 /* If we have direct-initialization from an initializer list, pull 1770 it out of the TREE_LIST so the code below can see it. */ 1771 if (init && TREE_CODE (init) == TREE_LIST 1772 && DIRECT_LIST_INIT_P (TREE_VALUE (init))) 1773 { 1774 gcc_checking_assert ((flags & LOOKUP_ONLYCONVERTING) == 0 1775 && TREE_CHAIN (init) == NULL_TREE); 1776 init = TREE_VALUE (init); 1777 /* Only call reshape_init if it has not been called earlier 1778 by the callers. */ 1779 if (BRACE_ENCLOSED_INITIALIZER_P (init) && CP_AGGREGATE_TYPE_P (type)) 1780 init = reshape_init (type, init, complain); 1781 } 1782 1783 if (init && BRACE_ENCLOSED_INITIALIZER_P (init) 1784 && CP_AGGREGATE_TYPE_P (type)) 1785 /* A brace-enclosed initializer for an aggregate. In C++0x this can 1786 happen for direct-initialization, too. */ 1787 init = digest_init (type, init, complain); 1788 1789 /* A CONSTRUCTOR of the target's type is a previously digested 1790 initializer, whether that happened just above or in 1791 cp_parser_late_parsing_nsdmi. 1792 1793 A TARGET_EXPR with TARGET_EXPR_DIRECT_INIT_P or TARGET_EXPR_LIST_INIT_P 1794 set represents the whole initialization, so we shouldn't build up 1795 another ctor call. */ 1796 if (init 1797 && (TREE_CODE (init) == CONSTRUCTOR 1798 || (TREE_CODE (init) == TARGET_EXPR 1799 && (TARGET_EXPR_DIRECT_INIT_P (init) 1800 || TARGET_EXPR_LIST_INIT_P (init)))) 1801 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (init), type)) 1802 { 1803 /* Early initialization via a TARGET_EXPR only works for 1804 complete objects. */ 1805 gcc_assert (TREE_CODE (init) == CONSTRUCTOR || true_exp == exp); 1806 1807 init = build2 (INIT_EXPR, TREE_TYPE (exp), exp, init); 1808 TREE_SIDE_EFFECTS (init) = 1; 1809 finish_expr_stmt (init); 1810 return; 1811 } 1812 1813 if (init && TREE_CODE (init) != TREE_LIST 1814 && (flags & LOOKUP_ONLYCONVERTING)) 1815 { 1816 /* Base subobjects should only get direct-initialization. */ 1817 gcc_assert (true_exp == exp); 1818 1819 if (flags & DIRECT_BIND) 1820 /* Do nothing. We hit this in two cases: Reference initialization, 1821 where we aren't initializing a real variable, so we don't want 1822 to run a new constructor; and catching an exception, where we 1823 have already built up the constructor call so we could wrap it 1824 in an exception region. */; 1825 else 1826 init = ocp_convert (type, init, CONV_IMPLICIT|CONV_FORCE_TEMP, 1827 flags, complain); 1828 1829 if (TREE_CODE (init) == MUST_NOT_THROW_EXPR) 1830 /* We need to protect the initialization of a catch parm with a 1831 call to terminate(), which shows up as a MUST_NOT_THROW_EXPR 1832 around the TARGET_EXPR for the copy constructor. See 1833 initialize_handler_parm. */ 1834 { 1835 TREE_OPERAND (init, 0) = build2 (INIT_EXPR, TREE_TYPE (exp), exp, 1836 TREE_OPERAND (init, 0)); 1837 TREE_TYPE (init) = void_type_node; 1838 } 1839 else 1840 init = build2 (INIT_EXPR, TREE_TYPE (exp), exp, init); 1841 TREE_SIDE_EFFECTS (init) = 1; 1842 finish_expr_stmt (init); 1843 return; 1844 } 1845 1846 if (init == NULL_TREE) 1847 parms = NULL; 1848 else if (TREE_CODE (init) == TREE_LIST && !TREE_TYPE (init)) 1849 { 1850 parms = make_tree_vector (); 1851 for (; init != NULL_TREE; init = TREE_CHAIN (init)) 1852 vec_safe_push (parms, TREE_VALUE (init)); 1853 } 1854 else 1855 parms = make_tree_vector_single (init); 1856 1857 if (exp == current_class_ref && current_function_decl 1858 && DECL_HAS_IN_CHARGE_PARM_P (current_function_decl)) 1859 { 1860 /* Delegating constructor. */ 1861 tree complete; 1862 tree base; 1863 tree elt; unsigned i; 1864 1865 /* Unshare the arguments for the second call. */ 1866 vec<tree, va_gc> *parms2 = make_tree_vector (); 1867 FOR_EACH_VEC_SAFE_ELT (parms, i, elt) 1868 { 1869 elt = break_out_target_exprs (elt); 1870 vec_safe_push (parms2, elt); 1871 } 1872 complete = build_special_member_call (exp, complete_ctor_identifier, 1873 &parms2, binfo, flags, 1874 complain); 1875 complete = fold_build_cleanup_point_expr (void_type_node, complete); 1876 release_tree_vector (parms2); 1877 1878 base = build_special_member_call (exp, base_ctor_identifier, 1879 &parms, binfo, flags, 1880 complain); 1881 base = fold_build_cleanup_point_expr (void_type_node, base); 1882 rval = build_if_in_charge (complete, base); 1883 } 1884 else 1885 { 1886 tree ctor_name = (true_exp == exp 1887 ? complete_ctor_identifier : base_ctor_identifier); 1888 1889 rval = build_special_member_call (exp, ctor_name, &parms, binfo, flags, 1890 complain); 1891 } 1892 1893 if (parms != NULL) 1894 release_tree_vector (parms); 1895 1896 if (exp == true_exp && TREE_CODE (rval) == CALL_EXPR) 1897 { 1898 tree fn = get_callee_fndecl (rval); 1899 if (fn && DECL_DECLARED_CONSTEXPR_P (fn)) 1900 { 1901 tree e = maybe_constant_init (rval, exp); 1902 if (TREE_CONSTANT (e)) 1903 rval = build2 (INIT_EXPR, type, exp, e); 1904 } 1905 } 1906 1907 /* FIXME put back convert_to_void? */ 1908 if (TREE_SIDE_EFFECTS (rval)) 1909 finish_expr_stmt (rval); 1910 } 1911 1912 /* This function is responsible for initializing EXP with INIT 1913 (if any). 1914 1915 BINFO is the binfo of the type for who we are performing the 1916 initialization. For example, if W is a virtual base class of A and B, 1917 and C : A, B. 1918 If we are initializing B, then W must contain B's W vtable, whereas 1919 were we initializing C, W must contain C's W vtable. 1920 1921 TRUE_EXP is nonzero if it is the true expression being initialized. 1922 In this case, it may be EXP, or may just contain EXP. The reason we 1923 need this is because if EXP is a base element of TRUE_EXP, we 1924 don't necessarily know by looking at EXP where its virtual 1925 baseclass fields should really be pointing. But we do know 1926 from TRUE_EXP. In constructors, we don't know anything about 1927 the value being initialized. 1928 1929 FLAGS is just passed to `build_new_method_call'. See that function 1930 for its description. */ 1931 1932 static void 1933 expand_aggr_init_1 (tree binfo, tree true_exp, tree exp, tree init, int flags, 1934 tsubst_flags_t complain) 1935 { 1936 tree type = TREE_TYPE (exp); 1937 1938 gcc_assert (init != error_mark_node && type != error_mark_node); 1939 gcc_assert (building_stmt_list_p ()); 1940 1941 /* Use a function returning the desired type to initialize EXP for us. 1942 If the function is a constructor, and its first argument is 1943 NULL_TREE, know that it was meant for us--just slide exp on 1944 in and expand the constructor. Constructors now come 1945 as TARGET_EXPRs. */ 1946 1947 if (init && VAR_P (exp) 1948 && COMPOUND_LITERAL_P (init)) 1949 { 1950 vec<tree, va_gc> *cleanups = NULL; 1951 /* If store_init_value returns NULL_TREE, the INIT has been 1952 recorded as the DECL_INITIAL for EXP. That means there's 1953 nothing more we have to do. */ 1954 init = store_init_value (exp, init, &cleanups, flags); 1955 if (init) 1956 finish_expr_stmt (init); 1957 gcc_assert (!cleanups); 1958 return; 1959 } 1960 1961 /* List-initialization from {} becomes value-initialization for non-aggregate 1962 classes with default constructors. Handle this here when we're 1963 initializing a base, so protected access works. */ 1964 if (exp != true_exp && init && TREE_CODE (init) == TREE_LIST) 1965 { 1966 tree elt = TREE_VALUE (init); 1967 if (DIRECT_LIST_INIT_P (elt) 1968 && CONSTRUCTOR_ELTS (elt) == 0 1969 && CLASSTYPE_NON_AGGREGATE (type) 1970 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type)) 1971 init = void_type_node; 1972 } 1973 1974 /* If an explicit -- but empty -- initializer list was present, 1975 that's value-initialization. */ 1976 if (init == void_type_node) 1977 { 1978 /* If the type has data but no user-provided ctor, we need to zero 1979 out the object. */ 1980 if (!type_has_user_provided_constructor (type) 1981 && !is_really_empty_class (type)) 1982 { 1983 tree field_size = NULL_TREE; 1984 if (exp != true_exp && CLASSTYPE_AS_BASE (type) != type) 1985 /* Don't clobber already initialized virtual bases. */ 1986 field_size = TYPE_SIZE (CLASSTYPE_AS_BASE (type)); 1987 init = build_zero_init_1 (type, NULL_TREE, /*static_storage_p=*/false, 1988 field_size); 1989 init = build2 (INIT_EXPR, type, exp, init); 1990 finish_expr_stmt (init); 1991 } 1992 1993 /* If we don't need to mess with the constructor at all, 1994 then we're done. */ 1995 if (! type_build_ctor_call (type)) 1996 return; 1997 1998 /* Otherwise fall through and call the constructor. */ 1999 init = NULL_TREE; 2000 } 2001 2002 /* We know that expand_default_init can handle everything we want 2003 at this point. */ 2004 expand_default_init (binfo, true_exp, exp, init, flags, complain); 2005 } 2006 2007 /* Report an error if TYPE is not a user-defined, class type. If 2008 OR_ELSE is nonzero, give an error message. */ 2009 2010 int 2011 is_class_type (tree type, int or_else) 2012 { 2013 if (type == error_mark_node) 2014 return 0; 2015 2016 if (! CLASS_TYPE_P (type)) 2017 { 2018 if (or_else) 2019 error ("%qT is not a class type", type); 2020 return 0; 2021 } 2022 return 1; 2023 } 2024 2025 tree 2026 get_type_value (tree name) 2027 { 2028 if (name == error_mark_node) 2029 return NULL_TREE; 2030 2031 if (IDENTIFIER_HAS_TYPE_VALUE (name)) 2032 return IDENTIFIER_TYPE_VALUE (name); 2033 else 2034 return NULL_TREE; 2035 } 2036 2037 /* Build a reference to a member of an aggregate. This is not a C++ 2038 `&', but really something which can have its address taken, and 2039 then act as a pointer to member, for example TYPE :: FIELD can have 2040 its address taken by saying & TYPE :: FIELD. ADDRESS_P is true if 2041 this expression is the operand of "&". 2042 2043 @@ Prints out lousy diagnostics for operator <typename> 2044 @@ fields. 2045 2046 @@ This function should be rewritten and placed in search.c. */ 2047 2048 tree 2049 build_offset_ref (tree type, tree member, bool address_p, 2050 tsubst_flags_t complain) 2051 { 2052 tree decl; 2053 tree basebinfo = NULL_TREE; 2054 2055 /* class templates can come in as TEMPLATE_DECLs here. */ 2056 if (TREE_CODE (member) == TEMPLATE_DECL) 2057 return member; 2058 2059 if (dependent_scope_p (type) || type_dependent_expression_p (member)) 2060 return build_qualified_name (NULL_TREE, type, member, 2061 /*template_p=*/false); 2062 2063 gcc_assert (TYPE_P (type)); 2064 if (! is_class_type (type, 1)) 2065 return error_mark_node; 2066 2067 gcc_assert (DECL_P (member) || BASELINK_P (member)); 2068 /* Callers should call mark_used before this point. */ 2069 gcc_assert (!DECL_P (member) || TREE_USED (member)); 2070 2071 type = TYPE_MAIN_VARIANT (type); 2072 if (!COMPLETE_OR_OPEN_TYPE_P (complete_type (type))) 2073 { 2074 if (complain & tf_error) 2075 error ("incomplete type %qT does not have member %qD", type, member); 2076 return error_mark_node; 2077 } 2078 2079 /* Entities other than non-static members need no further 2080 processing. */ 2081 if (TREE_CODE (member) == TYPE_DECL) 2082 return member; 2083 if (VAR_P (member) || TREE_CODE (member) == CONST_DECL) 2084 return convert_from_reference (member); 2085 2086 if (TREE_CODE (member) == FIELD_DECL && DECL_C_BIT_FIELD (member)) 2087 { 2088 if (complain & tf_error) 2089 error ("invalid pointer to bit-field %qD", member); 2090 return error_mark_node; 2091 } 2092 2093 /* Set up BASEBINFO for member lookup. */ 2094 decl = maybe_dummy_object (type, &basebinfo); 2095 2096 /* A lot of this logic is now handled in lookup_member. */ 2097 if (BASELINK_P (member)) 2098 { 2099 /* Go from the TREE_BASELINK to the member function info. */ 2100 tree t = BASELINK_FUNCTIONS (member); 2101 2102 if (TREE_CODE (t) != TEMPLATE_ID_EXPR && !really_overloaded_fn (t)) 2103 { 2104 /* Get rid of a potential OVERLOAD around it. */ 2105 t = OVL_FIRST (t); 2106 2107 /* Unique functions are handled easily. */ 2108 2109 /* For non-static member of base class, we need a special rule 2110 for access checking [class.protected]: 2111 2112 If the access is to form a pointer to member, the 2113 nested-name-specifier shall name the derived class 2114 (or any class derived from that class). */ 2115 bool ok; 2116 if (address_p && DECL_P (t) 2117 && DECL_NONSTATIC_MEMBER_P (t)) 2118 ok = perform_or_defer_access_check (TYPE_BINFO (type), t, t, 2119 complain); 2120 else 2121 ok = perform_or_defer_access_check (basebinfo, t, t, 2122 complain); 2123 if (!ok) 2124 return error_mark_node; 2125 if (DECL_STATIC_FUNCTION_P (t)) 2126 return t; 2127 member = t; 2128 } 2129 else 2130 TREE_TYPE (member) = unknown_type_node; 2131 } 2132 else if (address_p && TREE_CODE (member) == FIELD_DECL) 2133 { 2134 /* We need additional test besides the one in 2135 check_accessibility_of_qualified_id in case it is 2136 a pointer to non-static member. */ 2137 if (!perform_or_defer_access_check (TYPE_BINFO (type), member, member, 2138 complain)) 2139 return error_mark_node; 2140 } 2141 2142 if (!address_p) 2143 { 2144 /* If MEMBER is non-static, then the program has fallen afoul of 2145 [expr.prim]: 2146 2147 An id-expression that denotes a nonstatic data member or 2148 nonstatic member function of a class can only be used: 2149 2150 -- as part of a class member access (_expr.ref_) in which the 2151 object-expression refers to the member's class or a class 2152 derived from that class, or 2153 2154 -- to form a pointer to member (_expr.unary.op_), or 2155 2156 -- in the body of a nonstatic member function of that class or 2157 of a class derived from that class (_class.mfct.nonstatic_), or 2158 2159 -- in a mem-initializer for a constructor for that class or for 2160 a class derived from that class (_class.base.init_). */ 2161 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member)) 2162 { 2163 /* Build a representation of the qualified name suitable 2164 for use as the operand to "&" -- even though the "&" is 2165 not actually present. */ 2166 member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member); 2167 /* In Microsoft mode, treat a non-static member function as if 2168 it were a pointer-to-member. */ 2169 if (flag_ms_extensions) 2170 { 2171 PTRMEM_OK_P (member) = 1; 2172 return cp_build_addr_expr (member, complain); 2173 } 2174 if (complain & tf_error) 2175 error ("invalid use of non-static member function %qD", 2176 TREE_OPERAND (member, 1)); 2177 return error_mark_node; 2178 } 2179 else if (TREE_CODE (member) == FIELD_DECL) 2180 { 2181 if (complain & tf_error) 2182 error ("invalid use of non-static data member %qD", member); 2183 return error_mark_node; 2184 } 2185 return member; 2186 } 2187 2188 member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member); 2189 PTRMEM_OK_P (member) = 1; 2190 return member; 2191 } 2192 2193 /* If DECL is a scalar enumeration constant or variable with a 2194 constant initializer, return the initializer (or, its initializers, 2195 recursively); otherwise, return DECL. If STRICT_P, the 2196 initializer is only returned if DECL is a 2197 constant-expression. If RETURN_AGGREGATE_CST_OK_P, it is ok to 2198 return an aggregate constant. */ 2199 2200 static tree 2201 constant_value_1 (tree decl, bool strict_p, bool return_aggregate_cst_ok_p) 2202 { 2203 while (TREE_CODE (decl) == CONST_DECL 2204 || decl_constant_var_p (decl) 2205 || (!strict_p && VAR_P (decl) 2206 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl)))) 2207 { 2208 tree init; 2209 /* If DECL is a static data member in a template 2210 specialization, we must instantiate it here. The 2211 initializer for the static data member is not processed 2212 until needed; we need it now. */ 2213 mark_used (decl, tf_none); 2214 init = DECL_INITIAL (decl); 2215 if (init == error_mark_node) 2216 { 2217 if (TREE_CODE (decl) == CONST_DECL 2218 || DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl)) 2219 /* Treat the error as a constant to avoid cascading errors on 2220 excessively recursive template instantiation (c++/9335). */ 2221 return init; 2222 else 2223 return decl; 2224 } 2225 /* Initializers in templates are generally expanded during 2226 instantiation, so before that for const int i(2) 2227 INIT is a TREE_LIST with the actual initializer as 2228 TREE_VALUE. */ 2229 if (processing_template_decl 2230 && init 2231 && TREE_CODE (init) == TREE_LIST 2232 && TREE_CHAIN (init) == NULL_TREE) 2233 init = TREE_VALUE (init); 2234 /* Instantiate a non-dependent initializer for user variables. We 2235 mustn't do this for the temporary for an array compound literal; 2236 trying to instatiate the initializer will keep creating new 2237 temporaries until we crash. Probably it's not useful to do it for 2238 other artificial variables, either. */ 2239 if (!DECL_ARTIFICIAL (decl)) 2240 init = instantiate_non_dependent_or_null (init); 2241 if (!init 2242 || !TREE_TYPE (init) 2243 || !TREE_CONSTANT (init) 2244 || (!return_aggregate_cst_ok_p 2245 /* Unless RETURN_AGGREGATE_CST_OK_P is true, do not 2246 return an aggregate constant (of which string 2247 literals are a special case), as we do not want 2248 to make inadvertent copies of such entities, and 2249 we must be sure that their addresses are the 2250 same everywhere. */ 2251 && (TREE_CODE (init) == CONSTRUCTOR 2252 || TREE_CODE (init) == STRING_CST))) 2253 break; 2254 /* Don't return a CONSTRUCTOR for a variable with partial run-time 2255 initialization, since it doesn't represent the entire value. */ 2256 if (TREE_CODE (init) == CONSTRUCTOR 2257 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl)) 2258 break; 2259 /* If the variable has a dynamic initializer, don't use its 2260 DECL_INITIAL which doesn't reflect the real value. */ 2261 if (VAR_P (decl) 2262 && TREE_STATIC (decl) 2263 && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) 2264 && DECL_NONTRIVIALLY_INITIALIZED_P (decl)) 2265 break; 2266 decl = unshare_expr (init); 2267 } 2268 return decl; 2269 } 2270 2271 /* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by constant 2272 of integral or enumeration type, or a constexpr variable of scalar type, 2273 then return that value. These are those variables permitted in constant 2274 expressions by [5.19/1]. */ 2275 2276 tree 2277 scalar_constant_value (tree decl) 2278 { 2279 return constant_value_1 (decl, /*strict_p=*/true, 2280 /*return_aggregate_cst_ok_p=*/false); 2281 } 2282 2283 /* Like scalar_constant_value, but can also return aggregate initializers. */ 2284 2285 tree 2286 decl_really_constant_value (tree decl) 2287 { 2288 return constant_value_1 (decl, /*strict_p=*/true, 2289 /*return_aggregate_cst_ok_p=*/true); 2290 } 2291 2292 /* A more relaxed version of scalar_constant_value, used by the 2293 common C/C++ code. */ 2294 2295 tree 2296 decl_constant_value (tree decl) 2297 { 2298 return constant_value_1 (decl, /*strict_p=*/processing_template_decl, 2299 /*return_aggregate_cst_ok_p=*/true); 2300 } 2301 2302 /* Common subroutines of build_new and build_vec_delete. */ 2303 2304 /* Build and return a NEW_EXPR. If NELTS is non-NULL, TYPE[NELTS] is 2305 the type of the object being allocated; otherwise, it's just TYPE. 2306 INIT is the initializer, if any. USE_GLOBAL_NEW is true if the 2307 user explicitly wrote "::operator new". PLACEMENT, if non-NULL, is 2308 a vector of arguments to be provided as arguments to a placement 2309 new operator. This routine performs no semantic checks; it just 2310 creates and returns a NEW_EXPR. */ 2311 2312 static tree 2313 build_raw_new_expr (vec<tree, va_gc> *placement, tree type, tree nelts, 2314 vec<tree, va_gc> *init, int use_global_new) 2315 { 2316 tree init_list; 2317 tree new_expr; 2318 2319 /* If INIT is NULL, the we want to store NULL_TREE in the NEW_EXPR. 2320 If INIT is not NULL, then we want to store VOID_ZERO_NODE. This 2321 permits us to distinguish the case of a missing initializer "new 2322 int" from an empty initializer "new int()". */ 2323 if (init == NULL) 2324 init_list = NULL_TREE; 2325 else if (init->is_empty ()) 2326 init_list = void_node; 2327 else 2328 { 2329 init_list = build_tree_list_vec (init); 2330 for (tree v = init_list; v; v = TREE_CHAIN (v)) 2331 if (TREE_CODE (TREE_VALUE (v)) == OVERLOAD) 2332 lookup_keep (TREE_VALUE (v), true); 2333 } 2334 2335 new_expr = build4 (NEW_EXPR, build_pointer_type (type), 2336 build_tree_list_vec (placement), type, nelts, 2337 init_list); 2338 NEW_EXPR_USE_GLOBAL (new_expr) = use_global_new; 2339 TREE_SIDE_EFFECTS (new_expr) = 1; 2340 2341 return new_expr; 2342 } 2343 2344 /* Diagnose uninitialized const members or reference members of type 2345 TYPE. USING_NEW is used to disambiguate the diagnostic between a 2346 new expression without a new-initializer and a declaration. Returns 2347 the error count. */ 2348 2349 static int 2350 diagnose_uninitialized_cst_or_ref_member_1 (tree type, tree origin, 2351 bool using_new, bool complain) 2352 { 2353 tree field; 2354 int error_count = 0; 2355 2356 if (type_has_user_provided_constructor (type)) 2357 return 0; 2358 2359 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field)) 2360 { 2361 tree field_type; 2362 2363 if (TREE_CODE (field) != FIELD_DECL) 2364 continue; 2365 2366 field_type = strip_array_types (TREE_TYPE (field)); 2367 2368 if (type_has_user_provided_constructor (field_type)) 2369 continue; 2370 2371 if (TREE_CODE (field_type) == REFERENCE_TYPE) 2372 { 2373 ++ error_count; 2374 if (complain) 2375 { 2376 if (DECL_CONTEXT (field) == origin) 2377 { 2378 if (using_new) 2379 error ("uninitialized reference member in %q#T " 2380 "using %<new%> without new-initializer", origin); 2381 else 2382 error ("uninitialized reference member in %q#T", origin); 2383 } 2384 else 2385 { 2386 if (using_new) 2387 error ("uninitialized reference member in base %q#T " 2388 "of %q#T using %<new%> without new-initializer", 2389 DECL_CONTEXT (field), origin); 2390 else 2391 error ("uninitialized reference member in base %q#T " 2392 "of %q#T", DECL_CONTEXT (field), origin); 2393 } 2394 inform (DECL_SOURCE_LOCATION (field), 2395 "%q#D should be initialized", field); 2396 } 2397 } 2398 2399 if (CP_TYPE_CONST_P (field_type)) 2400 { 2401 ++ error_count; 2402 if (complain) 2403 { 2404 if (DECL_CONTEXT (field) == origin) 2405 { 2406 if (using_new) 2407 error ("uninitialized const member in %q#T " 2408 "using %<new%> without new-initializer", origin); 2409 else 2410 error ("uninitialized const member in %q#T", origin); 2411 } 2412 else 2413 { 2414 if (using_new) 2415 error ("uninitialized const member in base %q#T " 2416 "of %q#T using %<new%> without new-initializer", 2417 DECL_CONTEXT (field), origin); 2418 else 2419 error ("uninitialized const member in base %q#T " 2420 "of %q#T", DECL_CONTEXT (field), origin); 2421 } 2422 inform (DECL_SOURCE_LOCATION (field), 2423 "%q#D should be initialized", field); 2424 } 2425 } 2426 2427 if (CLASS_TYPE_P (field_type)) 2428 error_count 2429 += diagnose_uninitialized_cst_or_ref_member_1 (field_type, origin, 2430 using_new, complain); 2431 } 2432 return error_count; 2433 } 2434 2435 int 2436 diagnose_uninitialized_cst_or_ref_member (tree type, bool using_new, bool complain) 2437 { 2438 return diagnose_uninitialized_cst_or_ref_member_1 (type, type, using_new, complain); 2439 } 2440 2441 /* Call __cxa_bad_array_new_length to indicate that the size calculation 2442 overflowed. Pretend it returns sizetype so that it plays nicely in the 2443 COND_EXPR. */ 2444 2445 tree 2446 throw_bad_array_new_length (void) 2447 { 2448 if (!fn) 2449 { 2450 tree name = get_identifier ("__cxa_throw_bad_array_new_length"); 2451 2452 fn = get_global_binding (name); 2453 if (!fn) 2454 fn = push_throw_library_fn 2455 (name, build_function_type_list (sizetype, NULL_TREE)); 2456 } 2457 2458 return build_cxx_call (fn, 0, NULL, tf_warning_or_error); 2459 } 2460 2461 /* Attempt to find the initializer for flexible array field T in the 2462 initializer INIT, when non-null. Returns the initializer when 2463 successful and NULL otherwise. */ 2464 static tree 2465 find_flexarray_init (tree t, tree init) 2466 { 2467 if (!init || init == error_mark_node) 2468 return NULL_TREE; 2469 2470 unsigned HOST_WIDE_INT idx; 2471 tree field, elt; 2472 2473 /* Iterate over all top-level initializer elements. */ 2474 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx, field, elt) 2475 /* If the member T is found, return it. */ 2476 if (field == t) 2477 return elt; 2478 2479 return NULL_TREE; 2480 } 2481 2482 /* Attempt to verify that the argument, OPER, of a placement new expression 2483 refers to an object sufficiently large for an object of TYPE or an array 2484 of NELTS of such objects when NELTS is non-null, and issue a warning when 2485 it does not. SIZE specifies the size needed to construct the object or 2486 array and captures the result of NELTS * sizeof (TYPE). (SIZE could be 2487 greater when the array under construction requires a cookie to store 2488 NELTS. GCC's placement new expression stores the cookie when invoking 2489 a user-defined placement new operator function but not the default one. 2490 Placement new expressions with user-defined placement new operator are 2491 not diagnosed since we don't know how they use the buffer (this could 2492 be a future extension). */ 2493 static void 2494 warn_placement_new_too_small (tree type, tree nelts, tree size, tree oper) 2495 { 2496 location_t loc = EXPR_LOC_OR_LOC (oper, input_location); 2497 2498 /* The number of bytes to add to or subtract from the size of the provided 2499 buffer based on an offset into an array or an array element reference. 2500 Although intermediate results may be negative (as in a[3] - 2) a valid 2501 final result cannot be. */ 2502 offset_int adjust = 0; 2503 /* True when the size of the entire destination object should be used 2504 to compute the possibly optimistic estimate of the available space. */ 2505 bool use_obj_size = false; 2506 /* True when the reference to the destination buffer is an ADDR_EXPR. */ 2507 bool addr_expr = false; 2508 2509 STRIP_NOPS (oper); 2510 2511 /* Using a function argument or a (non-array) variable as an argument 2512 to placement new is not checked since it's unknown what it might 2513 point to. */ 2514 if (TREE_CODE (oper) == PARM_DECL 2515 || VAR_P (oper) 2516 || TREE_CODE (oper) == COMPONENT_REF) 2517 return; 2518 2519 /* Evaluate any constant expressions. */ 2520 size = fold_non_dependent_expr (size); 2521 2522 /* Handle the common case of array + offset expression when the offset 2523 is a constant. */ 2524 if (TREE_CODE (oper) == POINTER_PLUS_EXPR) 2525 { 2526 /* If the offset is compile-time constant, use it to compute a more 2527 accurate estimate of the size of the buffer. Since the operand 2528 of POINTER_PLUS_EXPR is represented as an unsigned type, convert 2529 it to signed first. 2530 Otherwise, use the size of the entire array as an optimistic 2531 estimate (this may lead to false negatives). */ 2532 tree adj = TREE_OPERAND (oper, 1); 2533 if (CONSTANT_CLASS_P (adj)) 2534 adjust += wi::to_offset (convert (ssizetype, adj)); 2535 else 2536 use_obj_size = true; 2537 2538 oper = TREE_OPERAND (oper, 0); 2539 2540 STRIP_NOPS (oper); 2541 } 2542 2543 if (TREE_CODE (oper) == TARGET_EXPR) 2544 oper = TREE_OPERAND (oper, 1); 2545 else if (TREE_CODE (oper) == ADDR_EXPR) 2546 { 2547 addr_expr = true; 2548 oper = TREE_OPERAND (oper, 0); 2549 } 2550 2551 STRIP_NOPS (oper); 2552 2553 if (TREE_CODE (oper) == ARRAY_REF 2554 && (addr_expr || TREE_CODE (TREE_TYPE (oper)) == ARRAY_TYPE)) 2555 { 2556 /* Similar to the offset computed above, see if the array index 2557 is a compile-time constant. If so, and unless the offset was 2558 not a compile-time constant, use the index to determine the 2559 size of the buffer. Otherwise, use the entire array as 2560 an optimistic estimate of the size. */ 2561 const_tree adj = fold_non_dependent_expr (TREE_OPERAND (oper, 1)); 2562 if (!use_obj_size && CONSTANT_CLASS_P (adj)) 2563 adjust += wi::to_offset (adj); 2564 else 2565 { 2566 use_obj_size = true; 2567 adjust = 0; 2568 } 2569 2570 oper = TREE_OPERAND (oper, 0); 2571 } 2572 2573 /* Refers to the declared object that constains the subobject referenced 2574 by OPER. When the object is initialized, makes it possible to determine 2575 the actual size of a flexible array member used as the buffer passed 2576 as OPER to placement new. */ 2577 tree var_decl = NULL_TREE; 2578 /* True when operand is a COMPONENT_REF, to distinguish flexible array 2579 members from arrays of unspecified size. */ 2580 bool compref = TREE_CODE (oper) == COMPONENT_REF; 2581 2582 /* For COMPONENT_REF (i.e., a struct member) the size of the entire 2583 enclosing struct. Used to validate the adjustment (offset) into 2584 an array at the end of a struct. */ 2585 offset_int compsize = 0; 2586 2587 /* Descend into a struct or union to find the member whose address 2588 is being used as the argument. */ 2589 if (TREE_CODE (oper) == COMPONENT_REF) 2590 { 2591 tree comptype = TREE_TYPE (TREE_OPERAND (oper, 0)); 2592 compsize = wi::to_offset (TYPE_SIZE_UNIT (comptype)); 2593 2594 tree op0 = oper; 2595 while (TREE_CODE (op0 = TREE_OPERAND (op0, 0)) == COMPONENT_REF); 2596 if (VAR_P (op0)) 2597 var_decl = op0; 2598 oper = TREE_OPERAND (oper, 1); 2599 } 2600 2601 tree opertype = TREE_TYPE (oper); 2602 if ((addr_expr || !POINTER_TYPE_P (opertype)) 2603 && (VAR_P (oper) 2604 || TREE_CODE (oper) == FIELD_DECL 2605 || TREE_CODE (oper) == PARM_DECL)) 2606 { 2607 /* A possibly optimistic estimate of the number of bytes available 2608 in the destination buffer. */ 2609 offset_int bytes_avail = 0; 2610 /* True when the estimate above is in fact the exact size 2611 of the destination buffer rather than an estimate. */ 2612 bool exact_size = true; 2613 2614 /* Treat members of unions and members of structs uniformly, even 2615 though the size of a member of a union may be viewed as extending 2616 to the end of the union itself (it is by __builtin_object_size). */ 2617 if ((VAR_P (oper) || use_obj_size) 2618 && DECL_SIZE_UNIT (oper) 2619 && tree_fits_uhwi_p (DECL_SIZE_UNIT (oper))) 2620 { 2621 /* Use the size of the entire array object when the expression 2622 refers to a variable or its size depends on an expression 2623 that's not a compile-time constant. */ 2624 bytes_avail = wi::to_offset (DECL_SIZE_UNIT (oper)); 2625 exact_size = !use_obj_size; 2626 } 2627 else if (tree opersize = TYPE_SIZE_UNIT (opertype)) 2628 { 2629 /* Use the size of the type of the destination buffer object 2630 as the optimistic estimate of the available space in it. 2631 Use the maximum possible size for zero-size arrays and 2632 flexible array members (except of initialized objects 2633 thereof). */ 2634 if (TREE_CODE (opersize) == INTEGER_CST) 2635 bytes_avail = wi::to_offset (opersize); 2636 } 2637 2638 if (bytes_avail == 0) 2639 { 2640 if (var_decl) 2641 { 2642 /* Constructing into a buffer provided by the flexible array 2643 member of a declared object (which is permitted as a G++ 2644 extension). If the array member has been initialized, 2645 determine its size from the initializer. Otherwise, 2646 the array size is zero. */ 2647 if (tree init = find_flexarray_init (oper, 2648 DECL_INITIAL (var_decl))) 2649 bytes_avail = wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (init))); 2650 } 2651 else 2652 bytes_avail = (wi::to_offset (TYPE_MAX_VALUE (ptrdiff_type_node)) 2653 - compsize); 2654 } 2655 2656 tree_code oper_code = TREE_CODE (opertype); 2657 2658 if (compref && oper_code == ARRAY_TYPE) 2659 { 2660 tree nelts = array_type_nelts_top (opertype); 2661 tree nelts_cst = maybe_constant_value (nelts); 2662 if (TREE_CODE (nelts_cst) == INTEGER_CST 2663 && integer_onep (nelts_cst) 2664 && !var_decl 2665 && warn_placement_new < 2) 2666 return; 2667 } 2668 2669 /* Reduce the size of the buffer by the adjustment computed above 2670 from the offset and/or the index into the array. */ 2671 if (bytes_avail < adjust || adjust < 0) 2672 bytes_avail = 0; 2673 else 2674 { 2675 tree elttype = (TREE_CODE (opertype) == ARRAY_TYPE 2676 ? TREE_TYPE (opertype) : opertype); 2677 if (tree eltsize = TYPE_SIZE_UNIT (elttype)) 2678 { 2679 bytes_avail -= adjust * wi::to_offset (eltsize); 2680 if (bytes_avail < 0) 2681 bytes_avail = 0; 2682 } 2683 } 2684 2685 /* The minimum amount of space needed for the allocation. This 2686 is an optimistic estimate that makes it possible to detect 2687 placement new invocation for some undersize buffers but not 2688 others. */ 2689 offset_int bytes_need; 2690 2691 if (CONSTANT_CLASS_P (size)) 2692 bytes_need = wi::to_offset (size); 2693 else if (nelts && CONSTANT_CLASS_P (nelts)) 2694 bytes_need = (wi::to_offset (nelts) 2695 * wi::to_offset (TYPE_SIZE_UNIT (type))); 2696 else if (tree_fits_uhwi_p (TYPE_SIZE_UNIT (type))) 2697 bytes_need = wi::to_offset (TYPE_SIZE_UNIT (type)); 2698 else 2699 { 2700 /* The type is a VLA. */ 2701 return; 2702 } 2703 2704 if (bytes_avail < bytes_need) 2705 { 2706 if (nelts) 2707 if (CONSTANT_CLASS_P (nelts)) 2708 warning_at (loc, OPT_Wplacement_new_, 2709 exact_size ? 2710 "placement new constructing an object of type " 2711 "%<%T [%wu]%> and size %qwu in a region of type %qT " 2712 "and size %qwi" 2713 : "placement new constructing an object of type " 2714 "%<%T [%wu]%> and size %qwu in a region of type %qT " 2715 "and size at most %qwu", 2716 type, tree_to_uhwi (nelts), bytes_need.to_uhwi (), 2717 opertype, bytes_avail.to_uhwi ()); 2718 else 2719 warning_at (loc, OPT_Wplacement_new_, 2720 exact_size ? 2721 "placement new constructing an array of objects " 2722 "of type %qT and size %qwu in a region of type %qT " 2723 "and size %qwi" 2724 : "placement new constructing an array of objects " 2725 "of type %qT and size %qwu in a region of type %qT " 2726 "and size at most %qwu", 2727 type, bytes_need.to_uhwi (), opertype, 2728 bytes_avail.to_uhwi ()); 2729 else 2730 warning_at (loc, OPT_Wplacement_new_, 2731 exact_size ? 2732 "placement new constructing an object of type %qT " 2733 "and size %qwu in a region of type %qT and size %qwi" 2734 : "placement new constructing an object of type %qT " 2735 "and size %qwu in a region of type %qT and size " 2736 "at most %qwu", 2737 type, bytes_need.to_uhwi (), opertype, 2738 bytes_avail.to_uhwi ()); 2739 } 2740 } 2741 } 2742 2743 /* True if alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__. */ 2744 2745 bool 2746 type_has_new_extended_alignment (tree t) 2747 { 2748 return (aligned_new_threshold 2749 && TYPE_ALIGN_UNIT (t) > (unsigned)aligned_new_threshold); 2750 } 2751 2752 /* Return the alignment we expect malloc to guarantee. This should just be 2753 MALLOC_ABI_ALIGNMENT, but that macro defaults to only BITS_PER_WORD for some 2754 reason, so don't let the threshold be smaller than max_align_t_align. */ 2755 2756 unsigned 2757 malloc_alignment () 2758 { 2759 return MAX (max_align_t_align(), MALLOC_ABI_ALIGNMENT); 2760 } 2761 2762 /* Determine whether an allocation function is a namespace-scope 2763 non-replaceable placement new function. See DR 1748. 2764 TODO: Enable in all standard modes. */ 2765 static bool 2766 std_placement_new_fn_p (tree alloc_fn) 2767 { 2768 if (DECL_NAMESPACE_SCOPE_P (alloc_fn)) 2769 { 2770 tree first_arg = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (alloc_fn))); 2771 if ((TREE_VALUE (first_arg) == ptr_type_node) 2772 && TREE_CHAIN (first_arg) == void_list_node) 2773 return true; 2774 } 2775 return false; 2776 } 2777 2778 /* Generate code for a new-expression, including calling the "operator 2779 new" function, initializing the object, and, if an exception occurs 2780 during construction, cleaning up. The arguments are as for 2781 build_raw_new_expr. This may change PLACEMENT and INIT. 2782 TYPE is the type of the object being constructed, possibly an array 2783 of NELTS elements when NELTS is non-null (in "new T[NELTS]", T may 2784 be an array of the form U[inner], with the whole expression being 2785 "new U[NELTS][inner]"). */ 2786 2787 static tree 2788 build_new_1 (vec<tree, va_gc> **placement, tree type, tree nelts, 2789 vec<tree, va_gc> **init, bool globally_qualified_p, 2790 tsubst_flags_t complain) 2791 { 2792 tree size, rval; 2793 /* True iff this is a call to "operator new[]" instead of just 2794 "operator new". */ 2795 bool array_p = false; 2796 /* If ARRAY_P is true, the element type of the array. This is never 2797 an ARRAY_TYPE; for something like "new int[3][4]", the 2798 ELT_TYPE is "int". If ARRAY_P is false, this is the same type as 2799 TYPE. */ 2800 tree elt_type; 2801 /* The type of the new-expression. (This type is always a pointer 2802 type.) */ 2803 tree pointer_type; 2804 tree non_const_pointer_type; 2805 /* The most significant array bound in int[OUTER_NELTS][inner]. */ 2806 tree outer_nelts = NULL_TREE; 2807 /* For arrays with a non-constant number of elements, a bounds checks 2808 on the NELTS parameter to avoid integer overflow at runtime. */ 2809 tree outer_nelts_check = NULL_TREE; 2810 bool outer_nelts_from_type = false; 2811 /* Number of the "inner" elements in "new T[OUTER_NELTS][inner]". */ 2812 offset_int inner_nelts_count = 1; 2813 tree alloc_call, alloc_expr; 2814 /* Size of the inner array elements (those with constant dimensions). */ 2815 offset_int inner_size; 2816 /* The address returned by the call to "operator new". This node is 2817 a VAR_DECL and is therefore reusable. */ 2818 tree alloc_node; 2819 tree alloc_fn; 2820 tree cookie_expr, init_expr; 2821 int nothrow, check_new; 2822 /* If non-NULL, the number of extra bytes to allocate at the 2823 beginning of the storage allocated for an array-new expression in 2824 order to store the number of elements. */ 2825 tree cookie_size = NULL_TREE; 2826 tree placement_first; 2827 tree placement_expr = NULL_TREE; 2828 /* True if the function we are calling is a placement allocation 2829 function. */ 2830 bool placement_allocation_fn_p; 2831 /* True if the storage must be initialized, either by a constructor 2832 or due to an explicit new-initializer. */ 2833 bool is_initialized; 2834 /* The address of the thing allocated, not including any cookie. In 2835 particular, if an array cookie is in use, DATA_ADDR is the 2836 address of the first array element. This node is a VAR_DECL, and 2837 is therefore reusable. */ 2838 tree data_addr; 2839 tree init_preeval_expr = NULL_TREE; 2840 tree orig_type = type; 2841 2842 if (nelts) 2843 { 2844 outer_nelts = nelts; 2845 array_p = true; 2846 } 2847 else if (TREE_CODE (type) == ARRAY_TYPE) 2848 { 2849 /* Transforms new (T[N]) to new T[N]. The former is a GNU 2850 extension for variable N. (This also covers new T where T is 2851 a VLA typedef.) */ 2852 array_p = true; 2853 nelts = array_type_nelts_top (type); 2854 outer_nelts = nelts; 2855 type = TREE_TYPE (type); 2856 outer_nelts_from_type = true; 2857 } 2858 2859 /* Lots of logic below. depends on whether we have a constant number of 2860 elements, so go ahead and fold it now. */ 2861 if (outer_nelts) 2862 outer_nelts = maybe_constant_value (outer_nelts); 2863 2864 /* If our base type is an array, then make sure we know how many elements 2865 it has. */ 2866 for (elt_type = type; 2867 TREE_CODE (elt_type) == ARRAY_TYPE; 2868 elt_type = TREE_TYPE (elt_type)) 2869 { 2870 tree inner_nelts = array_type_nelts_top (elt_type); 2871 tree inner_nelts_cst = maybe_constant_value (inner_nelts); 2872 if (TREE_CODE (inner_nelts_cst) == INTEGER_CST) 2873 { 2874 bool overflow; 2875 offset_int result = wi::mul (wi::to_offset (inner_nelts_cst), 2876 inner_nelts_count, SIGNED, &overflow); 2877 if (overflow) 2878 { 2879 if (complain & tf_error) 2880 error ("integer overflow in array size"); 2881 nelts = error_mark_node; 2882 } 2883 inner_nelts_count = result; 2884 } 2885 else 2886 { 2887 if (complain & tf_error) 2888 { 2889 error_at (EXPR_LOC_OR_LOC (inner_nelts, input_location), 2890 "array size in new-expression must be constant"); 2891 cxx_constant_value(inner_nelts); 2892 } 2893 nelts = error_mark_node; 2894 } 2895 if (nelts != error_mark_node) 2896 nelts = cp_build_binary_op (input_location, 2897 MULT_EXPR, nelts, 2898 inner_nelts_cst, 2899 complain); 2900 } 2901 2902 if (variably_modified_type_p (elt_type, NULL_TREE) && (complain & tf_error)) 2903 { 2904 error ("variably modified type not allowed in new-expression"); 2905 return error_mark_node; 2906 } 2907 2908 if (nelts == error_mark_node) 2909 return error_mark_node; 2910 2911 /* Warn if we performed the (T[N]) to T[N] transformation and N is 2912 variable. */ 2913 if (outer_nelts_from_type 2914 && !TREE_CONSTANT (outer_nelts)) 2915 { 2916 if (complain & tf_warning_or_error) 2917 { 2918 pedwarn (EXPR_LOC_OR_LOC (outer_nelts, input_location), OPT_Wvla, 2919 typedef_variant_p (orig_type) 2920 ? G_("non-constant array new length must be specified " 2921 "directly, not by typedef") 2922 : G_("non-constant array new length must be specified " 2923 "without parentheses around the type-id")); 2924 } 2925 else 2926 return error_mark_node; 2927 } 2928 2929 if (VOID_TYPE_P (elt_type)) 2930 { 2931 if (complain & tf_error) 2932 error ("invalid type %<void%> for new"); 2933 return error_mark_node; 2934 } 2935 2936 if (abstract_virtuals_error_sfinae (ACU_NEW, elt_type, complain)) 2937 return error_mark_node; 2938 2939 is_initialized = (type_build_ctor_call (elt_type) || *init != NULL); 2940 2941 if (*init == NULL && cxx_dialect < cxx11) 2942 { 2943 bool maybe_uninitialized_error = false; 2944 /* A program that calls for default-initialization [...] of an 2945 entity of reference type is ill-formed. */ 2946 if (CLASSTYPE_REF_FIELDS_NEED_INIT (elt_type)) 2947 maybe_uninitialized_error = true; 2948 2949 /* A new-expression that creates an object of type T initializes 2950 that object as follows: 2951 - If the new-initializer is omitted: 2952 -- If T is a (possibly cv-qualified) non-POD class type 2953 (or array thereof), the object is default-initialized (8.5). 2954 [...] 2955 -- Otherwise, the object created has indeterminate 2956 value. If T is a const-qualified type, or a (possibly 2957 cv-qualified) POD class type (or array thereof) 2958 containing (directly or indirectly) a member of 2959 const-qualified type, the program is ill-formed; */ 2960 2961 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (elt_type)) 2962 maybe_uninitialized_error = true; 2963 2964 if (maybe_uninitialized_error 2965 && diagnose_uninitialized_cst_or_ref_member (elt_type, 2966 /*using_new=*/true, 2967 complain & tf_error)) 2968 return error_mark_node; 2969 } 2970 2971 if (CP_TYPE_CONST_P (elt_type) && *init == NULL 2972 && default_init_uninitialized_part (elt_type)) 2973 { 2974 if (complain & tf_error) 2975 error ("uninitialized const in %<new%> of %q#T", elt_type); 2976 return error_mark_node; 2977 } 2978 2979 size = size_in_bytes (elt_type); 2980 if (array_p) 2981 { 2982 /* Maximum available size in bytes. Half of the address space 2983 minus the cookie size. */ 2984 offset_int max_size 2985 = wi::set_bit_in_zero <offset_int> (TYPE_PRECISION (sizetype) - 1); 2986 /* Maximum number of outer elements which can be allocated. */ 2987 offset_int max_outer_nelts; 2988 tree max_outer_nelts_tree; 2989 2990 gcc_assert (TREE_CODE (size) == INTEGER_CST); 2991 cookie_size = targetm.cxx.get_cookie_size (elt_type); 2992 gcc_assert (TREE_CODE (cookie_size) == INTEGER_CST); 2993 gcc_checking_assert (wi::ltu_p (wi::to_offset (cookie_size), max_size)); 2994 /* Unconditionally subtract the cookie size. This decreases the 2995 maximum object size and is safe even if we choose not to use 2996 a cookie after all. */ 2997 max_size -= wi::to_offset (cookie_size); 2998 bool overflow; 2999 inner_size = wi::mul (wi::to_offset (size), inner_nelts_count, SIGNED, 3000 &overflow); 3001 if (overflow || wi::gtu_p (inner_size, max_size)) 3002 { 3003 if (complain & tf_error) 3004 error ("size of array is too large"); 3005 return error_mark_node; 3006 } 3007 3008 max_outer_nelts = wi::udiv_trunc (max_size, inner_size); 3009 max_outer_nelts_tree = wide_int_to_tree (sizetype, max_outer_nelts); 3010 3011 size = size_binop (MULT_EXPR, size, fold_convert (sizetype, nelts)); 3012 3013 if (INTEGER_CST == TREE_CODE (outer_nelts)) 3014 { 3015 if (tree_int_cst_lt (max_outer_nelts_tree, outer_nelts)) 3016 { 3017 /* When the array size is constant, check it at compile time 3018 to make sure it doesn't exceed the implementation-defined 3019 maximum, as required by C++ 14 (in C++ 11 this requirement 3020 isn't explicitly stated but it's enforced anyway -- see 3021 grokdeclarator in cp/decl.c). */ 3022 if (complain & tf_error) 3023 error ("size of array is too large"); 3024 return error_mark_node; 3025 } 3026 } 3027 else 3028 { 3029 /* When a runtime check is necessary because the array size 3030 isn't constant, keep only the top-most seven bits (starting 3031 with the most significant non-zero bit) of the maximum size 3032 to compare the array size against, to simplify encoding the 3033 constant maximum size in the instruction stream. */ 3034 3035 unsigned shift = (max_outer_nelts.get_precision ()) - 7 3036 - wi::clz (max_outer_nelts); 3037 max_outer_nelts = (max_outer_nelts >> shift) << shift; 3038 3039 outer_nelts_check = fold_build2 (LE_EXPR, boolean_type_node, 3040 outer_nelts, 3041 max_outer_nelts_tree); 3042 } 3043 } 3044 3045 tree align_arg = NULL_TREE; 3046 if (type_has_new_extended_alignment (elt_type)) 3047 align_arg = build_int_cst (align_type_node, TYPE_ALIGN_UNIT (elt_type)); 3048 3049 alloc_fn = NULL_TREE; 3050 3051 /* If PLACEMENT is a single simple pointer type not passed by 3052 reference, prepare to capture it in a temporary variable. Do 3053 this now, since PLACEMENT will change in the calls below. */ 3054 placement_first = NULL_TREE; 3055 if (vec_safe_length (*placement) == 1 3056 && (TYPE_PTR_P (TREE_TYPE ((**placement)[0])))) 3057 placement_first = (**placement)[0]; 3058 3059 bool member_new_p = false; 3060 3061 /* Allocate the object. */ 3062 tree fnname; 3063 tree fns; 3064 3065 fnname = ovl_op_identifier (false, array_p ? VEC_NEW_EXPR : NEW_EXPR); 3066 3067 member_new_p = !globally_qualified_p 3068 && CLASS_TYPE_P (elt_type) 3069 && (array_p 3070 ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type) 3071 : TYPE_HAS_NEW_OPERATOR (elt_type)); 3072 3073 if (member_new_p) 3074 { 3075 /* Use a class-specific operator new. */ 3076 /* If a cookie is required, add some extra space. */ 3077 if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type)) 3078 size = size_binop (PLUS_EXPR, size, cookie_size); 3079 else 3080 { 3081 cookie_size = NULL_TREE; 3082 /* No size arithmetic necessary, so the size check is 3083 not needed. */ 3084 if (outer_nelts_check != NULL && inner_size == 1) 3085 outer_nelts_check = NULL_TREE; 3086 } 3087 /* Perform the overflow check. */ 3088 tree errval = TYPE_MAX_VALUE (sizetype); 3089 if (cxx_dialect >= cxx11 && flag_exceptions) 3090 errval = throw_bad_array_new_length (); 3091 if (outer_nelts_check != NULL_TREE) 3092 size = fold_build3 (COND_EXPR, sizetype, outer_nelts_check, 3093 size, errval); 3094 /* Create the argument list. */ 3095 vec_safe_insert (*placement, 0, size); 3096 /* Do name-lookup to find the appropriate operator. */ 3097 fns = lookup_fnfields (elt_type, fnname, /*protect=*/2); 3098 if (fns == NULL_TREE) 3099 { 3100 if (complain & tf_error) 3101 error ("no suitable %qD found in class %qT", fnname, elt_type); 3102 return error_mark_node; 3103 } 3104 if (TREE_CODE (fns) == TREE_LIST) 3105 { 3106 if (complain & tf_error) 3107 { 3108 error ("request for member %qD is ambiguous", fnname); 3109 print_candidates (fns); 3110 } 3111 return error_mark_node; 3112 } 3113 tree dummy = build_dummy_object (elt_type); 3114 alloc_call = NULL_TREE; 3115 if (align_arg) 3116 { 3117 vec<tree, va_gc> *align_args 3118 = vec_copy_and_insert (*placement, align_arg, 1); 3119 alloc_call 3120 = build_new_method_call (dummy, fns, &align_args, 3121 /*conversion_path=*/NULL_TREE, 3122 LOOKUP_NORMAL, &alloc_fn, tf_none); 3123 /* If no matching function is found and the allocated object type 3124 has new-extended alignment, the alignment argument is removed 3125 from the argument list, and overload resolution is performed 3126 again. */ 3127 if (alloc_call == error_mark_node) 3128 alloc_call = NULL_TREE; 3129 } 3130 if (!alloc_call) 3131 alloc_call = build_new_method_call (dummy, fns, placement, 3132 /*conversion_path=*/NULL_TREE, 3133 LOOKUP_NORMAL, 3134 &alloc_fn, complain); 3135 } 3136 else 3137 { 3138 /* Use a global operator new. */ 3139 /* See if a cookie might be required. */ 3140 if (!(array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))) 3141 { 3142 cookie_size = NULL_TREE; 3143 /* No size arithmetic necessary, so the size check is 3144 not needed. */ 3145 if (outer_nelts_check != NULL && inner_size == 1) 3146 outer_nelts_check = NULL_TREE; 3147 } 3148 3149 alloc_call = build_operator_new_call (fnname, placement, 3150 &size, &cookie_size, 3151 align_arg, outer_nelts_check, 3152 &alloc_fn, complain); 3153 } 3154 3155 if (alloc_call == error_mark_node) 3156 return error_mark_node; 3157 3158 gcc_assert (alloc_fn != NULL_TREE); 3159 3160 /* Now, check to see if this function is actually a placement 3161 allocation function. This can happen even when PLACEMENT is NULL 3162 because we might have something like: 3163 3164 struct S { void* operator new (size_t, int i = 0); }; 3165 3166 A call to `new S' will get this allocation function, even though 3167 there is no explicit placement argument. If there is more than 3168 one argument, or there are variable arguments, then this is a 3169 placement allocation function. */ 3170 placement_allocation_fn_p 3171 = (type_num_arguments (TREE_TYPE (alloc_fn)) > 1 3172 || varargs_function_p (alloc_fn)); 3173 3174 if (warn_aligned_new 3175 && !placement_allocation_fn_p 3176 && TYPE_ALIGN (elt_type) > malloc_alignment () 3177 && (warn_aligned_new > 1 3178 || CP_DECL_CONTEXT (alloc_fn) == global_namespace) 3179 && !aligned_allocation_fn_p (alloc_fn)) 3180 { 3181 if (warning (OPT_Waligned_new_, "%<new%> of type %qT with extended " 3182 "alignment %d", elt_type, TYPE_ALIGN_UNIT (elt_type))) 3183 { 3184 inform (input_location, "uses %qD, which does not have an alignment " 3185 "parameter", alloc_fn); 3186 if (!aligned_new_threshold) 3187 inform (input_location, "use %<-faligned-new%> to enable C++17 " 3188 "over-aligned new support"); 3189 } 3190 } 3191 3192 /* If we found a simple case of PLACEMENT_EXPR above, then copy it 3193 into a temporary variable. */ 3194 if (!processing_template_decl 3195 && TREE_CODE (alloc_call) == CALL_EXPR 3196 && call_expr_nargs (alloc_call) == 2 3197 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 0))) == INTEGER_TYPE 3198 && TYPE_PTR_P (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 1)))) 3199 { 3200 tree placement = CALL_EXPR_ARG (alloc_call, 1); 3201 3202 if (placement_first != NULL_TREE 3203 && (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (TREE_TYPE (placement))) 3204 || VOID_TYPE_P (TREE_TYPE (TREE_TYPE (placement))))) 3205 { 3206 placement_expr = get_target_expr (placement_first); 3207 CALL_EXPR_ARG (alloc_call, 1) 3208 = fold_convert (TREE_TYPE (placement), placement_expr); 3209 } 3210 3211 if (!member_new_p 3212 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 1))))) 3213 { 3214 /* Attempt to make the warning point at the operator new argument. */ 3215 if (placement_first) 3216 placement = placement_first; 3217 3218 warn_placement_new_too_small (orig_type, nelts, size, placement); 3219 } 3220 } 3221 3222 /* In the simple case, we can stop now. */ 3223 pointer_type = build_pointer_type (type); 3224 if (!cookie_size && !is_initialized) 3225 return build_nop (pointer_type, alloc_call); 3226 3227 /* Store the result of the allocation call in a variable so that we can 3228 use it more than once. */ 3229 alloc_expr = get_target_expr (alloc_call); 3230 alloc_node = TARGET_EXPR_SLOT (alloc_expr); 3231 3232 /* Strip any COMPOUND_EXPRs from ALLOC_CALL. */ 3233 while (TREE_CODE (alloc_call) == COMPOUND_EXPR) 3234 alloc_call = TREE_OPERAND (alloc_call, 1); 3235 3236 /* Preevaluate the placement args so that we don't reevaluate them for a 3237 placement delete. */ 3238 if (placement_allocation_fn_p) 3239 { 3240 tree inits; 3241 stabilize_call (alloc_call, &inits); 3242 if (inits) 3243 alloc_expr = build2 (COMPOUND_EXPR, TREE_TYPE (alloc_expr), inits, 3244 alloc_expr); 3245 } 3246 3247 /* unless an allocation function is declared with an empty excep- 3248 tion-specification (_except.spec_), throw(), it indicates failure to 3249 allocate storage by throwing a bad_alloc exception (clause _except_, 3250 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo- 3251 cation function is declared with an empty exception-specification, 3252 throw(), it returns null to indicate failure to allocate storage and a 3253 non-null pointer otherwise. 3254 3255 So check for a null exception spec on the op new we just called. */ 3256 3257 nothrow = TYPE_NOTHROW_P (TREE_TYPE (alloc_fn)); 3258 check_new 3259 = flag_check_new || (nothrow && !std_placement_new_fn_p (alloc_fn)); 3260 3261 if (cookie_size) 3262 { 3263 tree cookie; 3264 tree cookie_ptr; 3265 tree size_ptr_type; 3266 3267 /* Adjust so we're pointing to the start of the object. */ 3268 data_addr = fold_build_pointer_plus (alloc_node, cookie_size); 3269 3270 /* Store the number of bytes allocated so that we can know how 3271 many elements to destroy later. We use the last sizeof 3272 (size_t) bytes to store the number of elements. */ 3273 cookie_ptr = size_binop (MINUS_EXPR, cookie_size, size_in_bytes (sizetype)); 3274 cookie_ptr = fold_build_pointer_plus_loc (input_location, 3275 alloc_node, cookie_ptr); 3276 size_ptr_type = build_pointer_type (sizetype); 3277 cookie_ptr = fold_convert (size_ptr_type, cookie_ptr); 3278 cookie = cp_build_fold_indirect_ref (cookie_ptr); 3279 3280 cookie_expr = build2 (MODIFY_EXPR, sizetype, cookie, nelts); 3281 3282 if (targetm.cxx.cookie_has_size ()) 3283 { 3284 /* Also store the element size. */ 3285 cookie_ptr = fold_build_pointer_plus (cookie_ptr, 3286 fold_build1_loc (input_location, 3287 NEGATE_EXPR, sizetype, 3288 size_in_bytes (sizetype))); 3289 3290 cookie = cp_build_fold_indirect_ref (cookie_ptr); 3291 cookie = build2 (MODIFY_EXPR, sizetype, cookie, 3292 size_in_bytes (elt_type)); 3293 cookie_expr = build2 (COMPOUND_EXPR, TREE_TYPE (cookie_expr), 3294 cookie, cookie_expr); 3295 } 3296 } 3297 else 3298 { 3299 cookie_expr = NULL_TREE; 3300 data_addr = alloc_node; 3301 } 3302 3303 /* Now use a pointer to the type we've actually allocated. */ 3304 3305 /* But we want to operate on a non-const version to start with, 3306 since we'll be modifying the elements. */ 3307 non_const_pointer_type = build_pointer_type 3308 (cp_build_qualified_type (type, cp_type_quals (type) & ~TYPE_QUAL_CONST)); 3309 3310 data_addr = fold_convert (non_const_pointer_type, data_addr); 3311 /* Any further uses of alloc_node will want this type, too. */ 3312 alloc_node = fold_convert (non_const_pointer_type, alloc_node); 3313 3314 /* Now initialize the allocated object. Note that we preevaluate the 3315 initialization expression, apart from the actual constructor call or 3316 assignment--we do this because we want to delay the allocation as long 3317 as possible in order to minimize the size of the exception region for 3318 placement delete. */ 3319 if (is_initialized) 3320 { 3321 bool stable; 3322 bool explicit_value_init_p = false; 3323 3324 if (*init != NULL && (*init)->is_empty ()) 3325 { 3326 *init = NULL; 3327 explicit_value_init_p = true; 3328 } 3329 3330 if (processing_template_decl && explicit_value_init_p) 3331 { 3332 /* build_value_init doesn't work in templates, and we don't need 3333 the initializer anyway since we're going to throw it away and 3334 rebuild it at instantiation time, so just build up a single 3335 constructor call to get any appropriate diagnostics. */ 3336 init_expr = cp_build_fold_indirect_ref (data_addr); 3337 if (type_build_ctor_call (elt_type)) 3338 init_expr = build_special_member_call (init_expr, 3339 complete_ctor_identifier, 3340 init, elt_type, 3341 LOOKUP_NORMAL, 3342 complain); 3343 stable = stabilize_init (init_expr, &init_preeval_expr); 3344 } 3345 else if (array_p) 3346 { 3347 tree vecinit = NULL_TREE; 3348 if (vec_safe_length (*init) == 1 3349 && DIRECT_LIST_INIT_P ((**init)[0])) 3350 { 3351 vecinit = (**init)[0]; 3352 if (CONSTRUCTOR_NELTS (vecinit) == 0) 3353 /* List-value-initialization, leave it alone. */; 3354 else 3355 { 3356 tree arraytype, domain; 3357 if (TREE_CONSTANT (nelts)) 3358 domain = compute_array_index_type (NULL_TREE, nelts, 3359 complain); 3360 else 3361 /* We'll check the length at runtime. */ 3362 domain = NULL_TREE; 3363 arraytype = build_cplus_array_type (type, domain); 3364 vecinit = digest_init (arraytype, vecinit, complain); 3365 } 3366 } 3367 else if (*init) 3368 { 3369 if (complain & tf_error) 3370 error ("parenthesized initializer in array new"); 3371 return error_mark_node; 3372 } 3373 init_expr 3374 = build_vec_init (data_addr, 3375 cp_build_binary_op (input_location, 3376 MINUS_EXPR, outer_nelts, 3377 integer_one_node, 3378 complain), 3379 vecinit, 3380 explicit_value_init_p, 3381 /*from_array=*/0, 3382 complain); 3383 3384 /* An array initialization is stable because the initialization 3385 of each element is a full-expression, so the temporaries don't 3386 leak out. */ 3387 stable = true; 3388 } 3389 else 3390 { 3391 init_expr = cp_build_fold_indirect_ref (data_addr); 3392 3393 if (type_build_ctor_call (type) && !explicit_value_init_p) 3394 { 3395 init_expr = build_special_member_call (init_expr, 3396 complete_ctor_identifier, 3397 init, elt_type, 3398 LOOKUP_NORMAL, 3399 complain); 3400 } 3401 else if (explicit_value_init_p) 3402 { 3403 /* Something like `new int()'. NO_CLEANUP is needed so 3404 we don't try and build a (possibly ill-formed) 3405 destructor. */ 3406 tree val = build_value_init (type, complain | tf_no_cleanup); 3407 if (val == error_mark_node) 3408 return error_mark_node; 3409 init_expr = build2 (INIT_EXPR, type, init_expr, val); 3410 } 3411 else 3412 { 3413 tree ie; 3414 3415 /* We are processing something like `new int (10)', which 3416 means allocate an int, and initialize it with 10. */ 3417 3418 ie = build_x_compound_expr_from_vec (*init, "new initializer", 3419 complain); 3420 init_expr = cp_build_modify_expr (input_location, init_expr, 3421 INIT_EXPR, ie, complain); 3422 } 3423 /* If the initializer uses C++14 aggregate NSDMI that refer to the 3424 object being initialized, replace them now and don't try to 3425 preevaluate. */ 3426 bool had_placeholder = false; 3427 if (!processing_template_decl 3428 && TREE_CODE (init_expr) == INIT_EXPR) 3429 TREE_OPERAND (init_expr, 1) 3430 = replace_placeholders (TREE_OPERAND (init_expr, 1), 3431 TREE_OPERAND (init_expr, 0), 3432 &had_placeholder); 3433 stable = (!had_placeholder 3434 && stabilize_init (init_expr, &init_preeval_expr)); 3435 } 3436 3437 if (init_expr == error_mark_node) 3438 return error_mark_node; 3439 3440 /* If any part of the object initialization terminates by throwing an 3441 exception and a suitable deallocation function can be found, the 3442 deallocation function is called to free the memory in which the 3443 object was being constructed, after which the exception continues 3444 to propagate in the context of the new-expression. If no 3445 unambiguous matching deallocation function can be found, 3446 propagating the exception does not cause the object's memory to be 3447 freed. */ 3448 if (flag_exceptions) 3449 { 3450 enum tree_code dcode = array_p ? VEC_DELETE_EXPR : DELETE_EXPR; 3451 tree cleanup; 3452 3453 /* The Standard is unclear here, but the right thing to do 3454 is to use the same method for finding deallocation 3455 functions that we use for finding allocation functions. */ 3456 cleanup = (build_op_delete_call 3457 (dcode, 3458 alloc_node, 3459 size, 3460 globally_qualified_p, 3461 placement_allocation_fn_p ? alloc_call : NULL_TREE, 3462 alloc_fn, 3463 complain)); 3464 3465 if (!cleanup) 3466 /* We're done. */; 3467 else if (stable) 3468 /* This is much simpler if we were able to preevaluate all of 3469 the arguments to the constructor call. */ 3470 { 3471 /* CLEANUP is compiler-generated, so no diagnostics. */ 3472 TREE_NO_WARNING (cleanup) = true; 3473 init_expr = build2 (TRY_CATCH_EXPR, void_type_node, 3474 init_expr, cleanup); 3475 /* Likewise, this try-catch is compiler-generated. */ 3476 TREE_NO_WARNING (init_expr) = true; 3477 } 3478 else 3479 /* Ack! First we allocate the memory. Then we set our sentry 3480 variable to true, and expand a cleanup that deletes the 3481 memory if sentry is true. Then we run the constructor, and 3482 finally clear the sentry. 3483 3484 We need to do this because we allocate the space first, so 3485 if there are any temporaries with cleanups in the 3486 constructor args and we weren't able to preevaluate them, we 3487 need this EH region to extend until end of full-expression 3488 to preserve nesting. */ 3489 { 3490 tree end, sentry, begin; 3491 3492 begin = get_target_expr (boolean_true_node); 3493 CLEANUP_EH_ONLY (begin) = 1; 3494 3495 sentry = TARGET_EXPR_SLOT (begin); 3496 3497 /* CLEANUP is compiler-generated, so no diagnostics. */ 3498 TREE_NO_WARNING (cleanup) = true; 3499 3500 TARGET_EXPR_CLEANUP (begin) 3501 = build3 (COND_EXPR, void_type_node, sentry, 3502 cleanup, void_node); 3503 3504 end = build2 (MODIFY_EXPR, TREE_TYPE (sentry), 3505 sentry, boolean_false_node); 3506 3507 init_expr 3508 = build2 (COMPOUND_EXPR, void_type_node, begin, 3509 build2 (COMPOUND_EXPR, void_type_node, init_expr, 3510 end)); 3511 /* Likewise, this is compiler-generated. */ 3512 TREE_NO_WARNING (init_expr) = true; 3513 } 3514 } 3515 } 3516 else 3517 init_expr = NULL_TREE; 3518 3519 /* Now build up the return value in reverse order. */ 3520 3521 rval = data_addr; 3522 3523 if (init_expr) 3524 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_expr, rval); 3525 if (cookie_expr) 3526 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), cookie_expr, rval); 3527 3528 if (rval == data_addr) 3529 /* If we don't have an initializer or a cookie, strip the TARGET_EXPR 3530 and return the call (which doesn't need to be adjusted). */ 3531 rval = TARGET_EXPR_INITIAL (alloc_expr); 3532 else 3533 { 3534 if (check_new) 3535 { 3536 tree ifexp = cp_build_binary_op (input_location, 3537 NE_EXPR, alloc_node, 3538 nullptr_node, 3539 complain); 3540 rval = build_conditional_expr (input_location, ifexp, rval, 3541 alloc_node, complain); 3542 } 3543 3544 /* Perform the allocation before anything else, so that ALLOC_NODE 3545 has been initialized before we start using it. */ 3546 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval); 3547 } 3548 3549 if (init_preeval_expr) 3550 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_preeval_expr, rval); 3551 3552 /* A new-expression is never an lvalue. */ 3553 gcc_assert (!obvalue_p (rval)); 3554 3555 return convert (pointer_type, rval); 3556 } 3557 3558 /* Generate a representation for a C++ "new" expression. *PLACEMENT 3559 is a vector of placement-new arguments (or NULL if none). If NELTS 3560 is NULL, TYPE is the type of the storage to be allocated. If NELTS 3561 is not NULL, then this is an array-new allocation; TYPE is the type 3562 of the elements in the array and NELTS is the number of elements in 3563 the array. *INIT, if non-NULL, is the initializer for the new 3564 object, or an empty vector to indicate an initializer of "()". If 3565 USE_GLOBAL_NEW is true, then the user explicitly wrote "::new" 3566 rather than just "new". This may change PLACEMENT and INIT. */ 3567 3568 tree 3569 build_new (vec<tree, va_gc> **placement, tree type, tree nelts, 3570 vec<tree, va_gc> **init, int use_global_new, tsubst_flags_t complain) 3571 { 3572 tree rval; 3573 vec<tree, va_gc> *orig_placement = NULL; 3574 tree orig_nelts = NULL_TREE; 3575 vec<tree, va_gc> *orig_init = NULL; 3576 3577 if (type == error_mark_node) 3578 return error_mark_node; 3579 3580 if (nelts == NULL_TREE 3581 /* Don't do auto deduction where it might affect mangling. */ 3582 && (!processing_template_decl || at_function_scope_p ())) 3583 { 3584 tree auto_node = type_uses_auto (type); 3585 if (auto_node) 3586 { 3587 tree d_init = NULL_TREE; 3588 if (vec_safe_length (*init) == 1) 3589 { 3590 d_init = (**init)[0]; 3591 d_init = resolve_nondeduced_context (d_init, complain); 3592 } 3593 type = do_auto_deduction (type, d_init, auto_node, complain); 3594 } 3595 } 3596 3597 if (processing_template_decl) 3598 { 3599 if (dependent_type_p (type) 3600 || any_type_dependent_arguments_p (*placement) 3601 || (nelts && type_dependent_expression_p (nelts)) 3602 || (nelts && *init) 3603 || any_type_dependent_arguments_p (*init)) 3604 return build_raw_new_expr (*placement, type, nelts, *init, 3605 use_global_new); 3606 3607 orig_placement = make_tree_vector_copy (*placement); 3608 orig_nelts = nelts; 3609 if (*init) 3610 { 3611 orig_init = make_tree_vector_copy (*init); 3612 /* Also copy any CONSTRUCTORs in *init, since reshape_init and 3613 digest_init clobber them in place. */ 3614 for (unsigned i = 0; i < orig_init->length(); ++i) 3615 { 3616 tree e = (**init)[i]; 3617 if (TREE_CODE (e) == CONSTRUCTOR) 3618 (**init)[i] = copy_node (e); 3619 } 3620 } 3621 3622 make_args_non_dependent (*placement); 3623 if (nelts) 3624 nelts = build_non_dependent_expr (nelts); 3625 make_args_non_dependent (*init); 3626 } 3627 3628 if (nelts) 3629 { 3630 if (!build_expr_type_conversion (WANT_INT | WANT_ENUM, nelts, false)) 3631 { 3632 if (complain & tf_error) 3633 permerror (input_location, "size in array new must have integral type"); 3634 else 3635 return error_mark_node; 3636 } 3637 3638 /* Try to determine the constant value only for the purposes 3639 of the diagnostic below but continue to use the original 3640 value and handle const folding later. */ 3641 const_tree cst_nelts = maybe_constant_value (nelts); 3642 3643 /* The expression in a noptr-new-declarator is erroneous if it's of 3644 non-class type and its value before converting to std::size_t is 3645 less than zero. ... If the expression is a constant expression, 3646 the program is ill-fomed. */ 3647 if (INTEGER_CST == TREE_CODE (cst_nelts) 3648 && tree_int_cst_sgn (cst_nelts) == -1) 3649 { 3650 if (complain & tf_error) 3651 error ("size of array is negative"); 3652 return error_mark_node; 3653 } 3654 3655 nelts = mark_rvalue_use (nelts); 3656 nelts = cp_save_expr (cp_convert (sizetype, nelts, complain)); 3657 } 3658 3659 /* ``A reference cannot be created by the new operator. A reference 3660 is not an object (8.2.2, 8.4.3), so a pointer to it could not be 3661 returned by new.'' ARM 5.3.3 */ 3662 if (TREE_CODE (type) == REFERENCE_TYPE) 3663 { 3664 if (complain & tf_error) 3665 error ("new cannot be applied to a reference type"); 3666 else 3667 return error_mark_node; 3668 type = TREE_TYPE (type); 3669 } 3670 3671 if (TREE_CODE (type) == FUNCTION_TYPE) 3672 { 3673 if (complain & tf_error) 3674 error ("new cannot be applied to a function type"); 3675 return error_mark_node; 3676 } 3677 3678 /* The type allocated must be complete. If the new-type-id was 3679 "T[N]" then we are just checking that "T" is complete here, but 3680 that is equivalent, since the value of "N" doesn't matter. */ 3681 if (!complete_type_or_maybe_complain (type, NULL_TREE, complain)) 3682 return error_mark_node; 3683 3684 rval = build_new_1 (placement, type, nelts, init, use_global_new, complain); 3685 if (rval == error_mark_node) 3686 return error_mark_node; 3687 3688 if (processing_template_decl) 3689 { 3690 tree ret = build_raw_new_expr (orig_placement, type, orig_nelts, 3691 orig_init, use_global_new); 3692 release_tree_vector (orig_placement); 3693 release_tree_vector (orig_init); 3694 return ret; 3695 } 3696 3697 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */ 3698 rval = build1 (NOP_EXPR, TREE_TYPE (rval), rval); 3699 TREE_NO_WARNING (rval) = 1; 3700 3701 return rval; 3702 } 3703 3704 static tree 3705 build_vec_delete_1 (tree base, tree maxindex, tree type, 3706 special_function_kind auto_delete_vec, 3707 int use_global_delete, tsubst_flags_t complain) 3708 { 3709 tree virtual_size; 3710 tree ptype = build_pointer_type (type = complete_type (type)); 3711 tree size_exp; 3712 3713 /* Temporary variables used by the loop. */ 3714 tree tbase, tbase_init; 3715 3716 /* This is the body of the loop that implements the deletion of a 3717 single element, and moves temp variables to next elements. */ 3718 tree body; 3719 3720 /* This is the LOOP_EXPR that governs the deletion of the elements. */ 3721 tree loop = 0; 3722 3723 /* This is the thing that governs what to do after the loop has run. */ 3724 tree deallocate_expr = 0; 3725 3726 /* This is the BIND_EXPR which holds the outermost iterator of the 3727 loop. It is convenient to set this variable up and test it before 3728 executing any other code in the loop. 3729 This is also the containing expression returned by this function. */ 3730 tree controller = NULL_TREE; 3731 tree tmp; 3732 3733 /* We should only have 1-D arrays here. */ 3734 gcc_assert (TREE_CODE (type) != ARRAY_TYPE); 3735 3736 if (base == error_mark_node || maxindex == error_mark_node) 3737 return error_mark_node; 3738 3739 if (!COMPLETE_TYPE_P (type)) 3740 { 3741 if ((complain & tf_warning) 3742 && warning (OPT_Wdelete_incomplete, 3743 "possible problem detected in invocation of " 3744 "delete [] operator:")) 3745 { 3746 cxx_incomplete_type_diagnostic (base, type, DK_WARNING); 3747 inform (input_location, "neither the destructor nor the " 3748 "class-specific operator delete [] will be called, " 3749 "even if they are declared when the class is defined"); 3750 } 3751 /* This size won't actually be used. */ 3752 size_exp = size_one_node; 3753 goto no_destructor; 3754 } 3755 3756 size_exp = size_in_bytes (type); 3757 3758 if (! MAYBE_CLASS_TYPE_P (type)) 3759 goto no_destructor; 3760 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type)) 3761 { 3762 /* Make sure the destructor is callable. */ 3763 if (type_build_dtor_call (type)) 3764 { 3765 tmp = build_delete (ptype, base, sfk_complete_destructor, 3766 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1, 3767 complain); 3768 if (tmp == error_mark_node) 3769 return error_mark_node; 3770 } 3771 goto no_destructor; 3772 } 3773 3774 /* The below is short by the cookie size. */ 3775 virtual_size = size_binop (MULT_EXPR, size_exp, 3776 fold_convert (sizetype, maxindex)); 3777 3778 tbase = create_temporary_var (ptype); 3779 tbase_init 3780 = cp_build_modify_expr (input_location, tbase, NOP_EXPR, 3781 fold_build_pointer_plus_loc (input_location, 3782 fold_convert (ptype, 3783 base), 3784 virtual_size), 3785 complain); 3786 if (tbase_init == error_mark_node) 3787 return error_mark_node; 3788 controller = build3 (BIND_EXPR, void_type_node, tbase, 3789 NULL_TREE, NULL_TREE); 3790 TREE_SIDE_EFFECTS (controller) = 1; 3791 3792 body = build1 (EXIT_EXPR, void_type_node, 3793 build2 (EQ_EXPR, boolean_type_node, tbase, 3794 fold_convert (ptype, base))); 3795 tmp = fold_build1_loc (input_location, NEGATE_EXPR, sizetype, size_exp); 3796 tmp = fold_build_pointer_plus (tbase, tmp); 3797 tmp = cp_build_modify_expr (input_location, tbase, NOP_EXPR, tmp, complain); 3798 if (tmp == error_mark_node) 3799 return error_mark_node; 3800 body = build_compound_expr (input_location, body, tmp); 3801 tmp = build_delete (ptype, tbase, sfk_complete_destructor, 3802 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1, 3803 complain); 3804 if (tmp == error_mark_node) 3805 return error_mark_node; 3806 body = build_compound_expr (input_location, body, tmp); 3807 3808 loop = build1 (LOOP_EXPR, void_type_node, body); 3809 loop = build_compound_expr (input_location, tbase_init, loop); 3810 3811 no_destructor: 3812 /* Delete the storage if appropriate. */ 3813 if (auto_delete_vec == sfk_deleting_destructor) 3814 { 3815 tree base_tbd; 3816 3817 /* The below is short by the cookie size. */ 3818 virtual_size = size_binop (MULT_EXPR, size_exp, 3819 fold_convert (sizetype, maxindex)); 3820 3821 if (! TYPE_VEC_NEW_USES_COOKIE (type)) 3822 /* no header */ 3823 base_tbd = base; 3824 else 3825 { 3826 tree cookie_size; 3827 3828 cookie_size = targetm.cxx.get_cookie_size (type); 3829 base_tbd = cp_build_binary_op (input_location, 3830 MINUS_EXPR, 3831 cp_convert (string_type_node, 3832 base, complain), 3833 cookie_size, 3834 complain); 3835 if (base_tbd == error_mark_node) 3836 return error_mark_node; 3837 base_tbd = cp_convert (ptype, base_tbd, complain); 3838 /* True size with header. */ 3839 virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size); 3840 } 3841 3842 deallocate_expr = build_op_delete_call (VEC_DELETE_EXPR, 3843 base_tbd, virtual_size, 3844 use_global_delete & 1, 3845 /*placement=*/NULL_TREE, 3846 /*alloc_fn=*/NULL_TREE, 3847 complain); 3848 } 3849 3850 body = loop; 3851 if (!deallocate_expr) 3852 ; 3853 else if (!body) 3854 body = deallocate_expr; 3855 else 3856 /* The delete operator mist be called, even if a destructor 3857 throws. */ 3858 body = build2 (TRY_FINALLY_EXPR, void_type_node, body, deallocate_expr); 3859 3860 if (!body) 3861 body = integer_zero_node; 3862 3863 /* Outermost wrapper: If pointer is null, punt. */ 3864 tree cond = build2_loc (input_location, NE_EXPR, boolean_type_node, base, 3865 fold_convert (TREE_TYPE (base), nullptr_node)); 3866 /* This is a compiler generated comparison, don't emit 3867 e.g. -Wnonnull-compare warning for it. */ 3868 TREE_NO_WARNING (cond) = 1; 3869 body = build3_loc (input_location, COND_EXPR, void_type_node, 3870 cond, body, integer_zero_node); 3871 COND_EXPR_IS_VEC_DELETE (body) = true; 3872 body = build1 (NOP_EXPR, void_type_node, body); 3873 3874 if (controller) 3875 { 3876 TREE_OPERAND (controller, 1) = body; 3877 body = controller; 3878 } 3879 3880 if (TREE_CODE (base) == SAVE_EXPR) 3881 /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */ 3882 body = build2 (COMPOUND_EXPR, void_type_node, base, body); 3883 3884 return convert_to_void (body, ICV_CAST, complain); 3885 } 3886 3887 /* Create an unnamed variable of the indicated TYPE. */ 3888 3889 tree 3890 create_temporary_var (tree type) 3891 { 3892 tree decl; 3893 3894 decl = build_decl (input_location, 3895 VAR_DECL, NULL_TREE, type); 3896 TREE_USED (decl) = 1; 3897 DECL_ARTIFICIAL (decl) = 1; 3898 DECL_IGNORED_P (decl) = 1; 3899 DECL_CONTEXT (decl) = current_function_decl; 3900 3901 return decl; 3902 } 3903 3904 /* Create a new temporary variable of the indicated TYPE, initialized 3905 to INIT. 3906 3907 It is not entered into current_binding_level, because that breaks 3908 things when it comes time to do final cleanups (which take place 3909 "outside" the binding contour of the function). */ 3910 3911 tree 3912 get_temp_regvar (tree type, tree init) 3913 { 3914 tree decl; 3915 3916 decl = create_temporary_var (type); 3917 add_decl_expr (decl); 3918 3919 finish_expr_stmt (cp_build_modify_expr (input_location, decl, INIT_EXPR, 3920 init, tf_warning_or_error)); 3921 3922 return decl; 3923 } 3924 3925 /* Subroutine of build_vec_init. Returns true if assigning to an array of 3926 INNER_ELT_TYPE from INIT is trivial. */ 3927 3928 static bool 3929 vec_copy_assign_is_trivial (tree inner_elt_type, tree init) 3930 { 3931 tree fromtype = inner_elt_type; 3932 if (lvalue_p (init)) 3933 fromtype = cp_build_reference_type (fromtype, /*rval*/false); 3934 return is_trivially_xible (MODIFY_EXPR, inner_elt_type, fromtype); 3935 } 3936 3937 /* Subroutine of build_vec_init: Check that the array has at least N 3938 elements. Other parameters are local variables in build_vec_init. */ 3939 3940 void 3941 finish_length_check (tree atype, tree iterator, tree obase, unsigned n) 3942 { 3943 tree nelts = build_int_cst (ptrdiff_type_node, n - 1); 3944 if (TREE_CODE (atype) != ARRAY_TYPE) 3945 { 3946 if (flag_exceptions) 3947 { 3948 tree c = fold_build2 (LT_EXPR, boolean_type_node, iterator, 3949 nelts); 3950 c = build3 (COND_EXPR, void_type_node, c, 3951 throw_bad_array_new_length (), void_node); 3952 finish_expr_stmt (c); 3953 } 3954 /* Don't check an array new when -fno-exceptions. */ 3955 } 3956 else if (sanitize_flags_p (SANITIZE_BOUNDS) 3957 && current_function_decl != NULL_TREE) 3958 { 3959 /* Make sure the last element of the initializer is in bounds. */ 3960 finish_expr_stmt 3961 (ubsan_instrument_bounds 3962 (input_location, obase, &nelts, /*ignore_off_by_one*/false)); 3963 } 3964 } 3965 3966 /* `build_vec_init' returns tree structure that performs 3967 initialization of a vector of aggregate types. 3968 3969 BASE is a reference to the vector, of ARRAY_TYPE, or a pointer 3970 to the first element, of POINTER_TYPE. 3971 MAXINDEX is the maximum index of the array (one less than the 3972 number of elements). It is only used if BASE is a pointer or 3973 TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE. 3974 3975 INIT is the (possibly NULL) initializer. 3976 3977 If EXPLICIT_VALUE_INIT_P is true, then INIT must be NULL. All 3978 elements in the array are value-initialized. 3979 3980 FROM_ARRAY is 0 if we should init everything with INIT 3981 (i.e., every element initialized from INIT). 3982 FROM_ARRAY is 1 if we should index into INIT in parallel 3983 with initialization of DECL. 3984 FROM_ARRAY is 2 if we should index into INIT in parallel, 3985 but use assignment instead of initialization. */ 3986 3987 tree 3988 build_vec_init (tree base, tree maxindex, tree init, 3989 bool explicit_value_init_p, 3990 int from_array, tsubst_flags_t complain) 3991 { 3992 tree rval; 3993 tree base2 = NULL_TREE; 3994 tree itype = NULL_TREE; 3995 tree iterator; 3996 /* The type of BASE. */ 3997 tree atype = TREE_TYPE (base); 3998 /* The type of an element in the array. */ 3999 tree type = TREE_TYPE (atype); 4000 /* The element type reached after removing all outer array 4001 types. */ 4002 tree inner_elt_type; 4003 /* The type of a pointer to an element in the array. */ 4004 tree ptype; 4005 tree stmt_expr; 4006 tree compound_stmt; 4007 int destroy_temps; 4008 tree try_block = NULL_TREE; 4009 int num_initialized_elts = 0; 4010 bool is_global; 4011 tree obase = base; 4012 bool xvalue = false; 4013 bool errors = false; 4014 location_t loc = (init ? EXPR_LOC_OR_LOC (init, input_location) 4015 : location_of (base)); 4016 4017 if (TREE_CODE (atype) == ARRAY_TYPE && TYPE_DOMAIN (atype)) 4018 maxindex = array_type_nelts (atype); 4019 4020 if (maxindex == NULL_TREE || maxindex == error_mark_node) 4021 return error_mark_node; 4022 4023 maxindex = maybe_constant_value (maxindex); 4024 if (explicit_value_init_p) 4025 gcc_assert (!init); 4026 4027 inner_elt_type = strip_array_types (type); 4028 4029 /* Look through the TARGET_EXPR around a compound literal. */ 4030 if (init && TREE_CODE (init) == TARGET_EXPR 4031 && TREE_CODE (TARGET_EXPR_INITIAL (init)) == CONSTRUCTOR 4032 && from_array != 2) 4033 init = TARGET_EXPR_INITIAL (init); 4034 4035 bool direct_init = false; 4036 if (from_array && init && BRACE_ENCLOSED_INITIALIZER_P (init) 4037 && CONSTRUCTOR_NELTS (init) == 1) 4038 { 4039 tree elt = CONSTRUCTOR_ELT (init, 0)->value; 4040 if (TREE_CODE (TREE_TYPE (elt)) == ARRAY_TYPE) 4041 { 4042 direct_init = DIRECT_LIST_INIT_P (init); 4043 init = elt; 4044 } 4045 } 4046 4047 /* If we have a braced-init-list or string constant, make sure that the array 4048 is big enough for all the initializers. */ 4049 bool length_check = (init 4050 && (TREE_CODE (init) == STRING_CST 4051 || (TREE_CODE (init) == CONSTRUCTOR 4052 && CONSTRUCTOR_NELTS (init) > 0)) 4053 && !TREE_CONSTANT (maxindex)); 4054 4055 if (init 4056 && TREE_CODE (atype) == ARRAY_TYPE 4057 && TREE_CONSTANT (maxindex) 4058 && (from_array == 2 4059 ? vec_copy_assign_is_trivial (inner_elt_type, init) 4060 : !TYPE_NEEDS_CONSTRUCTING (type)) 4061 && ((TREE_CODE (init) == CONSTRUCTOR 4062 && (BRACE_ENCLOSED_INITIALIZER_P (init) 4063 || (same_type_ignoring_top_level_qualifiers_p 4064 (atype, TREE_TYPE (init)))) 4065 /* Don't do this if the CONSTRUCTOR might contain something 4066 that might throw and require us to clean up. */ 4067 && (vec_safe_is_empty (CONSTRUCTOR_ELTS (init)) 4068 || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_elt_type))) 4069 || from_array)) 4070 { 4071 /* Do non-default initialization of trivial arrays resulting from 4072 brace-enclosed initializers. In this case, digest_init and 4073 store_constructor will handle the semantics for us. */ 4074 4075 if (BRACE_ENCLOSED_INITIALIZER_P (init)) 4076 init = digest_init (atype, init, complain); 4077 stmt_expr = build2 (INIT_EXPR, atype, base, init); 4078 return stmt_expr; 4079 } 4080 4081 maxindex = cp_convert (ptrdiff_type_node, maxindex, complain); 4082 maxindex = fold_simple (maxindex); 4083 4084 if (TREE_CODE (atype) == ARRAY_TYPE) 4085 { 4086 ptype = build_pointer_type (type); 4087 base = decay_conversion (base, complain); 4088 if (base == error_mark_node) 4089 return error_mark_node; 4090 base = cp_convert (ptype, base, complain); 4091 } 4092 else 4093 ptype = atype; 4094 4095 /* The code we are generating looks like: 4096 ({ 4097 T* t1 = (T*) base; 4098 T* rval = t1; 4099 ptrdiff_t iterator = maxindex; 4100 try { 4101 for (; iterator != -1; --iterator) { 4102 ... initialize *t1 ... 4103 ++t1; 4104 } 4105 } catch (...) { 4106 ... destroy elements that were constructed ... 4107 } 4108 rval; 4109 }) 4110 4111 We can omit the try and catch blocks if we know that the 4112 initialization will never throw an exception, or if the array 4113 elements do not have destructors. We can omit the loop completely if 4114 the elements of the array do not have constructors. 4115 4116 We actually wrap the entire body of the above in a STMT_EXPR, for 4117 tidiness. 4118 4119 When copying from array to another, when the array elements have 4120 only trivial copy constructors, we should use __builtin_memcpy 4121 rather than generating a loop. That way, we could take advantage 4122 of whatever cleverness the back end has for dealing with copies 4123 of blocks of memory. */ 4124 4125 is_global = begin_init_stmts (&stmt_expr, &compound_stmt); 4126 destroy_temps = stmts_are_full_exprs_p (); 4127 current_stmt_tree ()->stmts_are_full_exprs_p = 0; 4128 rval = get_temp_regvar (ptype, base); 4129 base = get_temp_regvar (ptype, rval); 4130 iterator = get_temp_regvar (ptrdiff_type_node, maxindex); 4131 4132 /* If initializing one array from another, initialize element by 4133 element. We rely upon the below calls to do the argument 4134 checking. Evaluate the initializer before entering the try block. */ 4135 if (from_array && init && TREE_CODE (init) != CONSTRUCTOR) 4136 { 4137 if (lvalue_kind (init) & clk_rvalueref) 4138 xvalue = true; 4139 base2 = decay_conversion (init, complain); 4140 if (base2 == error_mark_node) 4141 return error_mark_node; 4142 itype = TREE_TYPE (base2); 4143 base2 = get_temp_regvar (itype, base2); 4144 itype = TREE_TYPE (itype); 4145 } 4146 4147 /* Protect the entire array initialization so that we can destroy 4148 the partially constructed array if an exception is thrown. 4149 But don't do this if we're assigning. */ 4150 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type) 4151 && from_array != 2) 4152 { 4153 try_block = begin_try_block (); 4154 } 4155 4156 /* Should we try to create a constant initializer? */ 4157 bool try_const = (TREE_CODE (atype) == ARRAY_TYPE 4158 && TREE_CONSTANT (maxindex) 4159 && (init ? TREE_CODE (init) == CONSTRUCTOR 4160 : (type_has_constexpr_default_constructor 4161 (inner_elt_type))) 4162 && (literal_type_p (inner_elt_type) 4163 || TYPE_HAS_CONSTEXPR_CTOR (inner_elt_type))); 4164 vec<constructor_elt, va_gc> *const_vec = NULL; 4165 bool saw_non_const = false; 4166 /* If we're initializing a static array, we want to do static 4167 initialization of any elements with constant initializers even if 4168 some are non-constant. */ 4169 bool do_static_init = (DECL_P (obase) && TREE_STATIC (obase)); 4170 4171 bool empty_list = false; 4172 if (init && BRACE_ENCLOSED_INITIALIZER_P (init) 4173 && CONSTRUCTOR_NELTS (init) == 0) 4174 /* Skip over the handling of non-empty init lists. */ 4175 empty_list = true; 4176 4177 /* Maybe pull out constant value when from_array? */ 4178 4179 else if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR) 4180 { 4181 /* Do non-default initialization of non-trivial arrays resulting from 4182 brace-enclosed initializers. */ 4183 unsigned HOST_WIDE_INT idx; 4184 tree field, elt; 4185 /* If the constructor already has the array type, it's been through 4186 digest_init, so we shouldn't try to do anything more. */ 4187 bool digested = same_type_p (atype, TREE_TYPE (init)); 4188 from_array = 0; 4189 4190 if (length_check) 4191 finish_length_check (atype, iterator, obase, CONSTRUCTOR_NELTS (init)); 4192 4193 if (try_const) 4194 vec_alloc (const_vec, CONSTRUCTOR_NELTS (init)); 4195 4196 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx, field, elt) 4197 { 4198 tree baseref = build1 (INDIRECT_REF, type, base); 4199 tree one_init; 4200 4201 num_initialized_elts++; 4202 4203 current_stmt_tree ()->stmts_are_full_exprs_p = 1; 4204 if (digested) 4205 one_init = build2 (INIT_EXPR, type, baseref, elt); 4206 else if (MAYBE_CLASS_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE) 4207 one_init = build_aggr_init (baseref, elt, 0, complain); 4208 else 4209 one_init = cp_build_modify_expr (input_location, baseref, 4210 NOP_EXPR, elt, complain); 4211 if (one_init == error_mark_node) 4212 errors = true; 4213 if (try_const) 4214 { 4215 tree e = maybe_constant_init (one_init); 4216 if (reduced_constant_expression_p (e)) 4217 { 4218 CONSTRUCTOR_APPEND_ELT (const_vec, field, e); 4219 if (do_static_init) 4220 one_init = NULL_TREE; 4221 else 4222 one_init = build2 (INIT_EXPR, type, baseref, e); 4223 } 4224 else 4225 { 4226 if (do_static_init) 4227 { 4228 tree value = build_zero_init (TREE_TYPE (e), NULL_TREE, 4229 true); 4230 if (value) 4231 CONSTRUCTOR_APPEND_ELT (const_vec, field, value); 4232 } 4233 saw_non_const = true; 4234 } 4235 } 4236 4237 if (one_init) 4238 finish_expr_stmt (one_init); 4239 current_stmt_tree ()->stmts_are_full_exprs_p = 0; 4240 4241 one_init = cp_build_unary_op (PREINCREMENT_EXPR, base, false, 4242 complain); 4243 if (one_init == error_mark_node) 4244 errors = true; 4245 else 4246 finish_expr_stmt (one_init); 4247 4248 one_init = cp_build_unary_op (PREDECREMENT_EXPR, iterator, false, 4249 complain); 4250 if (one_init == error_mark_node) 4251 errors = true; 4252 else 4253 finish_expr_stmt (one_init); 4254 } 4255 4256 /* Any elements without explicit initializers get T{}. */ 4257 empty_list = true; 4258 } 4259 else if (init && TREE_CODE (init) == STRING_CST) 4260 { 4261 /* Check that the array is at least as long as the string. */ 4262 if (length_check) 4263 finish_length_check (atype, iterator, obase, 4264 TREE_STRING_LENGTH (init)); 4265 tree length = build_int_cst (ptrdiff_type_node, 4266 TREE_STRING_LENGTH (init)); 4267 4268 /* Copy the string to the first part of the array. */ 4269 tree alias_set = build_int_cst (build_pointer_type (type), 0); 4270 tree lhs = build2 (MEM_REF, TREE_TYPE (init), base, alias_set); 4271 tree stmt = build2 (MODIFY_EXPR, void_type_node, lhs, init); 4272 finish_expr_stmt (stmt); 4273 4274 /* Adjust the counter and pointer. */ 4275 stmt = cp_build_binary_op (loc, MINUS_EXPR, iterator, length, complain); 4276 stmt = build2 (MODIFY_EXPR, void_type_node, iterator, stmt); 4277 finish_expr_stmt (stmt); 4278 4279 stmt = cp_build_binary_op (loc, PLUS_EXPR, base, length, complain); 4280 stmt = build2 (MODIFY_EXPR, void_type_node, base, stmt); 4281 finish_expr_stmt (stmt); 4282 4283 /* And set the rest of the array to NUL. */ 4284 from_array = 0; 4285 explicit_value_init_p = true; 4286 } 4287 else if (from_array) 4288 { 4289 if (init) 4290 /* OK, we set base2 above. */; 4291 else if (CLASS_TYPE_P (type) 4292 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type)) 4293 { 4294 if (complain & tf_error) 4295 error ("initializer ends prematurely"); 4296 errors = true; 4297 } 4298 } 4299 4300 /* Now, default-initialize any remaining elements. We don't need to 4301 do that if a) the type does not need constructing, or b) we've 4302 already initialized all the elements. 4303 4304 We do need to keep going if we're copying an array. */ 4305 4306 if (try_const && !init) 4307 /* With a constexpr default constructor, which we checked for when 4308 setting try_const above, default-initialization is equivalent to 4309 value-initialization, and build_value_init gives us something more 4310 friendly to maybe_constant_init. */ 4311 explicit_value_init_p = true; 4312 if (from_array 4313 || ((type_build_ctor_call (type) || init || explicit_value_init_p) 4314 && ! (tree_fits_shwi_p (maxindex) 4315 && (num_initialized_elts 4316 == tree_to_shwi (maxindex) + 1)))) 4317 { 4318 /* If the ITERATOR is lesser or equal to -1, then we don't have to loop; 4319 we've already initialized all the elements. */ 4320 tree for_stmt; 4321 tree elt_init; 4322 tree to; 4323 4324 for_stmt = begin_for_stmt (NULL_TREE, NULL_TREE); 4325 finish_init_stmt (for_stmt); 4326 finish_for_cond (build2 (GT_EXPR, boolean_type_node, iterator, 4327 build_int_cst (TREE_TYPE (iterator), -1)), 4328 for_stmt, false, 0); 4329 elt_init = cp_build_unary_op (PREDECREMENT_EXPR, iterator, false, 4330 complain); 4331 if (elt_init == error_mark_node) 4332 errors = true; 4333 finish_for_expr (elt_init, for_stmt); 4334 4335 to = build1 (INDIRECT_REF, type, base); 4336 4337 /* If the initializer is {}, then all elements are initialized from T{}. 4338 But for non-classes, that's the same as value-initialization. */ 4339 if (empty_list) 4340 { 4341 if (cxx_dialect >= cxx11 && AGGREGATE_TYPE_P (type)) 4342 { 4343 init = build_constructor (init_list_type_node, NULL); 4344 } 4345 else 4346 { 4347 init = NULL_TREE; 4348 explicit_value_init_p = true; 4349 } 4350 } 4351 4352 if (from_array) 4353 { 4354 tree from; 4355 4356 if (base2) 4357 { 4358 from = build1 (INDIRECT_REF, itype, base2); 4359 if (xvalue) 4360 from = move (from); 4361 if (direct_init) 4362 from = build_tree_list (NULL_TREE, from); 4363 } 4364 else 4365 from = NULL_TREE; 4366 4367 if (TREE_CODE (type) == ARRAY_TYPE) 4368 elt_init = build_vec_init (to, NULL_TREE, from, /*val_init*/false, 4369 from_array, complain); 4370 else if (from_array == 2) 4371 elt_init = cp_build_modify_expr (input_location, to, NOP_EXPR, 4372 from, complain); 4373 else if (type_build_ctor_call (type)) 4374 elt_init = build_aggr_init (to, from, 0, complain); 4375 else if (from) 4376 elt_init = cp_build_modify_expr (input_location, to, NOP_EXPR, from, 4377 complain); 4378 else 4379 gcc_unreachable (); 4380 } 4381 else if (TREE_CODE (type) == ARRAY_TYPE) 4382 { 4383 if (init && !BRACE_ENCLOSED_INITIALIZER_P (init)) 4384 { 4385 if ((complain & tf_error)) 4386 error_at (loc, "array must be initialized " 4387 "with a brace-enclosed initializer"); 4388 elt_init = error_mark_node; 4389 } 4390 else 4391 elt_init = build_vec_init (build1 (INDIRECT_REF, type, base), 4392 0, init, 4393 explicit_value_init_p, 4394 0, complain); 4395 } 4396 else if (explicit_value_init_p) 4397 { 4398 elt_init = build_value_init (type, complain); 4399 if (elt_init != error_mark_node) 4400 elt_init = build2 (INIT_EXPR, type, to, elt_init); 4401 } 4402 else 4403 { 4404 gcc_assert (type_build_ctor_call (type) || init); 4405 if (CLASS_TYPE_P (type)) 4406 elt_init = build_aggr_init (to, init, 0, complain); 4407 else 4408 { 4409 if (TREE_CODE (init) == TREE_LIST) 4410 init = build_x_compound_expr_from_list (init, ELK_INIT, 4411 complain); 4412 elt_init = (init == error_mark_node 4413 ? error_mark_node 4414 : build2 (INIT_EXPR, type, to, init)); 4415 } 4416 } 4417 4418 if (elt_init == error_mark_node) 4419 errors = true; 4420 4421 if (try_const) 4422 { 4423 /* FIXME refs to earlier elts */ 4424 tree e = maybe_constant_init (elt_init); 4425 if (reduced_constant_expression_p (e)) 4426 { 4427 if (initializer_zerop (e)) 4428 /* Don't fill the CONSTRUCTOR with zeros. */ 4429 e = NULL_TREE; 4430 if (do_static_init) 4431 elt_init = NULL_TREE; 4432 } 4433 else 4434 { 4435 saw_non_const = true; 4436 if (do_static_init) 4437 e = build_zero_init (TREE_TYPE (e), NULL_TREE, true); 4438 else 4439 e = NULL_TREE; 4440 } 4441 4442 if (e) 4443 { 4444 int max = tree_to_shwi (maxindex)+1; 4445 for (; num_initialized_elts < max; ++num_initialized_elts) 4446 { 4447 tree field = size_int (num_initialized_elts); 4448 CONSTRUCTOR_APPEND_ELT (const_vec, field, e); 4449 } 4450 } 4451 } 4452 4453 current_stmt_tree ()->stmts_are_full_exprs_p = 1; 4454 if (elt_init && !errors) 4455 finish_expr_stmt (elt_init); 4456 current_stmt_tree ()->stmts_are_full_exprs_p = 0; 4457 4458 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base, false, 4459 complain)); 4460 if (base2) 4461 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base2, false, 4462 complain)); 4463 4464 finish_for_stmt (for_stmt); 4465 } 4466 4467 /* Make sure to cleanup any partially constructed elements. */ 4468 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type) 4469 && from_array != 2) 4470 { 4471 tree e; 4472 tree m = cp_build_binary_op (input_location, 4473 MINUS_EXPR, maxindex, iterator, 4474 complain); 4475 4476 /* Flatten multi-dimensional array since build_vec_delete only 4477 expects one-dimensional array. */ 4478 if (TREE_CODE (type) == ARRAY_TYPE) 4479 m = cp_build_binary_op (input_location, 4480 MULT_EXPR, m, 4481 /* Avoid mixing signed and unsigned. */ 4482 convert (TREE_TYPE (m), 4483 array_type_nelts_total (type)), 4484 complain); 4485 4486 finish_cleanup_try_block (try_block); 4487 e = build_vec_delete_1 (rval, m, 4488 inner_elt_type, sfk_complete_destructor, 4489 /*use_global_delete=*/0, complain); 4490 if (e == error_mark_node) 4491 errors = true; 4492 finish_cleanup (e, try_block); 4493 } 4494 4495 /* The value of the array initialization is the array itself, RVAL 4496 is a pointer to the first element. */ 4497 finish_stmt_expr_expr (rval, stmt_expr); 4498 4499 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt); 4500 4501 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps; 4502 4503 if (errors) 4504 return error_mark_node; 4505 4506 if (try_const) 4507 { 4508 if (!saw_non_const) 4509 { 4510 tree const_init = build_constructor (atype, const_vec); 4511 return build2 (INIT_EXPR, atype, obase, const_init); 4512 } 4513 else if (do_static_init && !vec_safe_is_empty (const_vec)) 4514 DECL_INITIAL (obase) = build_constructor (atype, const_vec); 4515 else 4516 vec_free (const_vec); 4517 } 4518 4519 /* Now make the result have the correct type. */ 4520 if (TREE_CODE (atype) == ARRAY_TYPE) 4521 { 4522 atype = build_pointer_type (atype); 4523 stmt_expr = build1 (NOP_EXPR, atype, stmt_expr); 4524 stmt_expr = cp_build_fold_indirect_ref (stmt_expr); 4525 TREE_NO_WARNING (stmt_expr) = 1; 4526 } 4527 4528 return stmt_expr; 4529 } 4530 4531 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for 4532 build_delete. */ 4533 4534 static tree 4535 build_dtor_call (tree exp, special_function_kind dtor_kind, int flags, 4536 tsubst_flags_t complain) 4537 { 4538 tree name; 4539 tree fn; 4540 switch (dtor_kind) 4541 { 4542 case sfk_complete_destructor: 4543 name = complete_dtor_identifier; 4544 break; 4545 4546 case sfk_base_destructor: 4547 name = base_dtor_identifier; 4548 break; 4549 4550 case sfk_deleting_destructor: 4551 name = deleting_dtor_identifier; 4552 break; 4553 4554 default: 4555 gcc_unreachable (); 4556 } 4557 fn = lookup_fnfields (TREE_TYPE (exp), name, /*protect=*/2); 4558 return build_new_method_call (exp, fn, 4559 /*args=*/NULL, 4560 /*conversion_path=*/NULL_TREE, 4561 flags, 4562 /*fn_p=*/NULL, 4563 complain); 4564 } 4565 4566 /* Generate a call to a destructor. TYPE is the type to cast ADDR to. 4567 ADDR is an expression which yields the store to be destroyed. 4568 AUTO_DELETE is the name of the destructor to call, i.e., either 4569 sfk_complete_destructor, sfk_base_destructor, or 4570 sfk_deleting_destructor. 4571 4572 FLAGS is the logical disjunction of zero or more LOOKUP_ 4573 flags. See cp-tree.h for more info. */ 4574 4575 tree 4576 build_delete (tree otype, tree addr, special_function_kind auto_delete, 4577 int flags, int use_global_delete, tsubst_flags_t complain) 4578 { 4579 tree expr; 4580 4581 if (addr == error_mark_node) 4582 return error_mark_node; 4583 4584 tree type = TYPE_MAIN_VARIANT (otype); 4585 4586 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type 4587 set to `error_mark_node' before it gets properly cleaned up. */ 4588 if (type == error_mark_node) 4589 return error_mark_node; 4590 4591 if (TREE_CODE (type) == POINTER_TYPE) 4592 type = TYPE_MAIN_VARIANT (TREE_TYPE (type)); 4593 4594 if (TREE_CODE (type) == ARRAY_TYPE) 4595 { 4596 if (TYPE_DOMAIN (type) == NULL_TREE) 4597 { 4598 if (complain & tf_error) 4599 error ("unknown array size in delete"); 4600 return error_mark_node; 4601 } 4602 return build_vec_delete (addr, array_type_nelts (type), 4603 auto_delete, use_global_delete, complain); 4604 } 4605 4606 if (TYPE_PTR_P (otype)) 4607 { 4608 addr = mark_rvalue_use (addr); 4609 4610 /* We don't want to warn about delete of void*, only other 4611 incomplete types. Deleting other incomplete types 4612 invokes undefined behavior, but it is not ill-formed, so 4613 compile to something that would even do The Right Thing 4614 (TM) should the type have a trivial dtor and no delete 4615 operator. */ 4616 if (!VOID_TYPE_P (type)) 4617 { 4618 complete_type (type); 4619 if (!COMPLETE_TYPE_P (type)) 4620 { 4621 if ((complain & tf_warning) 4622 && warning (OPT_Wdelete_incomplete, 4623 "possible problem detected in invocation of " 4624 "delete operator:")) 4625 { 4626 cxx_incomplete_type_diagnostic (addr, type, DK_WARNING); 4627 inform (input_location, 4628 "neither the destructor nor the class-specific " 4629 "operator delete will be called, even if they are " 4630 "declared when the class is defined"); 4631 } 4632 } 4633 else if (auto_delete == sfk_deleting_destructor && warn_delnonvdtor 4634 && MAYBE_CLASS_TYPE_P (type) && !CLASSTYPE_FINAL (type) 4635 && TYPE_POLYMORPHIC_P (type)) 4636 { 4637 tree dtor = CLASSTYPE_DESTRUCTOR (type); 4638 if (!dtor || !DECL_VINDEX (dtor)) 4639 { 4640 if (CLASSTYPE_PURE_VIRTUALS (type)) 4641 warning (OPT_Wdelete_non_virtual_dtor, 4642 "deleting object of abstract class type %qT" 4643 " which has non-virtual destructor" 4644 " will cause undefined behavior", type); 4645 else 4646 warning (OPT_Wdelete_non_virtual_dtor, 4647 "deleting object of polymorphic class type %qT" 4648 " which has non-virtual destructor" 4649 " might cause undefined behavior", type); 4650 } 4651 } 4652 } 4653 if (TREE_SIDE_EFFECTS (addr)) 4654 addr = save_expr (addr); 4655 4656 /* Throw away const and volatile on target type of addr. */ 4657 addr = convert_force (build_pointer_type (type), addr, 0, complain); 4658 } 4659 else 4660 { 4661 /* Don't check PROTECT here; leave that decision to the 4662 destructor. If the destructor is accessible, call it, 4663 else report error. */ 4664 addr = cp_build_addr_expr (addr, complain); 4665 if (addr == error_mark_node) 4666 return error_mark_node; 4667 if (TREE_SIDE_EFFECTS (addr)) 4668 addr = save_expr (addr); 4669 4670 addr = convert_force (build_pointer_type (type), addr, 0, complain); 4671 } 4672 4673 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type)) 4674 { 4675 /* Make sure the destructor is callable. */ 4676 if (type_build_dtor_call (type)) 4677 { 4678 expr = build_dtor_call (cp_build_fold_indirect_ref (addr), 4679 sfk_complete_destructor, flags, complain); 4680 if (expr == error_mark_node) 4681 return error_mark_node; 4682 } 4683 4684 if (auto_delete != sfk_deleting_destructor) 4685 return void_node; 4686 4687 return build_op_delete_call (DELETE_EXPR, addr, 4688 cxx_sizeof_nowarn (type), 4689 use_global_delete, 4690 /*placement=*/NULL_TREE, 4691 /*alloc_fn=*/NULL_TREE, 4692 complain); 4693 } 4694 else 4695 { 4696 tree head = NULL_TREE; 4697 tree do_delete = NULL_TREE; 4698 tree ifexp; 4699 4700 if (CLASSTYPE_LAZY_DESTRUCTOR (type)) 4701 lazily_declare_fn (sfk_destructor, type); 4702 4703 /* For `::delete x', we must not use the deleting destructor 4704 since then we would not be sure to get the global `operator 4705 delete'. */ 4706 if (use_global_delete && auto_delete == sfk_deleting_destructor) 4707 { 4708 /* We will use ADDR multiple times so we must save it. */ 4709 addr = save_expr (addr); 4710 head = get_target_expr (build_headof (addr)); 4711 /* Delete the object. */ 4712 do_delete = build_op_delete_call (DELETE_EXPR, 4713 head, 4714 cxx_sizeof_nowarn (type), 4715 /*global_p=*/true, 4716 /*placement=*/NULL_TREE, 4717 /*alloc_fn=*/NULL_TREE, 4718 complain); 4719 /* Otherwise, treat this like a complete object destructor 4720 call. */ 4721 auto_delete = sfk_complete_destructor; 4722 } 4723 /* If the destructor is non-virtual, there is no deleting 4724 variant. Instead, we must explicitly call the appropriate 4725 `operator delete' here. */ 4726 else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTOR (type)) 4727 && auto_delete == sfk_deleting_destructor) 4728 { 4729 /* We will use ADDR multiple times so we must save it. */ 4730 addr = save_expr (addr); 4731 /* Build the call. */ 4732 do_delete = build_op_delete_call (DELETE_EXPR, 4733 addr, 4734 cxx_sizeof_nowarn (type), 4735 /*global_p=*/false, 4736 /*placement=*/NULL_TREE, 4737 /*alloc_fn=*/NULL_TREE, 4738 complain); 4739 /* Call the complete object destructor. */ 4740 auto_delete = sfk_complete_destructor; 4741 } 4742 else if (auto_delete == sfk_deleting_destructor 4743 && TYPE_GETS_REG_DELETE (type)) 4744 { 4745 /* Make sure we have access to the member op delete, even though 4746 we'll actually be calling it from the destructor. */ 4747 build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type), 4748 /*global_p=*/false, 4749 /*placement=*/NULL_TREE, 4750 /*alloc_fn=*/NULL_TREE, 4751 complain); 4752 } 4753 4754 expr = build_dtor_call (cp_build_fold_indirect_ref (addr), 4755 auto_delete, flags, complain); 4756 if (expr == error_mark_node) 4757 return error_mark_node; 4758 if (do_delete) 4759 /* The delete operator must be called, regardless of whether 4760 the destructor throws. 4761 4762 [expr.delete]/7 The deallocation function is called 4763 regardless of whether the destructor for the object or some 4764 element of the array throws an exception. */ 4765 expr = build2 (TRY_FINALLY_EXPR, void_type_node, expr, do_delete); 4766 4767 /* We need to calculate this before the dtor changes the vptr. */ 4768 if (head) 4769 expr = build2 (COMPOUND_EXPR, void_type_node, head, expr); 4770 4771 if (flags & LOOKUP_DESTRUCTOR) 4772 /* Explicit destructor call; don't check for null pointer. */ 4773 ifexp = integer_one_node; 4774 else 4775 { 4776 /* Handle deleting a null pointer. */ 4777 warning_sentinel s (warn_address); 4778 ifexp = cp_build_binary_op (input_location, NE_EXPR, addr, 4779 nullptr_node, complain); 4780 if (ifexp == error_mark_node) 4781 return error_mark_node; 4782 /* This is a compiler generated comparison, don't emit 4783 e.g. -Wnonnull-compare warning for it. */ 4784 else if (TREE_CODE (ifexp) == NE_EXPR) 4785 TREE_NO_WARNING (ifexp) = 1; 4786 } 4787 4788 if (ifexp != integer_one_node) 4789 expr = build3 (COND_EXPR, void_type_node, ifexp, expr, void_node); 4790 4791 return expr; 4792 } 4793 } 4794 4795 /* At the beginning of a destructor, push cleanups that will call the 4796 destructors for our base classes and members. 4797 4798 Called from begin_destructor_body. */ 4799 4800 void 4801 push_base_cleanups (void) 4802 { 4803 tree binfo, base_binfo; 4804 int i; 4805 tree member; 4806 tree expr; 4807 vec<tree, va_gc> *vbases; 4808 4809 /* Run destructors for all virtual baseclasses. */ 4810 if (!ABSTRACT_CLASS_TYPE_P (current_class_type) 4811 && CLASSTYPE_VBASECLASSES (current_class_type)) 4812 { 4813 tree cond = (condition_conversion 4814 (build2 (BIT_AND_EXPR, integer_type_node, 4815 current_in_charge_parm, 4816 integer_two_node))); 4817 4818 /* The CLASSTYPE_VBASECLASSES vector is in initialization 4819 order, which is also the right order for pushing cleanups. */ 4820 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0; 4821 vec_safe_iterate (vbases, i, &base_binfo); i++) 4822 { 4823 if (type_build_dtor_call (BINFO_TYPE (base_binfo))) 4824 { 4825 expr = build_special_member_call (current_class_ref, 4826 base_dtor_identifier, 4827 NULL, 4828 base_binfo, 4829 (LOOKUP_NORMAL 4830 | LOOKUP_NONVIRTUAL), 4831 tf_warning_or_error); 4832 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))) 4833 { 4834 expr = build3 (COND_EXPR, void_type_node, cond, 4835 expr, void_node); 4836 finish_decl_cleanup (NULL_TREE, expr); 4837 } 4838 } 4839 } 4840 } 4841 4842 /* Take care of the remaining baseclasses. */ 4843 for (binfo = TYPE_BINFO (current_class_type), i = 0; 4844 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) 4845 { 4846 if (BINFO_VIRTUAL_P (base_binfo) 4847 || !type_build_dtor_call (BINFO_TYPE (base_binfo))) 4848 continue; 4849 4850 expr = build_special_member_call (current_class_ref, 4851 base_dtor_identifier, 4852 NULL, base_binfo, 4853 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL, 4854 tf_warning_or_error); 4855 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))) 4856 finish_decl_cleanup (NULL_TREE, expr); 4857 } 4858 4859 /* Don't automatically destroy union members. */ 4860 if (TREE_CODE (current_class_type) == UNION_TYPE) 4861 return; 4862 4863 for (member = TYPE_FIELDS (current_class_type); member; 4864 member = DECL_CHAIN (member)) 4865 { 4866 tree this_type = TREE_TYPE (member); 4867 if (this_type == error_mark_node 4868 || TREE_CODE (member) != FIELD_DECL 4869 || DECL_ARTIFICIAL (member)) 4870 continue; 4871 if (ANON_AGGR_TYPE_P (this_type)) 4872 continue; 4873 if (type_build_dtor_call (this_type)) 4874 { 4875 tree this_member = (build_class_member_access_expr 4876 (current_class_ref, member, 4877 /*access_path=*/NULL_TREE, 4878 /*preserve_reference=*/false, 4879 tf_warning_or_error)); 4880 expr = build_delete (this_type, this_member, 4881 sfk_complete_destructor, 4882 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL, 4883 0, tf_warning_or_error); 4884 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (this_type)) 4885 finish_decl_cleanup (NULL_TREE, expr); 4886 } 4887 } 4888 } 4889 4890 /* Build a C++ vector delete expression. 4891 MAXINDEX is the number of elements to be deleted. 4892 ELT_SIZE is the nominal size of each element in the vector. 4893 BASE is the expression that should yield the store to be deleted. 4894 This function expands (or synthesizes) these calls itself. 4895 AUTO_DELETE_VEC says whether the container (vector) should be deallocated. 4896 4897 This also calls delete for virtual baseclasses of elements of the vector. 4898 4899 Update: MAXINDEX is no longer needed. The size can be extracted from the 4900 start of the vector for pointers, and from the type for arrays. We still 4901 use MAXINDEX for arrays because it happens to already have one of the 4902 values we'd have to extract. (We could use MAXINDEX with pointers to 4903 confirm the size, and trap if the numbers differ; not clear that it'd 4904 be worth bothering.) */ 4905 4906 tree 4907 build_vec_delete (tree base, tree maxindex, 4908 special_function_kind auto_delete_vec, 4909 int use_global_delete, tsubst_flags_t complain) 4910 { 4911 tree type; 4912 tree rval; 4913 tree base_init = NULL_TREE; 4914 4915 type = TREE_TYPE (base); 4916 4917 if (TYPE_PTR_P (type)) 4918 { 4919 /* Step back one from start of vector, and read dimension. */ 4920 tree cookie_addr; 4921 tree size_ptr_type = build_pointer_type (sizetype); 4922 4923 base = mark_rvalue_use (base); 4924 if (TREE_SIDE_EFFECTS (base)) 4925 { 4926 base_init = get_target_expr (base); 4927 base = TARGET_EXPR_SLOT (base_init); 4928 } 4929 type = strip_array_types (TREE_TYPE (type)); 4930 cookie_addr = fold_build1_loc (input_location, NEGATE_EXPR, 4931 sizetype, TYPE_SIZE_UNIT (sizetype)); 4932 cookie_addr = fold_build_pointer_plus (fold_convert (size_ptr_type, base), 4933 cookie_addr); 4934 maxindex = cp_build_fold_indirect_ref (cookie_addr); 4935 } 4936 else if (TREE_CODE (type) == ARRAY_TYPE) 4937 { 4938 /* Get the total number of things in the array, maxindex is a 4939 bad name. */ 4940 maxindex = array_type_nelts_total (type); 4941 type = strip_array_types (type); 4942 base = decay_conversion (base, complain); 4943 if (base == error_mark_node) 4944 return error_mark_node; 4945 if (TREE_SIDE_EFFECTS (base)) 4946 { 4947 base_init = get_target_expr (base); 4948 base = TARGET_EXPR_SLOT (base_init); 4949 } 4950 } 4951 else 4952 { 4953 if (base != error_mark_node && !(complain & tf_error)) 4954 error ("type to vector delete is neither pointer or array type"); 4955 return error_mark_node; 4956 } 4957 4958 rval = build_vec_delete_1 (base, maxindex, type, auto_delete_vec, 4959 use_global_delete, complain); 4960 if (base_init && rval != error_mark_node) 4961 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), base_init, rval); 4962 4963 return rval; 4964 } 4965 4966 #include "gt-cp-init.h" 4967