1 /* Handle initialization things in C++.
2 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
4 2011 Free Software Foundation, Inc.
5 Contributed by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 /* High-level class interface. */
27 #include "coretypes.h"
35 static bool begin_init_stmts (tree *, tree *);
36 static tree finish_init_stmts (bool, tree, tree);
37 static void construct_virtual_base (tree, tree);
38 static void expand_aggr_init_1 (tree, tree, tree, tree, int, tsubst_flags_t);
39 static void expand_default_init (tree, tree, tree, tree, int, tsubst_flags_t);
40 static void perform_member_init (tree, tree);
41 static tree build_builtin_delete_call (tree);
42 static int member_init_ok_or_else (tree, tree, tree);
43 static void expand_virtual_init (tree, tree);
44 static tree sort_mem_initializers (tree, tree);
45 static tree initializing_context (tree);
46 static void expand_cleanup_for_base (tree, tree);
47 static tree dfs_initialize_vtbl_ptrs (tree, void *);
48 static tree build_field_list (tree, tree, int *);
49 static tree build_vtbl_address (tree);
50 static int diagnose_uninitialized_cst_or_ref_member_1 (tree, tree, bool, bool);
52 /* We are about to generate some complex initialization code.
53 Conceptually, it is all a single expression. However, we may want
54 to include conditionals, loops, and other such statement-level
55 constructs. Therefore, we build the initialization code inside a
56 statement-expression. This function starts such an expression.
57 STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
58 pass them back to finish_init_stmts when the expression is
62 begin_init_stmts (tree *stmt_expr_p, tree *compound_stmt_p)
64 bool is_global = !building_stmt_list_p ();
66 *stmt_expr_p = begin_stmt_expr ();
67 *compound_stmt_p = begin_compound_stmt (BCS_NO_SCOPE);
72 /* Finish out the statement-expression begun by the previous call to
73 begin_init_stmts. Returns the statement-expression itself. */
76 finish_init_stmts (bool is_global, tree stmt_expr, tree compound_stmt)
78 finish_compound_stmt (compound_stmt);
80 stmt_expr = finish_stmt_expr (stmt_expr, true);
82 gcc_assert (!building_stmt_list_p () == is_global);
89 /* Called from initialize_vtbl_ptrs via dfs_walk. BINFO is the base
90 which we want to initialize the vtable pointer for, DATA is
91 TREE_LIST whose TREE_VALUE is the this ptr expression. */
94 dfs_initialize_vtbl_ptrs (tree binfo, void *data)
96 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
97 return dfs_skip_bases;
99 if (!BINFO_PRIMARY_P (binfo) || BINFO_VIRTUAL_P (binfo))
101 tree base_ptr = TREE_VALUE ((tree) data);
103 base_ptr = build_base_path (PLUS_EXPR, base_ptr, binfo, /*nonnull=*/1,
104 tf_warning_or_error);
106 expand_virtual_init (binfo, base_ptr);
112 /* Initialize all the vtable pointers in the object pointed to by
116 initialize_vtbl_ptrs (tree addr)
121 type = TREE_TYPE (TREE_TYPE (addr));
122 list = build_tree_list (type, addr);
124 /* Walk through the hierarchy, initializing the vptr in each base
125 class. We do these in pre-order because we can't find the virtual
126 bases for a class until we've initialized the vtbl for that
128 dfs_walk_once (TYPE_BINFO (type), dfs_initialize_vtbl_ptrs, NULL, list);
131 /* Return an expression for the zero-initialization of an object with
132 type T. This expression will either be a constant (in the case
133 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
134 aggregate), or NULL (in the case that T does not require
135 initialization). In either case, the value can be used as
136 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
137 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
138 is the number of elements in the array. If STATIC_STORAGE_P is
139 TRUE, initializers are only generated for entities for which
140 zero-initialization does not simply mean filling the storage with
141 zero bytes. FIELD_SIZE, if non-NULL, is the bit size of the field,
142 subfields with bit positions at or above that bit size shouldn't
146 build_zero_init_1 (tree type, tree nelts, bool static_storage_p,
149 tree init = NULL_TREE;
153 To zero-initialize an object of type T means:
155 -- if T is a scalar type, the storage is set to the value of zero
158 -- if T is a non-union class type, the storage for each nonstatic
159 data member and each base-class subobject is zero-initialized.
161 -- if T is a union type, the storage for its first data member is
164 -- if T is an array type, the storage for each element is
167 -- if T is a reference type, no initialization is performed. */
169 gcc_assert (nelts == NULL_TREE || TREE_CODE (nelts) == INTEGER_CST);
171 if (type == error_mark_node)
173 else if (static_storage_p && zero_init_p (type))
174 /* In order to save space, we do not explicitly build initializers
175 for items that do not need them. GCC's semantics are that
176 items with static storage duration that are not otherwise
177 initialized are initialized to zero. */
179 else if (TYPE_PTR_P (type) || TYPE_PTR_TO_MEMBER_P (type))
180 init = convert (type, nullptr_node);
181 else if (SCALAR_TYPE_P (type))
182 init = convert (type, integer_zero_node);
183 else if (CLASS_TYPE_P (type))
186 VEC(constructor_elt,gc) *v = NULL;
188 /* Iterate over the fields, building initializations. */
189 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
191 if (TREE_CODE (field) != FIELD_DECL)
194 /* Don't add virtual bases for base classes if they are beyond
195 the size of the current field, that means it is present
196 somewhere else in the object. */
199 tree bitpos = bit_position (field);
200 if (TREE_CODE (bitpos) == INTEGER_CST
201 && !tree_int_cst_lt (bitpos, field_size))
205 /* Note that for class types there will be FIELD_DECLs
206 corresponding to base classes as well. Thus, iterating
207 over TYPE_FIELDs will result in correct initialization of
208 all of the subobjects. */
209 if (!static_storage_p || !zero_init_p (TREE_TYPE (field)))
212 = (DECL_FIELD_IS_BASE (field)
214 && TREE_CODE (DECL_SIZE (field)) == INTEGER_CST)
215 ? DECL_SIZE (field) : NULL_TREE;
216 tree value = build_zero_init_1 (TREE_TYPE (field),
221 CONSTRUCTOR_APPEND_ELT(v, field, value);
224 /* For unions, only the first field is initialized. */
225 if (TREE_CODE (type) == UNION_TYPE)
229 /* Build a constructor to contain the initializations. */
230 init = build_constructor (type, v);
232 else if (TREE_CODE (type) == ARRAY_TYPE)
235 VEC(constructor_elt,gc) *v = NULL;
237 /* Iterate over the array elements, building initializations. */
239 max_index = fold_build2_loc (input_location,
240 MINUS_EXPR, TREE_TYPE (nelts),
241 nelts, integer_one_node);
243 max_index = array_type_nelts (type);
245 /* If we have an error_mark here, we should just return error mark
246 as we don't know the size of the array yet. */
247 if (max_index == error_mark_node)
248 return error_mark_node;
249 gcc_assert (TREE_CODE (max_index) == INTEGER_CST);
251 /* A zero-sized array, which is accepted as an extension, will
252 have an upper bound of -1. */
253 if (!tree_int_cst_equal (max_index, integer_minus_one_node))
257 v = VEC_alloc (constructor_elt, gc, 1);
258 ce = VEC_quick_push (constructor_elt, v, NULL);
260 /* If this is a one element array, we just use a regular init. */
261 if (tree_int_cst_equal (size_zero_node, max_index))
262 ce->index = size_zero_node;
264 ce->index = build2 (RANGE_EXPR, sizetype, size_zero_node,
267 ce->value = build_zero_init_1 (TREE_TYPE (type),
269 static_storage_p, NULL_TREE);
272 /* Build a constructor to contain the initializations. */
273 init = build_constructor (type, v);
275 else if (TREE_CODE (type) == VECTOR_TYPE)
276 init = build_zero_cst (type);
278 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
280 /* In all cases, the initializer is a constant. */
282 TREE_CONSTANT (init) = 1;
287 /* Return an expression for the zero-initialization of an object with
288 type T. This expression will either be a constant (in the case
289 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
290 aggregate), or NULL (in the case that T does not require
291 initialization). In either case, the value can be used as
292 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
293 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
294 is the number of elements in the array. If STATIC_STORAGE_P is
295 TRUE, initializers are only generated for entities for which
296 zero-initialization does not simply mean filling the storage with
300 build_zero_init (tree type, tree nelts, bool static_storage_p)
302 return build_zero_init_1 (type, nelts, static_storage_p, NULL_TREE);
305 /* Return a suitable initializer for value-initializing an object of type
306 TYPE, as described in [dcl.init]. */
309 build_value_init (tree type, tsubst_flags_t complain)
313 To value-initialize an object of type T means:
315 - if T is a class type (clause 9) with a user-provided constructor
316 (12.1), then the default constructor for T is called (and the
317 initialization is ill-formed if T has no accessible default
320 - if T is a non-union class type without a user-provided constructor,
321 then every non-static data member and base-class component of T is
322 value-initialized;92)
324 - if T is an array type, then each element is value-initialized;
326 - otherwise, the object is zero-initialized.
328 A program that calls for default-initialization or
329 value-initialization of an entity of reference type is ill-formed.
331 92) Value-initialization for such a class object may be implemented by
332 zero-initializing the object and then calling the default
335 /* The AGGR_INIT_EXPR tweaking below breaks in templates. */
336 gcc_assert (!processing_template_decl || SCALAR_TYPE_P (type));
338 if (CLASS_TYPE_P (type))
340 /* Instead of the above, only consider the user-providedness of the
341 default constructor itself so value-initializing a class with an
342 explicitly defaulted default constructor and another user-provided
343 constructor works properly (c++std-core-19883). */
344 if (type_has_user_provided_default_constructor (type)
345 || (!TYPE_HAS_DEFAULT_CONSTRUCTOR (type)
346 && type_has_user_provided_constructor (type)))
347 return build_aggr_init_expr
349 build_special_member_call (NULL_TREE, complete_ctor_identifier,
350 NULL, type, LOOKUP_NORMAL,
353 else if (TYPE_HAS_COMPLEX_DFLT (type))
355 /* This is a class that needs constructing, but doesn't have
356 a user-provided constructor. So we need to zero-initialize
357 the object and then call the implicitly defined ctor.
358 This will be handled in simplify_aggr_init_expr. */
359 tree ctor = build_special_member_call
360 (NULL_TREE, complete_ctor_identifier,
361 NULL, type, LOOKUP_NORMAL, complain);
362 if (ctor != error_mark_node)
364 ctor = build_aggr_init_expr (type, ctor, complain);
365 AGGR_INIT_ZERO_FIRST (ctor) = 1;
370 return build_value_init_noctor (type, complain);
373 /* Like build_value_init, but don't call the constructor for TYPE. Used
374 for base initializers. */
377 build_value_init_noctor (tree type, tsubst_flags_t complain)
379 /* FIXME the class and array cases should just use digest_init once it is
381 if (CLASS_TYPE_P (type))
383 gcc_assert (!TYPE_HAS_COMPLEX_DFLT (type));
385 if (TREE_CODE (type) != UNION_TYPE)
388 VEC(constructor_elt,gc) *v = NULL;
390 /* Iterate over the fields, building initializations. */
391 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
395 if (TREE_CODE (field) != FIELD_DECL)
398 ftype = TREE_TYPE (field);
400 /* We could skip vfields and fields of types with
401 user-defined constructors, but I think that won't improve
402 performance at all; it should be simpler in general just
403 to zero out the entire object than try to only zero the
404 bits that actually need it. */
406 /* Note that for class types there will be FIELD_DECLs
407 corresponding to base classes as well. Thus, iterating
408 over TYPE_FIELDs will result in correct initialization of
409 all of the subobjects. */
410 value = build_value_init (ftype, complain);
412 if (value == error_mark_node)
413 return error_mark_node;
416 CONSTRUCTOR_APPEND_ELT(v, field, value);
419 /* Build a constructor to contain the zero- initializations. */
420 return build_constructor (type, v);
423 else if (TREE_CODE (type) == ARRAY_TYPE)
425 VEC(constructor_elt,gc) *v = NULL;
427 /* Iterate over the array elements, building initializations. */
428 tree max_index = array_type_nelts (type);
430 /* If we have an error_mark here, we should just return error mark
431 as we don't know the size of the array yet. */
432 if (max_index == error_mark_node)
434 if (complain & tf_error)
435 error ("cannot value-initialize array of unknown bound %qT",
437 return error_mark_node;
439 gcc_assert (TREE_CODE (max_index) == INTEGER_CST);
441 /* A zero-sized array, which is accepted as an extension, will
442 have an upper bound of -1. */
443 if (!tree_int_cst_equal (max_index, integer_minus_one_node))
447 v = VEC_alloc (constructor_elt, gc, 1);
448 ce = VEC_quick_push (constructor_elt, v, NULL);
450 /* If this is a one element array, we just use a regular init. */
451 if (tree_int_cst_equal (size_zero_node, max_index))
452 ce->index = size_zero_node;
454 ce->index = build2 (RANGE_EXPR, sizetype, size_zero_node,
457 ce->value = build_value_init (TREE_TYPE (type), complain);
459 if (ce->value == error_mark_node)
460 return error_mark_node;
462 /* We shouldn't have gotten here for anything that would need
463 non-trivial initialization, and gimplify_init_ctor_preeval
464 would need to be fixed to allow it. */
465 gcc_assert (TREE_CODE (ce->value) != TARGET_EXPR
466 && TREE_CODE (ce->value) != AGGR_INIT_EXPR);
469 /* Build a constructor to contain the initializations. */
470 return build_constructor (type, v);
472 else if (TREE_CODE (type) == FUNCTION_TYPE)
474 if (complain & tf_error)
475 error ("value-initialization of function type %qT", type);
476 return error_mark_node;
478 else if (TREE_CODE (type) == REFERENCE_TYPE)
480 if (complain & tf_error)
481 error ("value-initialization of reference type %qT", type);
482 return error_mark_node;
485 return build_zero_init (type, NULL_TREE, /*static_storage_p=*/false);
488 /* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of
489 arguments. If TREE_LIST is void_type_node, an empty initializer
490 list was given; if NULL_TREE no initializer was given. */
493 perform_member_init (tree member, tree init)
496 tree type = TREE_TYPE (member);
498 /* Use the non-static data member initializer if there was no
499 mem-initializer for this field. */
500 if (init == NULL_TREE)
502 if (DECL_LANG_SPECIFIC (member) && DECL_TEMPLATE_INFO (member))
503 /* Do deferred instantiation of the NSDMI. */
504 init = (tsubst_copy_and_build
505 (DECL_INITIAL (DECL_TI_TEMPLATE (member)),
506 DECL_TI_ARGS (member),
507 tf_warning_or_error, member, /*function_p=*/false,
508 /*integral_constant_expression_p=*/false));
511 init = DECL_INITIAL (member);
512 /* Strip redundant TARGET_EXPR so we don't need to remap it, and
513 so the aggregate init code below will see a CONSTRUCTOR. */
514 if (init && TREE_CODE (init) == TARGET_EXPR
515 && !VOID_TYPE_P (TREE_TYPE (TARGET_EXPR_INITIAL (init))))
516 init = TARGET_EXPR_INITIAL (init);
517 init = break_out_target_exprs (init);
521 /* Effective C++ rule 12 requires that all data members be
523 if (warn_ecpp && init == NULL_TREE && TREE_CODE (type) != ARRAY_TYPE)
524 warning_at (DECL_SOURCE_LOCATION (current_function_decl), OPT_Weffc__,
525 "%qD should be initialized in the member initialization list",
528 /* Get an lvalue for the data member. */
529 decl = build_class_member_access_expr (current_class_ref, member,
530 /*access_path=*/NULL_TREE,
531 /*preserve_reference=*/true,
532 tf_warning_or_error);
533 if (decl == error_mark_node)
536 if (warn_init_self && init && TREE_CODE (init) == TREE_LIST
537 && TREE_CHAIN (init) == NULL_TREE)
539 tree val = TREE_VALUE (init);
540 if (TREE_CODE (val) == COMPONENT_REF && TREE_OPERAND (val, 1) == member
541 && TREE_OPERAND (val, 0) == current_class_ref)
542 warning_at (DECL_SOURCE_LOCATION (current_function_decl),
543 OPT_Wuninitialized, "%qD is initialized with itself",
547 if (init == void_type_node)
549 /* mem() means value-initialization. */
550 if (TREE_CODE (type) == ARRAY_TYPE)
552 init = build_vec_init_expr (type, init, tf_warning_or_error);
553 init = build2 (INIT_EXPR, type, decl, init);
554 finish_expr_stmt (init);
558 tree value = build_value_init (type, tf_warning_or_error);
559 if (value == error_mark_node)
561 init = build2 (INIT_EXPR, type, decl, value);
562 finish_expr_stmt (init);
565 /* Deal with this here, as we will get confused if we try to call the
566 assignment op for an anonymous union. This can happen in a
567 synthesized copy constructor. */
568 else if (ANON_AGGR_TYPE_P (type))
572 init = build2 (INIT_EXPR, type, decl, TREE_VALUE (init));
573 finish_expr_stmt (init);
577 && (TREE_CODE (type) == REFERENCE_TYPE
578 /* Pre-digested NSDMI. */
579 || (((TREE_CODE (init) == CONSTRUCTOR
580 && TREE_TYPE (init) == type)
581 /* { } mem-initializer. */
582 || (TREE_CODE (init) == TREE_LIST
583 && TREE_CODE (TREE_VALUE (init)) == CONSTRUCTOR
584 && CONSTRUCTOR_IS_DIRECT_INIT (TREE_VALUE (init))))
585 && (CP_AGGREGATE_TYPE_P (type)
586 || is_std_init_list (type)))))
588 /* With references and list-initialization, we need to deal with
589 extending temporary lifetimes. 12.2p5: "A temporary bound to a
590 reference member in a constructor’s ctor-initializer (12.6.2)
591 persists until the constructor exits." */
593 VEC(tree,gc) *cleanups = make_tree_vector ();
594 if (TREE_CODE (init) == TREE_LIST)
595 init = build_x_compound_expr_from_list (init, ELK_MEM_INIT,
596 tf_warning_or_error);
597 if (TREE_TYPE (init) != type)
598 init = digest_init (type, init, tf_warning_or_error);
599 if (init == error_mark_node)
601 /* Use 'this' as the decl, as it has the lifetime we want. */
602 init = extend_ref_init_temps (member, init, &cleanups);
603 if (TREE_CODE (type) == ARRAY_TYPE
604 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (type)))
605 init = build_vec_init_expr (type, init, tf_warning_or_error);
606 init = build2 (INIT_EXPR, type, decl, init);
607 finish_expr_stmt (init);
608 FOR_EACH_VEC_ELT (tree, cleanups, i, t)
609 push_cleanup (decl, t, false);
610 release_tree_vector (cleanups);
612 else if (type_build_ctor_call (type)
613 || (init && CLASS_TYPE_P (strip_array_types (type))))
615 if (TREE_CODE (type) == ARRAY_TYPE)
619 if (TREE_CHAIN (init))
620 init = error_mark_node;
622 init = TREE_VALUE (init);
623 if (BRACE_ENCLOSED_INITIALIZER_P (init))
624 init = digest_init (type, init, tf_warning_or_error);
626 if (init == NULL_TREE
627 || same_type_ignoring_top_level_qualifiers_p (type,
630 init = build_vec_init_expr (type, init, tf_warning_or_error);
631 init = build2 (INIT_EXPR, type, decl, init);
632 finish_expr_stmt (init);
635 error ("invalid initializer for array member %q#D", member);
639 int flags = LOOKUP_NORMAL;
640 if (DECL_DEFAULTED_FN (current_function_decl))
641 flags |= LOOKUP_DEFAULTED;
642 if (CP_TYPE_CONST_P (type)
644 && default_init_uninitialized_part (type))
645 /* TYPE_NEEDS_CONSTRUCTING can be set just because we have a
646 vtable; still give this diagnostic. */
647 permerror (DECL_SOURCE_LOCATION (current_function_decl),
648 "uninitialized member %qD with %<const%> type %qT",
650 finish_expr_stmt (build_aggr_init (decl, init, flags,
651 tf_warning_or_error));
656 if (init == NULL_TREE)
659 /* member traversal: note it leaves init NULL */
660 if (TREE_CODE (type) == REFERENCE_TYPE)
661 permerror (DECL_SOURCE_LOCATION (current_function_decl),
662 "uninitialized reference member %qD",
664 else if (CP_TYPE_CONST_P (type))
665 permerror (DECL_SOURCE_LOCATION (current_function_decl),
666 "uninitialized member %qD with %<const%> type %qT",
669 core_type = strip_array_types (type);
671 if (CLASS_TYPE_P (core_type)
672 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type)
673 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type)))
674 diagnose_uninitialized_cst_or_ref_member (core_type,
678 else if (TREE_CODE (init) == TREE_LIST)
679 /* There was an explicit member initialization. Do some work
681 init = build_x_compound_expr_from_list (init, ELK_MEM_INIT,
682 tf_warning_or_error);
685 finish_expr_stmt (cp_build_modify_expr (decl, INIT_EXPR, init,
686 tf_warning_or_error));
689 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
693 expr = build_class_member_access_expr (current_class_ref, member,
694 /*access_path=*/NULL_TREE,
695 /*preserve_reference=*/false,
696 tf_warning_or_error);
697 expr = build_delete (type, expr, sfk_complete_destructor,
698 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0,
699 tf_warning_or_error);
701 if (expr != error_mark_node)
702 finish_eh_cleanup (expr);
706 /* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
707 the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */
710 build_field_list (tree t, tree list, int *uses_unions_p)
714 /* Note whether or not T is a union. */
715 if (TREE_CODE (t) == UNION_TYPE)
718 for (fields = TYPE_FIELDS (t); fields; fields = DECL_CHAIN (fields))
722 /* Skip CONST_DECLs for enumeration constants and so forth. */
723 if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
726 fieldtype = TREE_TYPE (fields);
727 /* Keep track of whether or not any fields are unions. */
728 if (TREE_CODE (fieldtype) == UNION_TYPE)
731 /* For an anonymous struct or union, we must recursively
732 consider the fields of the anonymous type. They can be
733 directly initialized from the constructor. */
734 if (ANON_AGGR_TYPE_P (fieldtype))
736 /* Add this field itself. Synthesized copy constructors
737 initialize the entire aggregate. */
738 list = tree_cons (fields, NULL_TREE, list);
739 /* And now add the fields in the anonymous aggregate. */
740 list = build_field_list (fieldtype, list, uses_unions_p);
742 /* Add this field. */
743 else if (DECL_NAME (fields))
744 list = tree_cons (fields, NULL_TREE, list);
750 /* The MEM_INITS are a TREE_LIST. The TREE_PURPOSE of each list gives
751 a FIELD_DECL or BINFO in T that needs initialization. The
752 TREE_VALUE gives the initializer, or list of initializer arguments.
754 Return a TREE_LIST containing all of the initializations required
755 for T, in the order in which they should be performed. The output
756 list has the same format as the input. */
759 sort_mem_initializers (tree t, tree mem_inits)
762 tree base, binfo, base_binfo;
765 VEC(tree,gc) *vbases;
767 int uses_unions_p = 0;
769 /* Build up a list of initializations. The TREE_PURPOSE of entry
770 will be the subobject (a FIELD_DECL or BINFO) to initialize. The
771 TREE_VALUE will be the constructor arguments, or NULL if no
772 explicit initialization was provided. */
773 sorted_inits = NULL_TREE;
775 /* Process the virtual bases. */
776 for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
777 VEC_iterate (tree, vbases, i, base); i++)
778 sorted_inits = tree_cons (base, NULL_TREE, sorted_inits);
780 /* Process the direct bases. */
781 for (binfo = TYPE_BINFO (t), i = 0;
782 BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
783 if (!BINFO_VIRTUAL_P (base_binfo))
784 sorted_inits = tree_cons (base_binfo, NULL_TREE, sorted_inits);
786 /* Process the non-static data members. */
787 sorted_inits = build_field_list (t, sorted_inits, &uses_unions_p);
788 /* Reverse the entire list of initializations, so that they are in
789 the order that they will actually be performed. */
790 sorted_inits = nreverse (sorted_inits);
792 /* If the user presented the initializers in an order different from
793 that in which they will actually occur, we issue a warning. Keep
794 track of the next subobject which can be explicitly initialized
795 without issuing a warning. */
796 next_subobject = sorted_inits;
798 /* Go through the explicit initializers, filling in TREE_PURPOSE in
800 for (init = mem_inits; init; init = TREE_CHAIN (init))
805 subobject = TREE_PURPOSE (init);
807 /* If the explicit initializers are in sorted order, then
808 SUBOBJECT will be NEXT_SUBOBJECT, or something following
810 for (subobject_init = next_subobject;
812 subobject_init = TREE_CHAIN (subobject_init))
813 if (TREE_PURPOSE (subobject_init) == subobject)
816 /* Issue a warning if the explicit initializer order does not
817 match that which will actually occur.
818 ??? Are all these on the correct lines? */
819 if (warn_reorder && !subobject_init)
821 if (TREE_CODE (TREE_PURPOSE (next_subobject)) == FIELD_DECL)
822 warning (OPT_Wreorder, "%q+D will be initialized after",
823 TREE_PURPOSE (next_subobject));
825 warning (OPT_Wreorder, "base %qT will be initialized after",
826 TREE_PURPOSE (next_subobject));
827 if (TREE_CODE (subobject) == FIELD_DECL)
828 warning (OPT_Wreorder, " %q+#D", subobject);
830 warning (OPT_Wreorder, " base %qT", subobject);
831 warning_at (DECL_SOURCE_LOCATION (current_function_decl),
832 OPT_Wreorder, " when initialized here");
835 /* Look again, from the beginning of the list. */
838 subobject_init = sorted_inits;
839 while (TREE_PURPOSE (subobject_init) != subobject)
840 subobject_init = TREE_CHAIN (subobject_init);
843 /* It is invalid to initialize the same subobject more than
845 if (TREE_VALUE (subobject_init))
847 if (TREE_CODE (subobject) == FIELD_DECL)
848 error_at (DECL_SOURCE_LOCATION (current_function_decl),
849 "multiple initializations given for %qD",
852 error_at (DECL_SOURCE_LOCATION (current_function_decl),
853 "multiple initializations given for base %qT",
857 /* Record the initialization. */
858 TREE_VALUE (subobject_init) = TREE_VALUE (init);
859 next_subobject = subobject_init;
864 If a ctor-initializer specifies more than one mem-initializer for
865 multiple members of the same union (including members of
866 anonymous unions), the ctor-initializer is ill-formed.
868 Here we also splice out uninitialized union members. */
871 tree last_field = NULL_TREE;
873 for (p = &sorted_inits; *p; )
881 field = TREE_PURPOSE (init);
883 /* Skip base classes. */
884 if (TREE_CODE (field) != FIELD_DECL)
887 /* If this is an anonymous union with no explicit initializer,
889 if (!TREE_VALUE (init) && ANON_UNION_TYPE_P (TREE_TYPE (field)))
892 /* See if this field is a member of a union, or a member of a
893 structure contained in a union, etc. */
894 for (ctx = DECL_CONTEXT (field);
895 !same_type_p (ctx, t);
896 ctx = TYPE_CONTEXT (ctx))
897 if (TREE_CODE (ctx) == UNION_TYPE)
899 /* If this field is not a member of a union, skip it. */
900 if (TREE_CODE (ctx) != UNION_TYPE)
903 /* If this union member has no explicit initializer, splice
905 if (!TREE_VALUE (init))
908 /* It's only an error if we have two initializers for the same
916 /* See if LAST_FIELD and the field initialized by INIT are
917 members of the same union. If so, there's a problem,
918 unless they're actually members of the same structure
919 which is itself a member of a union. For example, given:
921 union { struct { int i; int j; }; };
923 initializing both `i' and `j' makes sense. */
924 ctx = DECL_CONTEXT (field);
930 last_ctx = DECL_CONTEXT (last_field);
933 if (same_type_p (last_ctx, ctx))
935 if (TREE_CODE (ctx) == UNION_TYPE)
936 error_at (DECL_SOURCE_LOCATION (current_function_decl),
937 "initializations for multiple members of %qT",
943 if (same_type_p (last_ctx, t))
946 last_ctx = TYPE_CONTEXT (last_ctx);
949 /* If we've reached the outermost class, then we're
951 if (same_type_p (ctx, t))
954 ctx = TYPE_CONTEXT (ctx);
961 p = &TREE_CHAIN (*p);
964 *p = TREE_CHAIN (*p);
972 /* Initialize all bases and members of CURRENT_CLASS_TYPE. MEM_INITS
973 is a TREE_LIST giving the explicit mem-initializer-list for the
974 constructor. The TREE_PURPOSE of each entry is a subobject (a
975 FIELD_DECL or a BINFO) of the CURRENT_CLASS_TYPE. The TREE_VALUE
976 is a TREE_LIST giving the arguments to the constructor or
977 void_type_node for an empty list of arguments. */
980 emit_mem_initializers (tree mem_inits)
982 int flags = LOOKUP_NORMAL;
984 /* We will already have issued an error message about the fact that
985 the type is incomplete. */
986 if (!COMPLETE_TYPE_P (current_class_type))
989 if (DECL_DEFAULTED_FN (current_function_decl))
990 flags |= LOOKUP_DEFAULTED;
992 /* Sort the mem-initializers into the order in which the
993 initializations should be performed. */
994 mem_inits = sort_mem_initializers (current_class_type, mem_inits);
996 in_base_initializer = 1;
998 /* Initialize base classes. */
1000 && TREE_CODE (TREE_PURPOSE (mem_inits)) != FIELD_DECL)
1002 tree subobject = TREE_PURPOSE (mem_inits);
1003 tree arguments = TREE_VALUE (mem_inits);
1005 if (arguments == NULL_TREE)
1007 /* If these initializations are taking place in a copy constructor,
1008 the base class should probably be explicitly initialized if there
1009 is a user-defined constructor in the base class (other than the
1010 default constructor, which will be called anyway). */
1012 && DECL_COPY_CONSTRUCTOR_P (current_function_decl)
1013 && type_has_user_nondefault_constructor (BINFO_TYPE (subobject)))
1014 warning_at (DECL_SOURCE_LOCATION (current_function_decl),
1015 OPT_Wextra, "base class %q#T should be explicitly "
1016 "initialized in the copy constructor",
1017 BINFO_TYPE (subobject));
1020 /* Initialize the base. */
1021 if (BINFO_VIRTUAL_P (subobject))
1022 construct_virtual_base (subobject, arguments);
1027 base_addr = build_base_path (PLUS_EXPR, current_class_ptr,
1028 subobject, 1, tf_warning_or_error);
1029 expand_aggr_init_1 (subobject, NULL_TREE,
1030 cp_build_indirect_ref (base_addr, RO_NULL,
1031 tf_warning_or_error),
1034 tf_warning_or_error);
1035 expand_cleanup_for_base (subobject, NULL_TREE);
1038 mem_inits = TREE_CHAIN (mem_inits);
1040 in_base_initializer = 0;
1042 /* Initialize the vptrs. */
1043 initialize_vtbl_ptrs (current_class_ptr);
1045 /* Initialize the data members. */
1048 perform_member_init (TREE_PURPOSE (mem_inits),
1049 TREE_VALUE (mem_inits));
1050 mem_inits = TREE_CHAIN (mem_inits);
1054 /* Returns the address of the vtable (i.e., the value that should be
1055 assigned to the vptr) for BINFO. */
1058 build_vtbl_address (tree binfo)
1060 tree binfo_for = binfo;
1063 if (BINFO_VPTR_INDEX (binfo) && BINFO_VIRTUAL_P (binfo))
1064 /* If this is a virtual primary base, then the vtable we want to store
1065 is that for the base this is being used as the primary base of. We
1066 can't simply skip the initialization, because we may be expanding the
1067 inits of a subobject constructor where the virtual base layout
1068 can be different. */
1069 while (BINFO_PRIMARY_P (binfo_for))
1070 binfo_for = BINFO_INHERITANCE_CHAIN (binfo_for);
1072 /* Figure out what vtable BINFO's vtable is based on, and mark it as
1074 vtbl = get_vtbl_decl_for_binfo (binfo_for);
1075 TREE_USED (vtbl) = 1;
1077 /* Now compute the address to use when initializing the vptr. */
1078 vtbl = unshare_expr (BINFO_VTABLE (binfo_for));
1079 if (TREE_CODE (vtbl) == VAR_DECL)
1080 vtbl = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (vtbl)), vtbl);
1085 /* This code sets up the virtual function tables appropriate for
1086 the pointer DECL. It is a one-ply initialization.
1088 BINFO is the exact type that DECL is supposed to be. In
1089 multiple inheritance, this might mean "C's A" if C : A, B. */
1092 expand_virtual_init (tree binfo, tree decl)
1094 tree vtbl, vtbl_ptr;
1097 /* Compute the initializer for vptr. */
1098 vtbl = build_vtbl_address (binfo);
1100 /* We may get this vptr from a VTT, if this is a subobject
1101 constructor or subobject destructor. */
1102 vtt_index = BINFO_VPTR_INDEX (binfo);
1108 /* Compute the value to use, when there's a VTT. */
1109 vtt_parm = current_vtt_parm;
1110 vtbl2 = fold_build_pointer_plus (vtt_parm, vtt_index);
1111 vtbl2 = cp_build_indirect_ref (vtbl2, RO_NULL, tf_warning_or_error);
1112 vtbl2 = convert (TREE_TYPE (vtbl), vtbl2);
1114 /* The actual initializer is the VTT value only in the subobject
1115 constructor. In maybe_clone_body we'll substitute NULL for
1116 the vtt_parm in the case of the non-subobject constructor. */
1117 vtbl = build3 (COND_EXPR,
1119 build2 (EQ_EXPR, boolean_type_node,
1120 current_in_charge_parm, integer_zero_node),
1125 /* Compute the location of the vtpr. */
1126 vtbl_ptr = build_vfield_ref (cp_build_indirect_ref (decl, RO_NULL,
1127 tf_warning_or_error),
1129 gcc_assert (vtbl_ptr != error_mark_node);
1131 /* Assign the vtable to the vptr. */
1132 vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl, 0);
1133 finish_expr_stmt (cp_build_modify_expr (vtbl_ptr, NOP_EXPR, vtbl,
1134 tf_warning_or_error));
1137 /* If an exception is thrown in a constructor, those base classes already
1138 constructed must be destroyed. This function creates the cleanup
1139 for BINFO, which has just been constructed. If FLAG is non-NULL,
1140 it is a DECL which is nonzero when this base needs to be
1144 expand_cleanup_for_base (tree binfo, tree flag)
1148 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo)))
1151 /* Call the destructor. */
1152 expr = build_special_member_call (current_class_ref,
1153 base_dtor_identifier,
1156 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
1157 tf_warning_or_error);
1159 expr = fold_build3_loc (input_location,
1160 COND_EXPR, void_type_node,
1161 c_common_truthvalue_conversion (input_location, flag),
1162 expr, integer_zero_node);
1164 finish_eh_cleanup (expr);
1167 /* Construct the virtual base-class VBASE passing the ARGUMENTS to its
1171 construct_virtual_base (tree vbase, tree arguments)
1177 /* If there are virtual base classes with destructors, we need to
1178 emit cleanups to destroy them if an exception is thrown during
1179 the construction process. These exception regions (i.e., the
1180 period during which the cleanups must occur) begin from the time
1181 the construction is complete to the end of the function. If we
1182 create a conditional block in which to initialize the
1183 base-classes, then the cleanup region for the virtual base begins
1184 inside a block, and ends outside of that block. This situation
1185 confuses the sjlj exception-handling code. Therefore, we do not
1186 create a single conditional block, but one for each
1187 initialization. (That way the cleanup regions always begin
1188 in the outer block.) We trust the back end to figure out
1189 that the FLAG will not change across initializations, and
1190 avoid doing multiple tests. */
1191 flag = DECL_CHAIN (DECL_ARGUMENTS (current_function_decl));
1192 inner_if_stmt = begin_if_stmt ();
1193 finish_if_stmt_cond (flag, inner_if_stmt);
1195 /* Compute the location of the virtual base. If we're
1196 constructing virtual bases, then we must be the most derived
1197 class. Therefore, we don't have to look up the virtual base;
1198 we already know where it is. */
1199 exp = convert_to_base_statically (current_class_ref, vbase);
1201 expand_aggr_init_1 (vbase, current_class_ref, exp, arguments,
1202 LOOKUP_COMPLAIN, tf_warning_or_error);
1203 finish_then_clause (inner_if_stmt);
1204 finish_if_stmt (inner_if_stmt);
1206 expand_cleanup_for_base (vbase, flag);
1209 /* Find the context in which this FIELD can be initialized. */
1212 initializing_context (tree field)
1214 tree t = DECL_CONTEXT (field);
1216 /* Anonymous union members can be initialized in the first enclosing
1217 non-anonymous union context. */
1218 while (t && ANON_AGGR_TYPE_P (t))
1219 t = TYPE_CONTEXT (t);
1223 /* Function to give error message if member initialization specification
1224 is erroneous. FIELD is the member we decided to initialize.
1225 TYPE is the type for which the initialization is being performed.
1226 FIELD must be a member of TYPE.
1228 MEMBER_NAME is the name of the member. */
1231 member_init_ok_or_else (tree field, tree type, tree member_name)
1233 if (field == error_mark_node)
1237 error ("class %qT does not have any field named %qD", type,
1241 if (TREE_CODE (field) == VAR_DECL)
1243 error ("%q#D is a static data member; it can only be "
1244 "initialized at its definition",
1248 if (TREE_CODE (field) != FIELD_DECL)
1250 error ("%q#D is not a non-static data member of %qT",
1254 if (initializing_context (field) != type)
1256 error ("class %qT does not have any field named %qD", type,
1264 /* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
1265 is a _TYPE node or TYPE_DECL which names a base for that type.
1266 Check the validity of NAME, and return either the base _TYPE, base
1267 binfo, or the FIELD_DECL of the member. If NAME is invalid, return
1268 NULL_TREE and issue a diagnostic.
1270 An old style unnamed direct single base construction is permitted,
1271 where NAME is NULL. */
1274 expand_member_init (tree name)
1279 if (!current_class_ref)
1284 /* This is an obsolete unnamed base class initializer. The
1285 parser will already have warned about its use. */
1286 switch (BINFO_N_BASE_BINFOS (TYPE_BINFO (current_class_type)))
1289 error ("unnamed initializer for %qT, which has no base classes",
1290 current_class_type);
1293 basetype = BINFO_TYPE
1294 (BINFO_BASE_BINFO (TYPE_BINFO (current_class_type), 0));
1297 error ("unnamed initializer for %qT, which uses multiple inheritance",
1298 current_class_type);
1302 else if (TYPE_P (name))
1304 basetype = TYPE_MAIN_VARIANT (name);
1305 name = TYPE_NAME (name);
1307 else if (TREE_CODE (name) == TYPE_DECL)
1308 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (name));
1310 basetype = NULL_TREE;
1319 if (current_template_parms)
1322 class_binfo = TYPE_BINFO (current_class_type);
1323 direct_binfo = NULL_TREE;
1324 virtual_binfo = NULL_TREE;
1326 /* Look for a direct base. */
1327 for (i = 0; BINFO_BASE_ITERATE (class_binfo, i, direct_binfo); ++i)
1328 if (SAME_BINFO_TYPE_P (BINFO_TYPE (direct_binfo), basetype))
1331 /* Look for a virtual base -- unless the direct base is itself
1333 if (!direct_binfo || !BINFO_VIRTUAL_P (direct_binfo))
1334 virtual_binfo = binfo_for_vbase (basetype, current_class_type);
1336 /* [class.base.init]
1338 If a mem-initializer-id is ambiguous because it designates
1339 both a direct non-virtual base class and an inherited virtual
1340 base class, the mem-initializer is ill-formed. */
1341 if (direct_binfo && virtual_binfo)
1343 error ("%qD is both a direct base and an indirect virtual base",
1348 if (!direct_binfo && !virtual_binfo)
1350 if (CLASSTYPE_VBASECLASSES (current_class_type))
1351 error ("type %qT is not a direct or virtual base of %qT",
1352 basetype, current_class_type);
1354 error ("type %qT is not a direct base of %qT",
1355 basetype, current_class_type);
1359 return direct_binfo ? direct_binfo : virtual_binfo;
1363 if (TREE_CODE (name) == IDENTIFIER_NODE)
1364 field = lookup_field (current_class_type, name, 1, false);
1368 if (member_init_ok_or_else (field, current_class_type, name))
1375 /* This is like `expand_member_init', only it stores one aggregate
1378 INIT comes in two flavors: it is either a value which
1379 is to be stored in EXP, or it is a parameter list
1380 to go to a constructor, which will operate on EXP.
1381 If INIT is not a parameter list for a constructor, then set
1382 LOOKUP_ONLYCONVERTING.
1383 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1384 the initializer, if FLAGS is 0, then it is the (init) form.
1385 If `init' is a CONSTRUCTOR, then we emit a warning message,
1386 explaining that such initializations are invalid.
1388 If INIT resolves to a CALL_EXPR which happens to return
1389 something of the type we are looking for, then we know
1390 that we can safely use that call to perform the
1393 The virtual function table pointer cannot be set up here, because
1394 we do not really know its type.
1396 This never calls operator=().
1398 When initializing, nothing is CONST.
1400 A default copy constructor may have to be used to perform the
1403 A constructor or a conversion operator may have to be used to
1404 perform the initialization, but not both, as it would be ambiguous. */
1407 build_aggr_init (tree exp, tree init, int flags, tsubst_flags_t complain)
1412 tree type = TREE_TYPE (exp);
1413 int was_const = TREE_READONLY (exp);
1414 int was_volatile = TREE_THIS_VOLATILE (exp);
1417 if (init == error_mark_node)
1418 return error_mark_node;
1420 TREE_READONLY (exp) = 0;
1421 TREE_THIS_VOLATILE (exp) = 0;
1423 if (init && TREE_CODE (init) != TREE_LIST
1424 && !(TREE_CODE (init) == TARGET_EXPR
1425 && TARGET_EXPR_DIRECT_INIT_P (init))
1426 && !(BRACE_ENCLOSED_INITIALIZER_P (init)
1427 && CONSTRUCTOR_IS_DIRECT_INIT (init)))
1428 flags |= LOOKUP_ONLYCONVERTING;
1430 if (TREE_CODE (type) == ARRAY_TYPE)
1434 /* An array may not be initialized use the parenthesized
1435 initialization form -- unless the initializer is "()". */
1436 if (init && TREE_CODE (init) == TREE_LIST)
1438 if (complain & tf_error)
1439 error ("bad array initializer");
1440 return error_mark_node;
1442 /* Must arrange to initialize each element of EXP
1443 from elements of INIT. */
1444 itype = init ? TREE_TYPE (init) : NULL_TREE;
1445 if (cv_qualified_p (type))
1446 TREE_TYPE (exp) = cv_unqualified (type);
1447 if (itype && cv_qualified_p (itype))
1448 TREE_TYPE (init) = cv_unqualified (itype);
1449 stmt_expr = build_vec_init (exp, NULL_TREE, init,
1450 /*explicit_value_init_p=*/false,
1451 itype && same_type_p (TREE_TYPE (init),
1454 TREE_READONLY (exp) = was_const;
1455 TREE_THIS_VOLATILE (exp) = was_volatile;
1456 TREE_TYPE (exp) = type;
1458 TREE_TYPE (init) = itype;
1462 if (TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == PARM_DECL)
1463 /* Just know that we've seen something for this node. */
1464 TREE_USED (exp) = 1;
1466 is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
1467 destroy_temps = stmts_are_full_exprs_p ();
1468 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
1469 expand_aggr_init_1 (TYPE_BINFO (type), exp, exp,
1470 init, LOOKUP_NORMAL|flags, complain);
1471 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
1472 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
1473 TREE_READONLY (exp) = was_const;
1474 TREE_THIS_VOLATILE (exp) = was_volatile;
1480 expand_default_init (tree binfo, tree true_exp, tree exp, tree init, int flags,
1481 tsubst_flags_t complain)
1483 tree type = TREE_TYPE (exp);
1486 /* It fails because there may not be a constructor which takes
1487 its own type as the first (or only parameter), but which does
1488 take other types via a conversion. So, if the thing initializing
1489 the expression is a unit element of type X, first try X(X&),
1490 followed by initialization by X. If neither of these work
1491 out, then look hard. */
1493 VEC(tree,gc) *parms;
1495 /* If we have direct-initialization from an initializer list, pull
1496 it out of the TREE_LIST so the code below can see it. */
1497 if (init && TREE_CODE (init) == TREE_LIST
1498 && BRACE_ENCLOSED_INITIALIZER_P (TREE_VALUE (init))
1499 && CONSTRUCTOR_IS_DIRECT_INIT (TREE_VALUE (init)))
1501 gcc_checking_assert ((flags & LOOKUP_ONLYCONVERTING) == 0
1502 && TREE_CHAIN (init) == NULL_TREE);
1503 init = TREE_VALUE (init);
1506 if (init && BRACE_ENCLOSED_INITIALIZER_P (init)
1507 && CP_AGGREGATE_TYPE_P (type))
1508 /* A brace-enclosed initializer for an aggregate. In C++0x this can
1509 happen for direct-initialization, too. */
1510 init = digest_init (type, init, complain);
1512 /* A CONSTRUCTOR of the target's type is a previously digested
1513 initializer, whether that happened just above or in
1514 cp_parser_late_parsing_nsdmi.
1516 A TARGET_EXPR with TARGET_EXPR_DIRECT_INIT_P or TARGET_EXPR_LIST_INIT_P
1517 set represents the whole initialization, so we shouldn't build up
1518 another ctor call. */
1520 && (TREE_CODE (init) == CONSTRUCTOR
1521 || (TREE_CODE (init) == TARGET_EXPR
1522 && (TARGET_EXPR_DIRECT_INIT_P (init)
1523 || TARGET_EXPR_LIST_INIT_P (init))))
1524 && same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (init), type))
1526 /* Early initialization via a TARGET_EXPR only works for
1527 complete objects. */
1528 gcc_assert (TREE_CODE (init) == CONSTRUCTOR || true_exp == exp);
1530 init = build2 (INIT_EXPR, TREE_TYPE (exp), exp, init);
1531 TREE_SIDE_EFFECTS (init) = 1;
1532 finish_expr_stmt (init);
1536 if (init && TREE_CODE (init) != TREE_LIST
1537 && (flags & LOOKUP_ONLYCONVERTING))
1539 /* Base subobjects should only get direct-initialization. */
1540 gcc_assert (true_exp == exp);
1542 if (flags & DIRECT_BIND)
1543 /* Do nothing. We hit this in two cases: Reference initialization,
1544 where we aren't initializing a real variable, so we don't want
1545 to run a new constructor; and catching an exception, where we
1546 have already built up the constructor call so we could wrap it
1547 in an exception region. */;
1549 init = ocp_convert (type, init, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
1551 if (TREE_CODE (init) == MUST_NOT_THROW_EXPR)
1552 /* We need to protect the initialization of a catch parm with a
1553 call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
1554 around the TARGET_EXPR for the copy constructor. See
1555 initialize_handler_parm. */
1557 TREE_OPERAND (init, 0) = build2 (INIT_EXPR, TREE_TYPE (exp), exp,
1558 TREE_OPERAND (init, 0));
1559 TREE_TYPE (init) = void_type_node;
1562 init = build2 (INIT_EXPR, TREE_TYPE (exp), exp, init);
1563 TREE_SIDE_EFFECTS (init) = 1;
1564 finish_expr_stmt (init);
1568 if (init == NULL_TREE)
1570 else if (TREE_CODE (init) == TREE_LIST && !TREE_TYPE (init))
1572 parms = make_tree_vector ();
1573 for (; init != NULL_TREE; init = TREE_CHAIN (init))
1574 VEC_safe_push (tree, gc, parms, TREE_VALUE (init));
1577 parms = make_tree_vector_single (init);
1579 if (true_exp == exp)
1580 ctor_name = complete_ctor_identifier;
1582 ctor_name = base_ctor_identifier;
1584 rval = build_special_member_call (exp, ctor_name, &parms, binfo, flags,
1588 release_tree_vector (parms);
1590 if (exp == true_exp && TREE_CODE (rval) == CALL_EXPR)
1592 tree fn = get_callee_fndecl (rval);
1593 if (fn && DECL_DECLARED_CONSTEXPR_P (fn))
1595 tree e = maybe_constant_init (rval);
1596 if (TREE_CONSTANT (e))
1597 rval = build2 (INIT_EXPR, type, exp, e);
1601 /* FIXME put back convert_to_void? */
1602 if (TREE_SIDE_EFFECTS (rval))
1603 finish_expr_stmt (rval);
1606 /* This function is responsible for initializing EXP with INIT
1609 BINFO is the binfo of the type for who we are performing the
1610 initialization. For example, if W is a virtual base class of A and B,
1612 If we are initializing B, then W must contain B's W vtable, whereas
1613 were we initializing C, W must contain C's W vtable.
1615 TRUE_EXP is nonzero if it is the true expression being initialized.
1616 In this case, it may be EXP, or may just contain EXP. The reason we
1617 need this is because if EXP is a base element of TRUE_EXP, we
1618 don't necessarily know by looking at EXP where its virtual
1619 baseclass fields should really be pointing. But we do know
1620 from TRUE_EXP. In constructors, we don't know anything about
1621 the value being initialized.
1623 FLAGS is just passed to `build_new_method_call'. See that function
1624 for its description. */
1627 expand_aggr_init_1 (tree binfo, tree true_exp, tree exp, tree init, int flags,
1628 tsubst_flags_t complain)
1630 tree type = TREE_TYPE (exp);
1632 gcc_assert (init != error_mark_node && type != error_mark_node);
1633 gcc_assert (building_stmt_list_p ());
1635 /* Use a function returning the desired type to initialize EXP for us.
1636 If the function is a constructor, and its first argument is
1637 NULL_TREE, know that it was meant for us--just slide exp on
1638 in and expand the constructor. Constructors now come
1641 if (init && TREE_CODE (exp) == VAR_DECL
1642 && COMPOUND_LITERAL_P (init))
1644 VEC(tree,gc)* cleanups = NULL;
1645 /* If store_init_value returns NULL_TREE, the INIT has been
1646 recorded as the DECL_INITIAL for EXP. That means there's
1647 nothing more we have to do. */
1648 init = store_init_value (exp, init, &cleanups, flags);
1650 finish_expr_stmt (init);
1651 gcc_assert (!cleanups);
1655 /* If an explicit -- but empty -- initializer list was present,
1656 that's value-initialization. */
1657 if (init == void_type_node)
1659 /* If no user-provided ctor, we need to zero out the object. */
1660 if (!type_has_user_provided_constructor (type))
1662 tree field_size = NULL_TREE;
1663 if (exp != true_exp && CLASSTYPE_AS_BASE (type) != type)
1664 /* Don't clobber already initialized virtual bases. */
1665 field_size = TYPE_SIZE (CLASSTYPE_AS_BASE (type));
1666 init = build_zero_init_1 (type, NULL_TREE, /*static_storage_p=*/false,
1668 init = build2 (INIT_EXPR, type, exp, init);
1669 finish_expr_stmt (init);
1672 /* If we don't need to mess with the constructor at all,
1674 if (! type_build_ctor_call (type))
1677 /* Otherwise fall through and call the constructor. */
1681 /* We know that expand_default_init can handle everything we want
1683 expand_default_init (binfo, true_exp, exp, init, flags, complain);
1686 /* Report an error if TYPE is not a user-defined, class type. If
1687 OR_ELSE is nonzero, give an error message. */
1690 is_class_type (tree type, int or_else)
1692 if (type == error_mark_node)
1695 if (! CLASS_TYPE_P (type))
1698 error ("%qT is not a class type", type);
1705 get_type_value (tree name)
1707 if (name == error_mark_node)
1710 if (IDENTIFIER_HAS_TYPE_VALUE (name))
1711 return IDENTIFIER_TYPE_VALUE (name);
1716 /* Build a reference to a member of an aggregate. This is not a C++
1717 `&', but really something which can have its address taken, and
1718 then act as a pointer to member, for example TYPE :: FIELD can have
1719 its address taken by saying & TYPE :: FIELD. ADDRESS_P is true if
1720 this expression is the operand of "&".
1722 @@ Prints out lousy diagnostics for operator <typename>
1725 @@ This function should be rewritten and placed in search.c. */
1728 build_offset_ref (tree type, tree member, bool address_p)
1731 tree basebinfo = NULL_TREE;
1733 /* class templates can come in as TEMPLATE_DECLs here. */
1734 if (TREE_CODE (member) == TEMPLATE_DECL)
1737 if (dependent_scope_p (type) || type_dependent_expression_p (member))
1738 return build_qualified_name (NULL_TREE, type, member,
1739 /*template_p=*/false);
1741 gcc_assert (TYPE_P (type));
1742 if (! is_class_type (type, 1))
1743 return error_mark_node;
1745 gcc_assert (DECL_P (member) || BASELINK_P (member));
1746 /* Callers should call mark_used before this point. */
1747 gcc_assert (!DECL_P (member) || TREE_USED (member));
1749 type = TYPE_MAIN_VARIANT (type);
1750 if (!COMPLETE_OR_OPEN_TYPE_P (complete_type (type)))
1752 error ("incomplete type %qT does not have member %qD", type, member);
1753 return error_mark_node;
1756 /* Entities other than non-static members need no further
1758 if (TREE_CODE (member) == TYPE_DECL)
1760 if (TREE_CODE (member) == VAR_DECL || TREE_CODE (member) == CONST_DECL)
1761 return convert_from_reference (member);
1763 if (TREE_CODE (member) == FIELD_DECL && DECL_C_BIT_FIELD (member))
1765 error ("invalid pointer to bit-field %qD", member);
1766 return error_mark_node;
1769 /* Set up BASEBINFO for member lookup. */
1770 decl = maybe_dummy_object (type, &basebinfo);
1772 /* A lot of this logic is now handled in lookup_member. */
1773 if (BASELINK_P (member))
1775 /* Go from the TREE_BASELINK to the member function info. */
1776 tree t = BASELINK_FUNCTIONS (member);
1778 if (TREE_CODE (t) != TEMPLATE_ID_EXPR && !really_overloaded_fn (t))
1780 /* Get rid of a potential OVERLOAD around it. */
1781 t = OVL_CURRENT (t);
1783 /* Unique functions are handled easily. */
1785 /* For non-static member of base class, we need a special rule
1786 for access checking [class.protected]:
1788 If the access is to form a pointer to member, the
1789 nested-name-specifier shall name the derived class
1790 (or any class derived from that class). */
1791 if (address_p && DECL_P (t)
1792 && DECL_NONSTATIC_MEMBER_P (t))
1793 perform_or_defer_access_check (TYPE_BINFO (type), t, t);
1795 perform_or_defer_access_check (basebinfo, t, t);
1797 if (DECL_STATIC_FUNCTION_P (t))
1802 TREE_TYPE (member) = unknown_type_node;
1804 else if (address_p && TREE_CODE (member) == FIELD_DECL)
1805 /* We need additional test besides the one in
1806 check_accessibility_of_qualified_id in case it is
1807 a pointer to non-static member. */
1808 perform_or_defer_access_check (TYPE_BINFO (type), member, member);
1812 /* If MEMBER is non-static, then the program has fallen afoul of
1815 An id-expression that denotes a nonstatic data member or
1816 nonstatic member function of a class can only be used:
1818 -- as part of a class member access (_expr.ref_) in which the
1819 object-expression refers to the member's class or a class
1820 derived from that class, or
1822 -- to form a pointer to member (_expr.unary.op_), or
1824 -- in the body of a nonstatic member function of that class or
1825 of a class derived from that class (_class.mfct.nonstatic_), or
1827 -- in a mem-initializer for a constructor for that class or for
1828 a class derived from that class (_class.base.init_). */
1829 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member))
1831 /* Build a representation of the qualified name suitable
1832 for use as the operand to "&" -- even though the "&" is
1833 not actually present. */
1834 member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1835 /* In Microsoft mode, treat a non-static member function as if
1836 it were a pointer-to-member. */
1837 if (flag_ms_extensions)
1839 PTRMEM_OK_P (member) = 1;
1840 return cp_build_addr_expr (member, tf_warning_or_error);
1842 error ("invalid use of non-static member function %qD",
1843 TREE_OPERAND (member, 1));
1844 return error_mark_node;
1846 else if (TREE_CODE (member) == FIELD_DECL)
1848 error ("invalid use of non-static data member %qD", member);
1849 return error_mark_node;
1854 member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1855 PTRMEM_OK_P (member) = 1;
1859 /* If DECL is a scalar enumeration constant or variable with a
1860 constant initializer, return the initializer (or, its initializers,
1861 recursively); otherwise, return DECL. If INTEGRAL_P, the
1862 initializer is only returned if DECL is an integral
1863 constant-expression. If RETURN_AGGREGATE_CST_OK_P, it is ok to
1864 return an aggregate constant. */
1867 constant_value_1 (tree decl, bool integral_p, bool return_aggregate_cst_ok_p)
1869 while (TREE_CODE (decl) == CONST_DECL
1871 ? decl_constant_var_p (decl)
1872 : (TREE_CODE (decl) == VAR_DECL
1873 && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl)))))
1876 /* If DECL is a static data member in a template
1877 specialization, we must instantiate it here. The
1878 initializer for the static data member is not processed
1879 until needed; we need it now. */
1881 mark_rvalue_use (decl);
1882 init = DECL_INITIAL (decl);
1883 if (init == error_mark_node)
1885 if (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl))
1886 /* Treat the error as a constant to avoid cascading errors on
1887 excessively recursive template instantiation (c++/9335). */
1892 /* Initializers in templates are generally expanded during
1893 instantiation, so before that for const int i(2)
1894 INIT is a TREE_LIST with the actual initializer as
1896 if (processing_template_decl
1898 && TREE_CODE (init) == TREE_LIST
1899 && TREE_CHAIN (init) == NULL_TREE)
1900 init = TREE_VALUE (init);
1902 || !TREE_TYPE (init)
1903 || !TREE_CONSTANT (init)
1904 || (!integral_p && !return_aggregate_cst_ok_p
1905 /* Unless RETURN_AGGREGATE_CST_OK_P is true, do not
1906 return an aggregate constant (of which string
1907 literals are a special case), as we do not want
1908 to make inadvertent copies of such entities, and
1909 we must be sure that their addresses are the
1911 && (TREE_CODE (init) == CONSTRUCTOR
1912 || TREE_CODE (init) == STRING_CST)))
1914 decl = unshare_expr (init);
1919 /* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by
1920 constant of integral or enumeration type, then return that value.
1921 These are those variables permitted in constant expressions by
1925 integral_constant_value (tree decl)
1927 return constant_value_1 (decl, /*integral_p=*/true,
1928 /*return_aggregate_cst_ok_p=*/false);
1931 /* A more relaxed version of integral_constant_value, used by the
1932 common C/C++ code. */
1935 decl_constant_value (tree decl)
1937 return constant_value_1 (decl, /*integral_p=*/processing_template_decl,
1938 /*return_aggregate_cst_ok_p=*/true);
1941 /* A version of integral_constant_value used by the C++ front end for
1942 optimization purposes. */
1945 decl_constant_value_safe (tree decl)
1947 return constant_value_1 (decl, /*integral_p=*/processing_template_decl,
1948 /*return_aggregate_cst_ok_p=*/false);
1951 /* Common subroutines of build_new and build_vec_delete. */
1953 /* Call the global __builtin_delete to delete ADDR. */
1956 build_builtin_delete_call (tree addr)
1958 mark_used (global_delete_fndecl);
1959 return build_call_n (global_delete_fndecl, 1, addr);
1962 /* Build and return a NEW_EXPR. If NELTS is non-NULL, TYPE[NELTS] is
1963 the type of the object being allocated; otherwise, it's just TYPE.
1964 INIT is the initializer, if any. USE_GLOBAL_NEW is true if the
1965 user explicitly wrote "::operator new". PLACEMENT, if non-NULL, is
1966 a vector of arguments to be provided as arguments to a placement
1967 new operator. This routine performs no semantic checks; it just
1968 creates and returns a NEW_EXPR. */
1971 build_raw_new_expr (VEC(tree,gc) *placement, tree type, tree nelts,
1972 VEC(tree,gc) *init, int use_global_new)
1977 /* If INIT is NULL, the we want to store NULL_TREE in the NEW_EXPR.
1978 If INIT is not NULL, then we want to store VOID_ZERO_NODE. This
1979 permits us to distinguish the case of a missing initializer "new
1980 int" from an empty initializer "new int()". */
1982 init_list = NULL_TREE;
1983 else if (VEC_empty (tree, init))
1984 init_list = void_zero_node;
1986 init_list = build_tree_list_vec (init);
1988 new_expr = build4 (NEW_EXPR, build_pointer_type (type),
1989 build_tree_list_vec (placement), type, nelts,
1991 NEW_EXPR_USE_GLOBAL (new_expr) = use_global_new;
1992 TREE_SIDE_EFFECTS (new_expr) = 1;
1997 /* Diagnose uninitialized const members or reference members of type
1998 TYPE. USING_NEW is used to disambiguate the diagnostic between a
1999 new expression without a new-initializer and a declaration. Returns
2003 diagnose_uninitialized_cst_or_ref_member_1 (tree type, tree origin,
2004 bool using_new, bool complain)
2007 int error_count = 0;
2009 if (type_has_user_provided_constructor (type))
2012 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
2016 if (TREE_CODE (field) != FIELD_DECL)
2019 field_type = strip_array_types (TREE_TYPE (field));
2021 if (type_has_user_provided_constructor (field_type))
2024 if (TREE_CODE (field_type) == REFERENCE_TYPE)
2030 error ("uninitialized reference member in %q#T "
2031 "using %<new%> without new-initializer", origin);
2033 error ("uninitialized reference member in %q#T", origin);
2034 inform (DECL_SOURCE_LOCATION (field),
2035 "%qD should be initialized", field);
2039 if (CP_TYPE_CONST_P (field_type))
2045 error ("uninitialized const member in %q#T "
2046 "using %<new%> without new-initializer", origin);
2048 error ("uninitialized const member in %q#T", origin);
2049 inform (DECL_SOURCE_LOCATION (field),
2050 "%qD should be initialized", field);
2054 if (CLASS_TYPE_P (field_type))
2056 += diagnose_uninitialized_cst_or_ref_member_1 (field_type, origin,
2057 using_new, complain);
2063 diagnose_uninitialized_cst_or_ref_member (tree type, bool using_new, bool complain)
2065 return diagnose_uninitialized_cst_or_ref_member_1 (type, type, using_new, complain);
2068 /* Generate code for a new-expression, including calling the "operator
2069 new" function, initializing the object, and, if an exception occurs
2070 during construction, cleaning up. The arguments are as for
2071 build_raw_new_expr. This may change PLACEMENT and INIT. */
2074 build_new_1 (VEC(tree,gc) **placement, tree type, tree nelts,
2075 VEC(tree,gc) **init, bool globally_qualified_p,
2076 tsubst_flags_t complain)
2079 /* True iff this is a call to "operator new[]" instead of just
2081 bool array_p = false;
2082 /* If ARRAY_P is true, the element type of the array. This is never
2083 an ARRAY_TYPE; for something like "new int[3][4]", the
2084 ELT_TYPE is "int". If ARRAY_P is false, this is the same type as
2087 /* The type of the new-expression. (This type is always a pointer
2090 tree non_const_pointer_type;
2091 tree outer_nelts = NULL_TREE;
2092 tree alloc_call, alloc_expr;
2093 /* The address returned by the call to "operator new". This node is
2094 a VAR_DECL and is therefore reusable. */
2097 tree cookie_expr, init_expr;
2098 int nothrow, check_new;
2099 int use_java_new = 0;
2100 /* If non-NULL, the number of extra bytes to allocate at the
2101 beginning of the storage allocated for an array-new expression in
2102 order to store the number of elements. */
2103 tree cookie_size = NULL_TREE;
2104 tree placement_first;
2105 tree placement_expr = NULL_TREE;
2106 /* True if the function we are calling is a placement allocation
2108 bool placement_allocation_fn_p;
2109 /* True if the storage must be initialized, either by a constructor
2110 or due to an explicit new-initializer. */
2111 bool is_initialized;
2112 /* The address of the thing allocated, not including any cookie. In
2113 particular, if an array cookie is in use, DATA_ADDR is the
2114 address of the first array element. This node is a VAR_DECL, and
2115 is therefore reusable. */
2117 tree init_preeval_expr = NULL_TREE;
2121 outer_nelts = nelts;
2124 else if (TREE_CODE (type) == ARRAY_TYPE)
2127 nelts = array_type_nelts_top (type);
2128 outer_nelts = nelts;
2129 type = TREE_TYPE (type);
2132 /* If our base type is an array, then make sure we know how many elements
2134 for (elt_type = type;
2135 TREE_CODE (elt_type) == ARRAY_TYPE;
2136 elt_type = TREE_TYPE (elt_type))
2137 nelts = cp_build_binary_op (input_location,
2139 array_type_nelts_top (elt_type),
2142 if (TREE_CODE (elt_type) == VOID_TYPE)
2144 if (complain & tf_error)
2145 error ("invalid type %<void%> for new");
2146 return error_mark_node;
2149 if (abstract_virtuals_error_sfinae (NULL_TREE, elt_type, complain))
2150 return error_mark_node;
2152 is_initialized = (type_build_ctor_call (elt_type) || *init != NULL);
2156 bool maybe_uninitialized_error = false;
2157 /* A program that calls for default-initialization [...] of an
2158 entity of reference type is ill-formed. */
2159 if (CLASSTYPE_REF_FIELDS_NEED_INIT (elt_type))
2160 maybe_uninitialized_error = true;
2162 /* A new-expression that creates an object of type T initializes
2163 that object as follows:
2164 - If the new-initializer is omitted:
2165 -- If T is a (possibly cv-qualified) non-POD class type
2166 (or array thereof), the object is default-initialized (8.5).
2168 -- Otherwise, the object created has indeterminate
2169 value. If T is a const-qualified type, or a (possibly
2170 cv-qualified) POD class type (or array thereof)
2171 containing (directly or indirectly) a member of
2172 const-qualified type, the program is ill-formed; */
2174 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (elt_type))
2175 maybe_uninitialized_error = true;
2177 if (maybe_uninitialized_error
2178 && diagnose_uninitialized_cst_or_ref_member (elt_type,
2180 complain & tf_error))
2181 return error_mark_node;
2184 if (CP_TYPE_CONST_P (elt_type) && *init == NULL
2185 && default_init_uninitialized_part (elt_type))
2187 if (complain & tf_error)
2188 error ("uninitialized const in %<new%> of %q#T", elt_type);
2189 return error_mark_node;
2192 size = size_in_bytes (elt_type);
2194 size = size_binop (MULT_EXPR, size, convert (sizetype, nelts));
2196 alloc_fn = NULL_TREE;
2198 /* If PLACEMENT is a single simple pointer type not passed by
2199 reference, prepare to capture it in a temporary variable. Do
2200 this now, since PLACEMENT will change in the calls below. */
2201 placement_first = NULL_TREE;
2202 if (VEC_length (tree, *placement) == 1
2203 && (TREE_CODE (TREE_TYPE (VEC_index (tree, *placement, 0)))
2205 placement_first = VEC_index (tree, *placement, 0);
2207 /* Allocate the object. */
2208 if (VEC_empty (tree, *placement) && TYPE_FOR_JAVA (elt_type))
2211 tree class_decl = build_java_class_ref (elt_type);
2212 static const char alloc_name[] = "_Jv_AllocObject";
2214 if (class_decl == error_mark_node)
2215 return error_mark_node;
2218 if (!get_global_value_if_present (get_identifier (alloc_name),
2221 if (complain & tf_error)
2222 error ("call to Java constructor with %qs undefined", alloc_name);
2223 return error_mark_node;
2225 else if (really_overloaded_fn (alloc_fn))
2227 if (complain & tf_error)
2228 error ("%qD should never be overloaded", alloc_fn);
2229 return error_mark_node;
2231 alloc_fn = OVL_CURRENT (alloc_fn);
2232 class_addr = build1 (ADDR_EXPR, jclass_node, class_decl);
2233 alloc_call = cp_build_function_call_nary (alloc_fn, complain,
2234 class_addr, NULL_TREE);
2236 else if (TYPE_FOR_JAVA (elt_type) && MAYBE_CLASS_TYPE_P (elt_type))
2238 error ("Java class %q#T object allocated using placement new", elt_type);
2239 return error_mark_node;
2246 fnname = ansi_opname (array_p ? VEC_NEW_EXPR : NEW_EXPR);
2248 if (!globally_qualified_p
2249 && CLASS_TYPE_P (elt_type)
2251 ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type)
2252 : TYPE_HAS_NEW_OPERATOR (elt_type)))
2254 /* Use a class-specific operator new. */
2255 /* If a cookie is required, add some extra space. */
2256 if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
2258 cookie_size = targetm.cxx.get_cookie_size (elt_type);
2259 size = size_binop (PLUS_EXPR, size, cookie_size);
2261 /* Create the argument list. */
2262 VEC_safe_insert (tree, gc, *placement, 0, size);
2263 /* Do name-lookup to find the appropriate operator. */
2264 fns = lookup_fnfields (elt_type, fnname, /*protect=*/2);
2265 if (fns == NULL_TREE)
2267 if (complain & tf_error)
2268 error ("no suitable %qD found in class %qT", fnname, elt_type);
2269 return error_mark_node;
2271 if (TREE_CODE (fns) == TREE_LIST)
2273 if (complain & tf_error)
2275 error ("request for member %qD is ambiguous", fnname);
2276 print_candidates (fns);
2278 return error_mark_node;
2280 alloc_call = build_new_method_call (build_dummy_object (elt_type),
2282 /*conversion_path=*/NULL_TREE,
2289 /* Use a global operator new. */
2290 /* See if a cookie might be required. */
2291 if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
2292 cookie_size = targetm.cxx.get_cookie_size (elt_type);
2294 cookie_size = NULL_TREE;
2296 alloc_call = build_operator_new_call (fnname, placement,
2297 &size, &cookie_size,
2302 if (alloc_call == error_mark_node)
2303 return error_mark_node;
2305 gcc_assert (alloc_fn != NULL_TREE);
2307 /* If we found a simple case of PLACEMENT_EXPR above, then copy it
2308 into a temporary variable. */
2309 if (!processing_template_decl
2310 && placement_first != NULL_TREE
2311 && TREE_CODE (alloc_call) == CALL_EXPR
2312 && call_expr_nargs (alloc_call) == 2
2313 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 0))) == INTEGER_TYPE
2314 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 1))) == POINTER_TYPE)
2316 tree placement_arg = CALL_EXPR_ARG (alloc_call, 1);
2318 if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (TREE_TYPE (placement_arg)))
2319 || VOID_TYPE_P (TREE_TYPE (TREE_TYPE (placement_arg))))
2321 placement_expr = get_target_expr (placement_first);
2322 CALL_EXPR_ARG (alloc_call, 1)
2323 = convert (TREE_TYPE (placement_arg), placement_expr);
2327 /* In the simple case, we can stop now. */
2328 pointer_type = build_pointer_type (type);
2329 if (!cookie_size && !is_initialized)
2330 return build_nop (pointer_type, alloc_call);
2332 /* Store the result of the allocation call in a variable so that we can
2333 use it more than once. */
2334 alloc_expr = get_target_expr (alloc_call);
2335 alloc_node = TARGET_EXPR_SLOT (alloc_expr);
2337 /* Strip any COMPOUND_EXPRs from ALLOC_CALL. */
2338 while (TREE_CODE (alloc_call) == COMPOUND_EXPR)
2339 alloc_call = TREE_OPERAND (alloc_call, 1);
2341 /* Now, check to see if this function is actually a placement
2342 allocation function. This can happen even when PLACEMENT is NULL
2343 because we might have something like:
2345 struct S { void* operator new (size_t, int i = 0); };
2347 A call to `new S' will get this allocation function, even though
2348 there is no explicit placement argument. If there is more than
2349 one argument, or there are variable arguments, then this is a
2350 placement allocation function. */
2351 placement_allocation_fn_p
2352 = (type_num_arguments (TREE_TYPE (alloc_fn)) > 1
2353 || varargs_function_p (alloc_fn));
2355 /* Preevaluate the placement args so that we don't reevaluate them for a
2356 placement delete. */
2357 if (placement_allocation_fn_p)
2360 stabilize_call (alloc_call, &inits);
2362 alloc_expr = build2 (COMPOUND_EXPR, TREE_TYPE (alloc_expr), inits,
2366 /* unless an allocation function is declared with an empty excep-
2367 tion-specification (_except.spec_), throw(), it indicates failure to
2368 allocate storage by throwing a bad_alloc exception (clause _except_,
2369 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2370 cation function is declared with an empty exception-specification,
2371 throw(), it returns null to indicate failure to allocate storage and a
2372 non-null pointer otherwise.
2374 So check for a null exception spec on the op new we just called. */
2376 nothrow = TYPE_NOTHROW_P (TREE_TYPE (alloc_fn));
2377 check_new = (flag_check_new || nothrow) && ! use_java_new;
2385 /* Adjust so we're pointing to the start of the object. */
2386 data_addr = fold_build_pointer_plus (alloc_node, cookie_size);
2388 /* Store the number of bytes allocated so that we can know how
2389 many elements to destroy later. We use the last sizeof
2390 (size_t) bytes to store the number of elements. */
2391 cookie_ptr = size_binop (MINUS_EXPR, cookie_size, size_in_bytes (sizetype));
2392 cookie_ptr = fold_build_pointer_plus_loc (input_location,
2393 alloc_node, cookie_ptr);
2394 size_ptr_type = build_pointer_type (sizetype);
2395 cookie_ptr = fold_convert (size_ptr_type, cookie_ptr);
2396 cookie = cp_build_indirect_ref (cookie_ptr, RO_NULL, complain);
2398 cookie_expr = build2 (MODIFY_EXPR, sizetype, cookie, nelts);
2400 if (targetm.cxx.cookie_has_size ())
2402 /* Also store the element size. */
2403 cookie_ptr = fold_build_pointer_plus (cookie_ptr,
2404 fold_build1_loc (input_location,
2405 NEGATE_EXPR, sizetype,
2406 size_in_bytes (sizetype)));
2408 cookie = cp_build_indirect_ref (cookie_ptr, RO_NULL, complain);
2409 cookie = build2 (MODIFY_EXPR, sizetype, cookie,
2410 size_in_bytes (elt_type));
2411 cookie_expr = build2 (COMPOUND_EXPR, TREE_TYPE (cookie_expr),
2412 cookie, cookie_expr);
2417 cookie_expr = NULL_TREE;
2418 data_addr = alloc_node;
2421 /* Now use a pointer to the type we've actually allocated. */
2423 /* But we want to operate on a non-const version to start with,
2424 since we'll be modifying the elements. */
2425 non_const_pointer_type = build_pointer_type
2426 (cp_build_qualified_type (type, cp_type_quals (type) & ~TYPE_QUAL_CONST));
2428 data_addr = fold_convert (non_const_pointer_type, data_addr);
2429 /* Any further uses of alloc_node will want this type, too. */
2430 alloc_node = fold_convert (non_const_pointer_type, alloc_node);
2432 /* Now initialize the allocated object. Note that we preevaluate the
2433 initialization expression, apart from the actual constructor call or
2434 assignment--we do this because we want to delay the allocation as long
2435 as possible in order to minimize the size of the exception region for
2436 placement delete. */
2440 bool explicit_value_init_p = false;
2442 if (*init != NULL && VEC_empty (tree, *init))
2445 explicit_value_init_p = true;
2448 if (processing_template_decl && explicit_value_init_p)
2450 /* build_value_init doesn't work in templates, and we don't need
2451 the initializer anyway since we're going to throw it away and
2452 rebuild it at instantiation time, so just build up a single
2453 constructor call to get any appropriate diagnostics. */
2454 init_expr = cp_build_indirect_ref (data_addr, RO_NULL, complain);
2455 if (type_build_ctor_call (elt_type))
2456 init_expr = build_special_member_call (init_expr,
2457 complete_ctor_identifier,
2461 stable = stabilize_init (init_expr, &init_preeval_expr);
2465 tree vecinit = NULL_TREE;
2466 if (*init && VEC_length (tree, *init) == 1
2467 && BRACE_ENCLOSED_INITIALIZER_P (VEC_index (tree, *init, 0))
2468 && CONSTRUCTOR_IS_DIRECT_INIT (VEC_index (tree, *init, 0)))
2470 vecinit = VEC_index (tree, *init, 0);
2471 if (CONSTRUCTOR_NELTS (vecinit) == 0)
2472 /* List-value-initialization, leave it alone. */;
2475 tree arraytype, domain;
2476 if (TREE_CONSTANT (nelts))
2477 domain = compute_array_index_type (NULL_TREE, nelts,
2482 if (CONSTRUCTOR_NELTS (vecinit) > 0)
2483 warning (0, "non-constant array size in new, unable "
2484 "to verify length of initializer-list");
2486 arraytype = build_cplus_array_type (type, domain);
2487 vecinit = digest_init (arraytype, vecinit, complain);
2492 if (complain & tf_error)
2493 permerror (input_location,
2494 "parenthesized initializer in array new");
2496 return error_mark_node;
2497 vecinit = build_tree_list_vec (*init);
2500 = build_vec_init (data_addr,
2501 cp_build_binary_op (input_location,
2502 MINUS_EXPR, outer_nelts,
2506 explicit_value_init_p,
2510 /* An array initialization is stable because the initialization
2511 of each element is a full-expression, so the temporaries don't
2517 init_expr = cp_build_indirect_ref (data_addr, RO_NULL, complain);
2519 if (type_build_ctor_call (type) && !explicit_value_init_p)
2521 init_expr = build_special_member_call (init_expr,
2522 complete_ctor_identifier,
2527 else if (explicit_value_init_p)
2529 /* Something like `new int()'. */
2530 tree val = build_value_init (type, complain);
2531 if (val == error_mark_node)
2532 return error_mark_node;
2533 init_expr = build2 (INIT_EXPR, type, init_expr, val);
2539 /* We are processing something like `new int (10)', which
2540 means allocate an int, and initialize it with 10. */
2542 ie = build_x_compound_expr_from_vec (*init, "new initializer");
2543 init_expr = cp_build_modify_expr (init_expr, INIT_EXPR, ie,
2546 stable = stabilize_init (init_expr, &init_preeval_expr);
2549 if (init_expr == error_mark_node)
2550 return error_mark_node;
2552 /* If any part of the object initialization terminates by throwing an
2553 exception and a suitable deallocation function can be found, the
2554 deallocation function is called to free the memory in which the
2555 object was being constructed, after which the exception continues
2556 to propagate in the context of the new-expression. If no
2557 unambiguous matching deallocation function can be found,
2558 propagating the exception does not cause the object's memory to be
2560 if (flag_exceptions && ! use_java_new)
2562 enum tree_code dcode = array_p ? VEC_DELETE_EXPR : DELETE_EXPR;
2565 /* The Standard is unclear here, but the right thing to do
2566 is to use the same method for finding deallocation
2567 functions that we use for finding allocation functions. */
2568 cleanup = (build_op_delete_call
2572 globally_qualified_p,
2573 placement_allocation_fn_p ? alloc_call : NULL_TREE,
2579 /* This is much simpler if we were able to preevaluate all of
2580 the arguments to the constructor call. */
2582 /* CLEANUP is compiler-generated, so no diagnostics. */
2583 TREE_NO_WARNING (cleanup) = true;
2584 init_expr = build2 (TRY_CATCH_EXPR, void_type_node,
2585 init_expr, cleanup);
2586 /* Likewise, this try-catch is compiler-generated. */
2587 TREE_NO_WARNING (init_expr) = true;
2590 /* Ack! First we allocate the memory. Then we set our sentry
2591 variable to true, and expand a cleanup that deletes the
2592 memory if sentry is true. Then we run the constructor, and
2593 finally clear the sentry.
2595 We need to do this because we allocate the space first, so
2596 if there are any temporaries with cleanups in the
2597 constructor args and we weren't able to preevaluate them, we
2598 need this EH region to extend until end of full-expression
2599 to preserve nesting. */
2601 tree end, sentry, begin;
2603 begin = get_target_expr (boolean_true_node);
2604 CLEANUP_EH_ONLY (begin) = 1;
2606 sentry = TARGET_EXPR_SLOT (begin);
2608 /* CLEANUP is compiler-generated, so no diagnostics. */
2609 TREE_NO_WARNING (cleanup) = true;
2611 TARGET_EXPR_CLEANUP (begin)
2612 = build3 (COND_EXPR, void_type_node, sentry,
2613 cleanup, void_zero_node);
2615 end = build2 (MODIFY_EXPR, TREE_TYPE (sentry),
2616 sentry, boolean_false_node);
2619 = build2 (COMPOUND_EXPR, void_type_node, begin,
2620 build2 (COMPOUND_EXPR, void_type_node, init_expr,
2622 /* Likewise, this is compiler-generated. */
2623 TREE_NO_WARNING (init_expr) = true;
2628 init_expr = NULL_TREE;
2630 /* Now build up the return value in reverse order. */
2635 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_expr, rval);
2637 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), cookie_expr, rval);
2639 if (rval == data_addr)
2640 /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
2641 and return the call (which doesn't need to be adjusted). */
2642 rval = TARGET_EXPR_INITIAL (alloc_expr);
2647 tree ifexp = cp_build_binary_op (input_location,
2648 NE_EXPR, alloc_node,
2651 rval = build_conditional_expr (ifexp, rval, alloc_node,
2655 /* Perform the allocation before anything else, so that ALLOC_NODE
2656 has been initialized before we start using it. */
2657 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
2660 if (init_preeval_expr)
2661 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_preeval_expr, rval);
2663 /* A new-expression is never an lvalue. */
2664 gcc_assert (!lvalue_p (rval));
2666 return convert (pointer_type, rval);
2669 /* Generate a representation for a C++ "new" expression. *PLACEMENT
2670 is a vector of placement-new arguments (or NULL if none). If NELTS
2671 is NULL, TYPE is the type of the storage to be allocated. If NELTS
2672 is not NULL, then this is an array-new allocation; TYPE is the type
2673 of the elements in the array and NELTS is the number of elements in
2674 the array. *INIT, if non-NULL, is the initializer for the new
2675 object, or an empty vector to indicate an initializer of "()". If
2676 USE_GLOBAL_NEW is true, then the user explicitly wrote "::new"
2677 rather than just "new". This may change PLACEMENT and INIT. */
2680 build_new (VEC(tree,gc) **placement, tree type, tree nelts,
2681 VEC(tree,gc) **init, int use_global_new, tsubst_flags_t complain)
2684 VEC(tree,gc) *orig_placement = NULL;
2685 tree orig_nelts = NULL_TREE;
2686 VEC(tree,gc) *orig_init = NULL;
2688 if (type == error_mark_node)
2689 return error_mark_node;
2691 if (nelts == NULL_TREE && VEC_length (tree, *init) == 1)
2693 tree auto_node = type_uses_auto (type);
2696 tree d_init = VEC_index (tree, *init, 0);
2697 d_init = resolve_nondeduced_context (d_init);
2698 type = do_auto_deduction (type, d_init, auto_node);
2702 if (processing_template_decl)
2704 if (dependent_type_p (type)
2705 || any_type_dependent_arguments_p (*placement)
2706 || (nelts && type_dependent_expression_p (nelts))
2707 || any_type_dependent_arguments_p (*init))
2708 return build_raw_new_expr (*placement, type, nelts, *init,
2711 orig_placement = make_tree_vector_copy (*placement);
2713 orig_init = make_tree_vector_copy (*init);
2715 make_args_non_dependent (*placement);
2717 nelts = build_non_dependent_expr (nelts);
2718 make_args_non_dependent (*init);
2723 if (!build_expr_type_conversion (WANT_INT | WANT_ENUM, nelts, false))
2725 if (complain & tf_error)
2726 permerror (input_location, "size in array new must have integral type");
2728 return error_mark_node;
2730 nelts = mark_rvalue_use (nelts);
2731 nelts = cp_save_expr (cp_convert (sizetype, nelts));
2734 /* ``A reference cannot be created by the new operator. A reference
2735 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2736 returned by new.'' ARM 5.3.3 */
2737 if (TREE_CODE (type) == REFERENCE_TYPE)
2739 if (complain & tf_error)
2740 error ("new cannot be applied to a reference type");
2742 return error_mark_node;
2743 type = TREE_TYPE (type);
2746 if (TREE_CODE (type) == FUNCTION_TYPE)
2748 if (complain & tf_error)
2749 error ("new cannot be applied to a function type");
2750 return error_mark_node;
2753 /* The type allocated must be complete. If the new-type-id was
2754 "T[N]" then we are just checking that "T" is complete here, but
2755 that is equivalent, since the value of "N" doesn't matter. */
2756 if (!complete_type_or_maybe_complain (type, NULL_TREE, complain))
2757 return error_mark_node;
2759 rval = build_new_1 (placement, type, nelts, init, use_global_new, complain);
2760 if (rval == error_mark_node)
2761 return error_mark_node;
2763 if (processing_template_decl)
2765 tree ret = build_raw_new_expr (orig_placement, type, orig_nelts,
2766 orig_init, use_global_new);
2767 release_tree_vector (orig_placement);
2768 release_tree_vector (orig_init);
2772 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
2773 rval = build1 (NOP_EXPR, TREE_TYPE (rval), rval);
2774 TREE_NO_WARNING (rval) = 1;
2779 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
2782 build_java_class_ref (tree type)
2784 tree name = NULL_TREE, class_decl;
2785 static tree CL_suffix = NULL_TREE;
2786 if (CL_suffix == NULL_TREE)
2787 CL_suffix = get_identifier("class$");
2788 if (jclass_node == NULL_TREE)
2790 jclass_node = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
2791 if (jclass_node == NULL_TREE)
2793 error ("call to Java constructor, while %<jclass%> undefined");
2794 return error_mark_node;
2796 jclass_node = TREE_TYPE (jclass_node);
2799 /* Mangle the class$ field. */
2802 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
2803 if (DECL_NAME (field) == CL_suffix)
2805 mangle_decl (field);
2806 name = DECL_ASSEMBLER_NAME (field);
2811 error ("can%'t find %<class$%> in %qT", type);
2812 return error_mark_node;
2816 class_decl = IDENTIFIER_GLOBAL_VALUE (name);
2817 if (class_decl == NULL_TREE)
2819 class_decl = build_decl (input_location,
2820 VAR_DECL, name, TREE_TYPE (jclass_node));
2821 TREE_STATIC (class_decl) = 1;
2822 DECL_EXTERNAL (class_decl) = 1;
2823 TREE_PUBLIC (class_decl) = 1;
2824 DECL_ARTIFICIAL (class_decl) = 1;
2825 DECL_IGNORED_P (class_decl) = 1;
2826 pushdecl_top_level (class_decl);
2827 make_decl_rtl (class_decl);
2833 build_vec_delete_1 (tree base, tree maxindex, tree type,
2834 special_function_kind auto_delete_vec,
2835 int use_global_delete, tsubst_flags_t complain)
2838 tree ptype = build_pointer_type (type = complete_type (type));
2839 tree size_exp = size_in_bytes (type);
2841 /* Temporary variables used by the loop. */
2842 tree tbase, tbase_init;
2844 /* This is the body of the loop that implements the deletion of a
2845 single element, and moves temp variables to next elements. */
2848 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2851 /* This is the thing that governs what to do after the loop has run. */
2852 tree deallocate_expr = 0;
2854 /* This is the BIND_EXPR which holds the outermost iterator of the
2855 loop. It is convenient to set this variable up and test it before
2856 executing any other code in the loop.
2857 This is also the containing expression returned by this function. */
2858 tree controller = NULL_TREE;
2861 /* We should only have 1-D arrays here. */
2862 gcc_assert (TREE_CODE (type) != ARRAY_TYPE);
2864 if (base == error_mark_node || maxindex == error_mark_node)
2865 return error_mark_node;
2867 if (! MAYBE_CLASS_TYPE_P (type) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2870 /* The below is short by the cookie size. */
2871 virtual_size = size_binop (MULT_EXPR, size_exp,
2872 convert (sizetype, maxindex));
2874 tbase = create_temporary_var (ptype);
2876 = cp_build_modify_expr (tbase, NOP_EXPR,
2877 fold_build_pointer_plus_loc (input_location,
2878 fold_convert (ptype,
2882 if (tbase_init == error_mark_node)
2883 return error_mark_node;
2884 controller = build3 (BIND_EXPR, void_type_node, tbase,
2885 NULL_TREE, NULL_TREE);
2886 TREE_SIDE_EFFECTS (controller) = 1;
2888 body = build1 (EXIT_EXPR, void_type_node,
2889 build2 (EQ_EXPR, boolean_type_node, tbase,
2890 fold_convert (ptype, base)));
2891 tmp = fold_build1_loc (input_location, NEGATE_EXPR, sizetype, size_exp);
2892 tmp = fold_build_pointer_plus (tbase, tmp);
2893 tmp = cp_build_modify_expr (tbase, NOP_EXPR, tmp, complain);
2894 if (tmp == error_mark_node)
2895 return error_mark_node;
2896 body = build_compound_expr (input_location, body, tmp);
2897 tmp = build_delete (ptype, tbase, sfk_complete_destructor,
2898 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1,
2900 if (tmp == error_mark_node)
2901 return error_mark_node;
2902 body = build_compound_expr (input_location, body, tmp);
2904 loop = build1 (LOOP_EXPR, void_type_node, body);
2905 loop = build_compound_expr (input_location, tbase_init, loop);
2908 /* Delete the storage if appropriate. */
2909 if (auto_delete_vec == sfk_deleting_destructor)
2913 /* The below is short by the cookie size. */
2914 virtual_size = size_binop (MULT_EXPR, size_exp,
2915 convert (sizetype, maxindex));
2917 if (! TYPE_VEC_NEW_USES_COOKIE (type))
2924 cookie_size = targetm.cxx.get_cookie_size (type);
2925 base_tbd = cp_build_binary_op (input_location,
2927 cp_convert (string_type_node,
2931 if (base_tbd == error_mark_node)
2932 return error_mark_node;
2933 base_tbd = cp_convert (ptype, base_tbd);
2934 /* True size with header. */
2935 virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size);
2938 deallocate_expr = build_op_delete_call (VEC_DELETE_EXPR,
2939 base_tbd, virtual_size,
2940 use_global_delete & 1,
2941 /*placement=*/NULL_TREE,
2942 /*alloc_fn=*/NULL_TREE);
2946 if (!deallocate_expr)
2949 body = deallocate_expr;
2951 body = build_compound_expr (input_location, body, deallocate_expr);
2954 body = integer_zero_node;
2956 /* Outermost wrapper: If pointer is null, punt. */
2957 body = fold_build3_loc (input_location, COND_EXPR, void_type_node,
2958 fold_build2_loc (input_location,
2959 NE_EXPR, boolean_type_node, base,
2960 convert (TREE_TYPE (base),
2962 body, integer_zero_node);
2963 body = build1 (NOP_EXPR, void_type_node, body);
2967 TREE_OPERAND (controller, 1) = body;
2971 if (TREE_CODE (base) == SAVE_EXPR)
2972 /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */
2973 body = build2 (COMPOUND_EXPR, void_type_node, base, body);
2975 return convert_to_void (body, ICV_CAST, complain);
2978 /* Create an unnamed variable of the indicated TYPE. */
2981 create_temporary_var (tree type)
2985 decl = build_decl (input_location,
2986 VAR_DECL, NULL_TREE, type);
2987 TREE_USED (decl) = 1;
2988 DECL_ARTIFICIAL (decl) = 1;
2989 DECL_IGNORED_P (decl) = 1;
2990 DECL_CONTEXT (decl) = current_function_decl;
2995 /* Create a new temporary variable of the indicated TYPE, initialized
2998 It is not entered into current_binding_level, because that breaks
2999 things when it comes time to do final cleanups (which take place
3000 "outside" the binding contour of the function). */
3003 get_temp_regvar (tree type, tree init)
3007 decl = create_temporary_var (type);
3008 add_decl_expr (decl);
3010 finish_expr_stmt (cp_build_modify_expr (decl, INIT_EXPR, init,
3011 tf_warning_or_error));
3016 /* `build_vec_init' returns tree structure that performs
3017 initialization of a vector of aggregate types.
3019 BASE is a reference to the vector, of ARRAY_TYPE, or a pointer
3020 to the first element, of POINTER_TYPE.
3021 MAXINDEX is the maximum index of the array (one less than the
3022 number of elements). It is only used if BASE is a pointer or
3023 TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
3025 INIT is the (possibly NULL) initializer.
3027 If EXPLICIT_VALUE_INIT_P is true, then INIT must be NULL. All
3028 elements in the array are value-initialized.
3030 FROM_ARRAY is 0 if we should init everything with INIT
3031 (i.e., every element initialized from INIT).
3032 FROM_ARRAY is 1 if we should index into INIT in parallel
3033 with initialization of DECL.
3034 FROM_ARRAY is 2 if we should index into INIT in parallel,
3035 but use assignment instead of initialization. */
3038 build_vec_init (tree base, tree maxindex, tree init,
3039 bool explicit_value_init_p,
3040 int from_array, tsubst_flags_t complain)
3043 tree base2 = NULL_TREE;
3044 tree itype = NULL_TREE;
3046 /* The type of BASE. */
3047 tree atype = TREE_TYPE (base);
3048 /* The type of an element in the array. */
3049 tree type = TREE_TYPE (atype);
3050 /* The element type reached after removing all outer array
3052 tree inner_elt_type;
3053 /* The type of a pointer to an element in the array. */
3058 tree try_block = NULL_TREE;
3059 int num_initialized_elts = 0;
3061 tree const_init = NULL_TREE;
3063 bool xvalue = false;
3064 bool errors = false;
3066 if (TREE_CODE (atype) == ARRAY_TYPE && TYPE_DOMAIN (atype))
3067 maxindex = array_type_nelts (atype);
3069 if (maxindex == NULL_TREE || maxindex == error_mark_node
3070 || integer_all_onesp (maxindex))
3071 return error_mark_node;
3073 if (explicit_value_init_p)
3076 inner_elt_type = strip_array_types (type);
3078 /* Look through the TARGET_EXPR around a compound literal. */
3079 if (init && TREE_CODE (init) == TARGET_EXPR
3080 && TREE_CODE (TARGET_EXPR_INITIAL (init)) == CONSTRUCTOR
3082 init = TARGET_EXPR_INITIAL (init);
3085 && TREE_CODE (atype) == ARRAY_TYPE
3087 ? (!CLASS_TYPE_P (inner_elt_type)
3088 || !TYPE_HAS_COMPLEX_COPY_ASSIGN (inner_elt_type))
3089 : !TYPE_NEEDS_CONSTRUCTING (type))
3090 && ((TREE_CODE (init) == CONSTRUCTOR
3091 /* Don't do this if the CONSTRUCTOR might contain something
3092 that might throw and require us to clean up. */
3093 && (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init))
3094 || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_elt_type)))
3097 /* Do non-default initialization of trivial arrays resulting from
3098 brace-enclosed initializers. In this case, digest_init and
3099 store_constructor will handle the semantics for us. */
3101 stmt_expr = build2 (INIT_EXPR, atype, base, init);
3105 maxindex = cp_convert (ptrdiff_type_node, maxindex);
3106 if (TREE_CODE (atype) == ARRAY_TYPE)
3108 ptype = build_pointer_type (type);
3109 base = cp_convert (ptype, decay_conversion (base));
3114 /* The code we are generating looks like:
3118 ptrdiff_t iterator = maxindex;
3120 for (; iterator != -1; --iterator) {
3121 ... initialize *t1 ...
3125 ... destroy elements that were constructed ...
3130 We can omit the try and catch blocks if we know that the
3131 initialization will never throw an exception, or if the array
3132 elements do not have destructors. We can omit the loop completely if
3133 the elements of the array do not have constructors.
3135 We actually wrap the entire body of the above in a STMT_EXPR, for
3138 When copying from array to another, when the array elements have
3139 only trivial copy constructors, we should use __builtin_memcpy
3140 rather than generating a loop. That way, we could take advantage
3141 of whatever cleverness the back end has for dealing with copies
3142 of blocks of memory. */
3144 is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
3145 destroy_temps = stmts_are_full_exprs_p ();
3146 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
3147 rval = get_temp_regvar (ptype, base);
3148 base = get_temp_regvar (ptype, rval);
3149 iterator = get_temp_regvar (ptrdiff_type_node, maxindex);
3151 /* If initializing one array from another, initialize element by
3152 element. We rely upon the below calls to do the argument
3153 checking. Evaluate the initializer before entering the try block. */
3154 if (from_array && init && TREE_CODE (init) != CONSTRUCTOR)
3156 if (lvalue_kind (init) & clk_rvalueref)
3158 base2 = decay_conversion (init);
3159 itype = TREE_TYPE (base2);
3160 base2 = get_temp_regvar (itype, base2);
3161 itype = TREE_TYPE (itype);
3164 /* Protect the entire array initialization so that we can destroy
3165 the partially constructed array if an exception is thrown.
3166 But don't do this if we're assigning. */
3167 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
3170 try_block = begin_try_block ();
3173 /* If the initializer is {}, then all elements are initialized from {}.
3174 But for non-classes, that's the same as value-initialization. */
3175 if (init && BRACE_ENCLOSED_INITIALIZER_P (init)
3176 && CONSTRUCTOR_NELTS (init) == 0)
3178 if (CLASS_TYPE_P (type))
3179 /* Leave init alone. */;
3183 explicit_value_init_p = true;
3187 /* Maybe pull out constant value when from_array? */
3189 else if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR)
3191 /* Do non-default initialization of non-trivial arrays resulting from
3192 brace-enclosed initializers. */
3193 unsigned HOST_WIDE_INT idx;
3195 /* Should we try to create a constant initializer? */
3196 bool try_const = (TREE_CODE (atype) == ARRAY_TYPE
3197 && (literal_type_p (inner_elt_type)
3198 || TYPE_HAS_CONSTEXPR_CTOR (inner_elt_type)));
3199 /* If the constructor already has the array type, it's been through
3200 digest_init, so we shouldn't try to do anything more. */
3201 bool digested = same_type_p (atype, TREE_TYPE (init));
3202 bool saw_non_const = false;
3203 bool saw_const = false;
3204 /* If we're initializing a static array, we want to do static
3205 initialization of any elements with constant initializers even if
3206 some are non-constant. */
3207 bool do_static_init = (DECL_P (obase) && TREE_STATIC (obase));
3208 VEC(constructor_elt,gc) *new_vec;
3212 new_vec = VEC_alloc (constructor_elt, gc, CONSTRUCTOR_NELTS (init));
3216 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), idx, field, elt)
3218 tree baseref = build1 (INDIRECT_REF, type, base);
3221 num_initialized_elts++;
3223 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
3225 one_init = build2 (INIT_EXPR, type, baseref, elt);
3226 else if (MAYBE_CLASS_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)
3227 one_init = build_aggr_init (baseref, elt, 0, complain);
3229 one_init = cp_build_modify_expr (baseref, NOP_EXPR,
3231 if (one_init == error_mark_node)
3236 if (TREE_CODE (e) == EXPR_STMT)
3237 e = TREE_OPERAND (e, 0);
3238 if (TREE_CODE (e) == CONVERT_EXPR
3239 && VOID_TYPE_P (TREE_TYPE (e)))
3240 e = TREE_OPERAND (e, 0);
3241 e = maybe_constant_init (e);
3242 if (reduced_constant_expression_p (e))
3244 CONSTRUCTOR_APPEND_ELT (new_vec, field, e);
3246 one_init = NULL_TREE;
3248 one_init = build2 (INIT_EXPR, type, baseref, e);
3254 CONSTRUCTOR_APPEND_ELT (new_vec, field,
3255 build_zero_init (TREE_TYPE (e),
3257 saw_non_const = true;
3262 finish_expr_stmt (one_init);
3263 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
3265 one_init = cp_build_unary_op (PREINCREMENT_EXPR, base, 0, complain);
3266 if (one_init == error_mark_node)
3269 finish_expr_stmt (one_init);
3271 one_init = cp_build_unary_op (PREDECREMENT_EXPR, iterator, 0,
3273 if (one_init == error_mark_node)
3276 finish_expr_stmt (one_init);
3282 const_init = build_constructor (atype, new_vec);
3283 else if (do_static_init && saw_const)
3284 DECL_INITIAL (obase) = build_constructor (atype, new_vec);
3286 VEC_free (constructor_elt, gc, new_vec);
3289 /* Clear out INIT so that we don't get confused below. */
3292 else if (from_array)
3295 /* OK, we set base2 above. */;
3296 else if (CLASS_TYPE_P (type)
3297 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
3299 if (complain & tf_error)
3300 error ("initializer ends prematurely");
3305 /* Now, default-initialize any remaining elements. We don't need to
3306 do that if a) the type does not need constructing, or b) we've
3307 already initialized all the elements.
3309 We do need to keep going if we're copying an array. */
3312 || ((type_build_ctor_call (type) || init || explicit_value_init_p)
3313 && ! (host_integerp (maxindex, 0)
3314 && (num_initialized_elts
3315 == tree_low_cst (maxindex, 0) + 1))))
3317 /* If the ITERATOR is equal to -1, then we don't have to loop;
3318 we've already initialized all the elements. */
3323 for_stmt = begin_for_stmt (NULL_TREE, NULL_TREE);
3324 finish_for_init_stmt (for_stmt);
3325 finish_for_cond (build2 (NE_EXPR, boolean_type_node, iterator,
3326 build_int_cst (TREE_TYPE (iterator), -1)),
3328 elt_init = cp_build_unary_op (PREDECREMENT_EXPR, iterator, 0,
3330 if (elt_init == error_mark_node)
3332 finish_for_expr (elt_init, for_stmt);
3334 to = build1 (INDIRECT_REF, type, base);
3342 from = build1 (INDIRECT_REF, itype, base2);
3349 if (from_array == 2)
3350 elt_init = cp_build_modify_expr (to, NOP_EXPR, from,
3352 else if (type_build_ctor_call (type))
3353 elt_init = build_aggr_init (to, from, 0, complain);
3355 elt_init = cp_build_modify_expr (to, NOP_EXPR, from,
3360 else if (TREE_CODE (type) == ARRAY_TYPE)
3364 ("cannot initialize multi-dimensional array with initializer");
3365 elt_init = build_vec_init (build1 (INDIRECT_REF, type, base),
3367 explicit_value_init_p,
3370 else if (explicit_value_init_p)
3372 elt_init = build_value_init (type, complain);
3373 if (elt_init != error_mark_node)
3374 elt_init = build2 (INIT_EXPR, type, to, elt_init);
3378 gcc_assert (type_build_ctor_call (type) || init);
3379 if (CLASS_TYPE_P (type))
3380 elt_init = build_aggr_init (to, init, 0, complain);
3383 if (TREE_CODE (init) == TREE_LIST)
3384 init = build_x_compound_expr_from_list (init, ELK_INIT,
3386 elt_init = build2 (INIT_EXPR, type, to, init);
3390 if (elt_init == error_mark_node)
3393 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
3394 finish_expr_stmt (elt_init);
3395 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
3397 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base, 0,
3400 finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base2, 0,
3403 finish_for_stmt (for_stmt);
3406 /* Make sure to cleanup any partially constructed elements. */
3407 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
3411 tree m = cp_build_binary_op (input_location,
3412 MINUS_EXPR, maxindex, iterator,
3415 /* Flatten multi-dimensional array since build_vec_delete only
3416 expects one-dimensional array. */
3417 if (TREE_CODE (type) == ARRAY_TYPE)
3418 m = cp_build_binary_op (input_location,
3420 array_type_nelts_total (type),
3423 finish_cleanup_try_block (try_block);
3424 e = build_vec_delete_1 (rval, m,
3425 inner_elt_type, sfk_complete_destructor,
3426 /*use_global_delete=*/0, complain);
3427 if (e == error_mark_node)
3429 finish_cleanup (e, try_block);
3432 /* The value of the array initialization is the array itself, RVAL
3433 is a pointer to the first element. */
3434 finish_stmt_expr_expr (rval, stmt_expr);
3436 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
3438 /* Now make the result have the correct type. */
3439 if (TREE_CODE (atype) == ARRAY_TYPE)
3441 atype = build_pointer_type (atype);
3442 stmt_expr = build1 (NOP_EXPR, atype, stmt_expr);
3443 stmt_expr = cp_build_indirect_ref (stmt_expr, RO_NULL, complain);
3444 TREE_NO_WARNING (stmt_expr) = 1;
3447 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
3450 return build2 (INIT_EXPR, atype, obase, const_init);
3452 return error_mark_node;
3456 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
3460 build_dtor_call (tree exp, special_function_kind dtor_kind, int flags,
3461 tsubst_flags_t complain)
3467 case sfk_complete_destructor:
3468 name = complete_dtor_identifier;
3471 case sfk_base_destructor:
3472 name = base_dtor_identifier;
3475 case sfk_deleting_destructor:
3476 name = deleting_dtor_identifier;
3482 fn = lookup_fnfields (TREE_TYPE (exp), name, /*protect=*/2);
3483 return build_new_method_call (exp, fn,
3485 /*conversion_path=*/NULL_TREE,
3491 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
3492 ADDR is an expression which yields the store to be destroyed.
3493 AUTO_DELETE is the name of the destructor to call, i.e., either
3494 sfk_complete_destructor, sfk_base_destructor, or
3495 sfk_deleting_destructor.
3497 FLAGS is the logical disjunction of zero or more LOOKUP_
3498 flags. See cp-tree.h for more info. */
3501 build_delete (tree type, tree addr, special_function_kind auto_delete,
3502 int flags, int use_global_delete, tsubst_flags_t complain)
3506 if (addr == error_mark_node)
3507 return error_mark_node;
3509 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3510 set to `error_mark_node' before it gets properly cleaned up. */
3511 if (type == error_mark_node)
3512 return error_mark_node;
3514 type = TYPE_MAIN_VARIANT (type);
3516 addr = mark_rvalue_use (addr);
3518 if (TREE_CODE (type) == POINTER_TYPE)
3520 bool complete_p = true;
3522 type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
3523 if (TREE_CODE (type) == ARRAY_TYPE)
3526 /* We don't want to warn about delete of void*, only other
3527 incomplete types. Deleting other incomplete types
3528 invokes undefined behavior, but it is not ill-formed, so
3529 compile to something that would even do The Right Thing
3530 (TM) should the type have a trivial dtor and no delete
3532 if (!VOID_TYPE_P (type))
3534 complete_type (type);
3535 if (!COMPLETE_TYPE_P (type))
3537 if ((complain & tf_warning)
3538 && warning (0, "possible problem detected in invocation of "
3539 "delete operator:"))
3541 cxx_incomplete_type_diagnostic (addr, type, DK_WARNING);
3542 inform (input_location, "neither the destructor nor the class-specific "
3543 "operator delete will be called, even if they are "
3544 "declared when the class is defined");
3548 else if (auto_delete == sfk_deleting_destructor && warn_delnonvdtor
3549 && MAYBE_CLASS_TYPE_P (type) && !CLASSTYPE_FINAL (type)
3550 && TYPE_POLYMORPHIC_P (type))
3553 dtor = CLASSTYPE_DESTRUCTORS (type);
3554 if (!dtor || !DECL_VINDEX (dtor))
3556 if (CLASSTYPE_PURE_VIRTUALS (type))
3557 warning (OPT_Wdelete_non_virtual_dtor,
3558 "deleting object of abstract class type %qT"
3559 " which has non-virtual destructor"
3560 " will cause undefined behaviour", type);
3562 warning (OPT_Wdelete_non_virtual_dtor,
3563 "deleting object of polymorphic class type %qT"
3564 " which has non-virtual destructor"
3565 " might cause undefined behaviour", type);
3569 if (VOID_TYPE_P (type) || !complete_p || !MAYBE_CLASS_TYPE_P (type))
3570 /* Call the builtin operator delete. */
3571 return build_builtin_delete_call (addr);
3572 if (TREE_SIDE_EFFECTS (addr))
3573 addr = save_expr (addr);
3575 /* Throw away const and volatile on target type of addr. */
3576 addr = convert_force (build_pointer_type (type), addr, 0);
3578 else if (TREE_CODE (type) == ARRAY_TYPE)
3582 if (TYPE_DOMAIN (type) == NULL_TREE)
3584 if (complain & tf_error)
3585 error ("unknown array size in delete");
3586 return error_mark_node;
3588 return build_vec_delete (addr, array_type_nelts (type),
3589 auto_delete, use_global_delete, complain);
3593 /* Don't check PROTECT here; leave that decision to the
3594 destructor. If the destructor is accessible, call it,
3595 else report error. */
3596 addr = cp_build_addr_expr (addr, complain);
3597 if (addr == error_mark_node)
3598 return error_mark_node;
3599 if (TREE_SIDE_EFFECTS (addr))
3600 addr = save_expr (addr);
3602 addr = convert_force (build_pointer_type (type), addr, 0);
3605 gcc_assert (MAYBE_CLASS_TYPE_P (type));
3607 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
3609 if (auto_delete != sfk_deleting_destructor)
3610 return void_zero_node;
3612 return build_op_delete_call (DELETE_EXPR, addr,
3613 cxx_sizeof_nowarn (type),
3615 /*placement=*/NULL_TREE,
3616 /*alloc_fn=*/NULL_TREE);
3620 tree head = NULL_TREE;
3621 tree do_delete = NULL_TREE;
3624 if (CLASSTYPE_LAZY_DESTRUCTOR (type))
3625 lazily_declare_fn (sfk_destructor, type);
3627 /* For `::delete x', we must not use the deleting destructor
3628 since then we would not be sure to get the global `operator
3630 if (use_global_delete && auto_delete == sfk_deleting_destructor)
3632 /* We will use ADDR multiple times so we must save it. */
3633 addr = save_expr (addr);
3634 head = get_target_expr (build_headof (addr));
3635 /* Delete the object. */
3636 do_delete = build_builtin_delete_call (head);
3637 /* Otherwise, treat this like a complete object destructor
3639 auto_delete = sfk_complete_destructor;
3641 /* If the destructor is non-virtual, there is no deleting
3642 variant. Instead, we must explicitly call the appropriate
3643 `operator delete' here. */
3644 else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type))
3645 && auto_delete == sfk_deleting_destructor)
3647 /* We will use ADDR multiple times so we must save it. */
3648 addr = save_expr (addr);
3649 /* Build the call. */
3650 do_delete = build_op_delete_call (DELETE_EXPR,
3652 cxx_sizeof_nowarn (type),
3654 /*placement=*/NULL_TREE,
3655 /*alloc_fn=*/NULL_TREE);
3656 /* Call the complete object destructor. */
3657 auto_delete = sfk_complete_destructor;
3659 else if (auto_delete == sfk_deleting_destructor
3660 && TYPE_GETS_REG_DELETE (type))
3662 /* Make sure we have access to the member op delete, even though
3663 we'll actually be calling it from the destructor. */
3664 build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
3666 /*placement=*/NULL_TREE,
3667 /*alloc_fn=*/NULL_TREE);
3670 expr = build_dtor_call (cp_build_indirect_ref (addr, RO_NULL, complain),
3671 auto_delete, flags, complain);
3672 if (expr == error_mark_node)
3673 return error_mark_node;
3675 expr = build2 (COMPOUND_EXPR, void_type_node, expr, do_delete);
3677 /* We need to calculate this before the dtor changes the vptr. */
3679 expr = build2 (COMPOUND_EXPR, void_type_node, head, expr);
3681 if (flags & LOOKUP_DESTRUCTOR)
3682 /* Explicit destructor call; don't check for null pointer. */
3683 ifexp = integer_one_node;
3686 /* Handle deleting a null pointer. */
3687 ifexp = fold (cp_build_binary_op (input_location,
3688 NE_EXPR, addr, nullptr_node,
3690 if (ifexp == error_mark_node)
3691 return error_mark_node;
3694 if (ifexp != integer_one_node)
3695 expr = build3 (COND_EXPR, void_type_node,
3696 ifexp, expr, void_zero_node);
3702 /* At the beginning of a destructor, push cleanups that will call the
3703 destructors for our base classes and members.
3705 Called from begin_destructor_body. */
3708 push_base_cleanups (void)
3710 tree binfo, base_binfo;
3714 VEC(tree,gc) *vbases;
3716 /* Run destructors for all virtual baseclasses. */
3717 if (CLASSTYPE_VBASECLASSES (current_class_type))
3719 tree cond = (condition_conversion
3720 (build2 (BIT_AND_EXPR, integer_type_node,
3721 current_in_charge_parm,
3722 integer_two_node)));
3724 /* The CLASSTYPE_VBASECLASSES vector is in initialization
3725 order, which is also the right order for pushing cleanups. */
3726 for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
3727 VEC_iterate (tree, vbases, i, base_binfo); i++)
3729 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo)))
3731 expr = build_special_member_call (current_class_ref,
3732 base_dtor_identifier,
3736 | LOOKUP_NONVIRTUAL),
3737 tf_warning_or_error);
3738 expr = build3 (COND_EXPR, void_type_node, cond,
3739 expr, void_zero_node);
3740 finish_decl_cleanup (NULL_TREE, expr);
3745 /* Take care of the remaining baseclasses. */
3746 for (binfo = TYPE_BINFO (current_class_type), i = 0;
3747 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
3749 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))
3750 || BINFO_VIRTUAL_P (base_binfo))
3753 expr = build_special_member_call (current_class_ref,
3754 base_dtor_identifier,
3756 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
3757 tf_warning_or_error);
3758 finish_decl_cleanup (NULL_TREE, expr);
3761 /* Don't automatically destroy union members. */
3762 if (TREE_CODE (current_class_type) == UNION_TYPE)
3765 for (member = TYPE_FIELDS (current_class_type); member;
3766 member = DECL_CHAIN (member))
3768 tree this_type = TREE_TYPE (member);
3769 if (this_type == error_mark_node
3770 || TREE_CODE (member) != FIELD_DECL
3771 || DECL_ARTIFICIAL (member))
3773 if (ANON_UNION_TYPE_P (this_type))
3775 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (this_type))
3777 tree this_member = (build_class_member_access_expr
3778 (current_class_ref, member,
3779 /*access_path=*/NULL_TREE,
3780 /*preserve_reference=*/false,
3781 tf_warning_or_error));
3782 expr = build_delete (this_type, this_member,
3783 sfk_complete_destructor,
3784 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
3785 0, tf_warning_or_error);
3786 finish_decl_cleanup (NULL_TREE, expr);
3791 /* Build a C++ vector delete expression.
3792 MAXINDEX is the number of elements to be deleted.
3793 ELT_SIZE is the nominal size of each element in the vector.
3794 BASE is the expression that should yield the store to be deleted.
3795 This function expands (or synthesizes) these calls itself.
3796 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3798 This also calls delete for virtual baseclasses of elements of the vector.
3800 Update: MAXINDEX is no longer needed. The size can be extracted from the
3801 start of the vector for pointers, and from the type for arrays. We still
3802 use MAXINDEX for arrays because it happens to already have one of the
3803 values we'd have to extract. (We could use MAXINDEX with pointers to
3804 confirm the size, and trap if the numbers differ; not clear that it'd
3805 be worth bothering.) */
3808 build_vec_delete (tree base, tree maxindex,
3809 special_function_kind auto_delete_vec,
3810 int use_global_delete, tsubst_flags_t complain)
3814 tree base_init = NULL_TREE;
3816 type = TREE_TYPE (base);
3818 if (TREE_CODE (type) == POINTER_TYPE)
3820 /* Step back one from start of vector, and read dimension. */
3822 tree size_ptr_type = build_pointer_type (sizetype);
3824 if (TREE_SIDE_EFFECTS (base))
3826 base_init = get_target_expr (base);
3827 base = TARGET_EXPR_SLOT (base_init);
3829 type = strip_array_types (TREE_TYPE (type));
3830 cookie_addr = fold_build1_loc (input_location, NEGATE_EXPR,
3831 sizetype, TYPE_SIZE_UNIT (sizetype));
3832 cookie_addr = fold_build_pointer_plus (fold_convert (size_ptr_type, base),
3834 maxindex = cp_build_indirect_ref (cookie_addr, RO_NULL, complain);
3836 else if (TREE_CODE (type) == ARRAY_TYPE)
3838 /* Get the total number of things in the array, maxindex is a
3840 maxindex = array_type_nelts_total (type);
3841 type = strip_array_types (type);
3842 base = cp_build_addr_expr (base, complain);
3843 if (base == error_mark_node)
3844 return error_mark_node;
3845 if (TREE_SIDE_EFFECTS (base))
3847 base_init = get_target_expr (base);
3848 base = TARGET_EXPR_SLOT (base_init);
3853 if (base != error_mark_node && !(complain & tf_error))
3854 error ("type to vector delete is neither pointer or array type");
3855 return error_mark_node;
3858 rval = build_vec_delete_1 (base, maxindex, type, auto_delete_vec,
3859 use_global_delete, complain);
3860 if (base_init && rval != error_mark_node)
3861 rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), base_init, rval);