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