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