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 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* High-level class interface. */
27 #include "coretypes.h"
38 static bool begin_init_stmts (tree *, tree *);
39 static tree finish_init_stmts (bool, tree, tree);
40 static void construct_virtual_base (tree, tree);
41 static void expand_aggr_init_1 (tree, tree, tree, tree, int);
42 static void expand_default_init (tree, tree, tree, tree, int);
43 static tree build_vec_delete_1 (tree, tree, tree, special_function_kind, int);
44 static void perform_member_init (tree, tree);
45 static tree build_builtin_delete_call (tree);
46 static int member_init_ok_or_else (tree, tree, tree);
47 static void expand_virtual_init (tree, tree);
48 static tree sort_mem_initializers (tree, tree);
49 static tree initializing_context (tree);
50 static void expand_cleanup_for_base (tree, tree);
51 static tree get_temp_regvar (tree, tree);
52 static tree dfs_initialize_vtbl_ptrs (tree, void *);
53 static tree build_default_init (tree, tree);
54 static tree build_new_1 (tree);
55 static tree get_cookie_size (tree);
56 static tree build_dtor_call (tree, special_function_kind, int);
57 static tree build_field_list (tree, tree, int *);
58 static tree build_vtbl_address (tree);
60 /* We are about to generate some complex initialization code.
61 Conceptually, it is all a single expression. However, we may want
62 to include conditionals, loops, and other such statement-level
63 constructs. Therefore, we build the initialization code inside a
64 statement-expression. This function starts such an expression.
65 STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
66 pass them back to finish_init_stmts when the expression is
70 begin_init_stmts (tree *stmt_expr_p, tree *compound_stmt_p)
72 bool is_global = !building_stmt_tree ();
74 *stmt_expr_p = begin_stmt_expr ();
75 *compound_stmt_p = begin_compound_stmt (/*has_no_scope=*/true);
80 /* Finish out the statement-expression begun by the previous call to
81 begin_init_stmts. Returns the statement-expression itself. */
84 finish_init_stmts (bool is_global, tree stmt_expr, tree compound_stmt)
86 finish_compound_stmt (compound_stmt);
88 stmt_expr = finish_stmt_expr (stmt_expr, true);
90 my_friendly_assert (!building_stmt_tree () == is_global, 20030726);
97 /* Called from initialize_vtbl_ptrs via dfs_walk. BINFO is the base
98 which we want to initialize the vtable pointer for, DATA is
99 TREE_LIST whose TREE_VALUE is the this ptr expression. */
102 dfs_initialize_vtbl_ptrs (tree binfo, void *data)
104 if ((!BINFO_PRIMARY_P (binfo) || TREE_VIA_VIRTUAL (binfo))
105 && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo)))
107 tree base_ptr = TREE_VALUE ((tree) data);
109 base_ptr = build_base_path (PLUS_EXPR, base_ptr, binfo, /*nonnull=*/1);
111 expand_virtual_init (binfo, base_ptr);
114 BINFO_MARKED (binfo) = 1;
119 /* Initialize all the vtable pointers in the object pointed to by
123 initialize_vtbl_ptrs (tree addr)
128 type = TREE_TYPE (TREE_TYPE (addr));
129 list = build_tree_list (type, addr);
131 /* Walk through the hierarchy, initializing the vptr in each base
132 class. We do these in pre-order because we can't find the virtual
133 bases for a class until we've initialized the vtbl for that
135 dfs_walk_real (TYPE_BINFO (type), dfs_initialize_vtbl_ptrs,
136 NULL, unmarkedp, list);
137 dfs_walk (TYPE_BINFO (type), dfs_unmark, markedp, type);
140 /* Return an expression for the zero-initialization of an object with
141 type T. This expression will either be a constant (in the case
142 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
143 aggregate). In either case, the value can be used as DECL_INITIAL
144 for a decl of the indicated TYPE; it is a valid static initializer.
145 If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS is the
146 number of elements in the array. If STATIC_STORAGE_P is TRUE,
147 initializers are only generated for entities for which
148 zero-initialization does not simply mean filling the storage with
152 build_zero_init (tree type, tree nelts, bool static_storage_p)
154 tree init = NULL_TREE;
158 To zero-initialization storage for an object of type T means:
160 -- if T is a scalar type, the storage is set to the value of zero
163 -- if T is a non-union class type, the storage for each nonstatic
164 data member and each base-class subobject is zero-initialized.
166 -- if T is a union type, the storage for its first data member is
169 -- if T is an array type, the storage for each element is
172 -- if T is a reference type, no initialization is performed. */
174 my_friendly_assert (nelts == NULL_TREE || TREE_CODE (nelts) == INTEGER_CST,
177 if (type == error_mark_node)
179 else if (static_storage_p && zero_init_p (type))
180 /* In order to save space, we do not explicitly build initializers
181 for items that do not need them. GCC's semantics are that
182 items with static storage duration that are not otherwise
183 initialized are initialized to zero. */
185 else if (SCALAR_TYPE_P (type))
186 init = convert (type, integer_zero_node);
187 else if (CLASS_TYPE_P (type))
192 /* Build a constructor to contain the initializations. */
193 init = build_constructor (type, NULL_TREE);
194 /* Iterate over the fields, building initializations. */
196 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
198 if (TREE_CODE (field) != FIELD_DECL)
201 /* Note that for class types there will be FIELD_DECLs
202 corresponding to base classes as well. Thus, iterating
203 over TYPE_FIELDs will result in correct initialization of
204 all of the subobjects. */
205 if (static_storage_p && !zero_init_p (TREE_TYPE (field)))
206 inits = tree_cons (field,
207 build_zero_init (TREE_TYPE (field),
212 /* For unions, only the first field is initialized. */
213 if (TREE_CODE (type) == UNION_TYPE)
216 CONSTRUCTOR_ELTS (init) = nreverse (inits);
218 else if (TREE_CODE (type) == ARRAY_TYPE)
224 /* Build a constructor to contain the initializations. */
225 init = build_constructor (type, NULL_TREE);
226 /* Iterate over the array elements, building initializations. */
228 max_index = nelts ? nelts : array_type_nelts (type);
229 my_friendly_assert (TREE_CODE (max_index) == INTEGER_CST, 20030618);
231 /* A zero-sized array, which is accepted as an extension, will
232 have an upper bound of -1. */
233 if (!tree_int_cst_equal (max_index, integer_minus_one_node))
234 for (index = size_zero_node;
235 !tree_int_cst_lt (max_index, index);
236 index = size_binop (PLUS_EXPR, index, size_one_node))
237 inits = tree_cons (index,
238 build_zero_init (TREE_TYPE (type),
242 CONSTRUCTOR_ELTS (init) = nreverse (inits);
244 else if (TREE_CODE (type) == REFERENCE_TYPE)
249 /* In all cases, the initializer is a constant. */
252 TREE_CONSTANT (init) = 1;
253 TREE_INVARIANT (init) = 1;
259 /* Build an expression for the default-initialization of an object of
260 the indicated TYPE. If NELTS is non-NULL, and TYPE is an
261 ARRAY_TYPE, NELTS is the number of elements in the array. If
262 initialization of TYPE requires calling constructors, this function
263 returns NULL_TREE; the caller is responsible for arranging for the
264 constructors to be called. */
267 build_default_init (tree type, tree nelts)
271 To default-initialize an object of type T means:
273 --if T is a non-POD class type (clause _class_), the default construc-
274 tor for T is called (and the initialization is ill-formed if T has
275 no accessible default constructor);
277 --if T is an array type, each element is default-initialized;
279 --otherwise, the storage for the object is zero-initialized.
281 A program that calls for default-initialization of an entity of refer-
282 ence type is ill-formed. */
284 /* If TYPE_NEEDS_CONSTRUCTING is true, the caller is responsible for
285 performing the initialization. This is confusing in that some
286 non-PODs do not have TYPE_NEEDS_CONSTRUCTING set. (For example,
287 a class with a pointer-to-data member as a non-static data member
288 does not have TYPE_NEEDS_CONSTRUCTING set.) Therefore, we end up
289 passing non-PODs to build_zero_init below, which is contrary to
290 the semantics quoted above from [dcl.init].
292 It happens, however, that the behavior of the constructor the
293 standard says we should have generated would be precisely the
294 same as that obtained by calling build_zero_init below, so things
296 if (TYPE_NEEDS_CONSTRUCTING (type)
297 || (nelts && TREE_CODE (nelts) != INTEGER_CST))
300 /* At this point, TYPE is either a POD class type, an array of POD
301 classes, or something even more innocuous. */
302 return build_zero_init (type, nelts, /*static_storage_p=*/false);
305 /* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of
306 arguments. If TREE_LIST is void_type_node, an empty initializer
307 list was given; if NULL_TREE no initializer was given. */
310 perform_member_init (tree member, tree init)
313 tree type = TREE_TYPE (member);
316 explicit = (init != NULL_TREE);
318 /* Effective C++ rule 12 requires that all data members be
320 if (warn_ecpp && !explicit && TREE_CODE (type) != ARRAY_TYPE)
321 warning ("`%D' should be initialized in the member initialization "
325 if (init == void_type_node)
328 /* Get an lvalue for the data member. */
329 decl = build_class_member_access_expr (current_class_ref, member,
330 /*access_path=*/NULL_TREE,
331 /*preserve_reference=*/true);
332 if (decl == error_mark_node)
335 /* Deal with this here, as we will get confused if we try to call the
336 assignment op for an anonymous union. This can happen in a
337 synthesized copy constructor. */
338 if (ANON_AGGR_TYPE_P (type))
342 init = build (INIT_EXPR, type, decl, TREE_VALUE (init));
343 finish_expr_stmt (init);
346 else if (TYPE_NEEDS_CONSTRUCTING (type))
349 && TREE_CODE (type) == ARRAY_TYPE
351 && TREE_CHAIN (init) == NULL_TREE
352 && TREE_CODE (TREE_TYPE (TREE_VALUE (init))) == ARRAY_TYPE)
354 /* Initialization of one array from another. */
355 finish_expr_stmt (build_vec_init (decl, NULL_TREE, TREE_VALUE (init),
359 finish_expr_stmt (build_aggr_init (decl, init, 0));
363 if (init == NULL_TREE)
367 init = build_default_init (type, /*nelts=*/NULL_TREE);
368 if (TREE_CODE (type) == REFERENCE_TYPE)
370 ("default-initialization of `%#D', which has reference type",
373 /* member traversal: note it leaves init NULL */
374 else if (TREE_CODE (type) == REFERENCE_TYPE)
375 pedwarn ("uninitialized reference member `%D'", member);
376 else if (CP_TYPE_CONST_P (type))
377 pedwarn ("uninitialized member `%D' with `const' type `%T'",
380 else if (TREE_CODE (init) == TREE_LIST)
381 /* There was an explicit member initialization. Do some work
383 init = build_x_compound_expr_from_list (init, "member initializer");
386 finish_expr_stmt (build_modify_expr (decl, INIT_EXPR, init));
389 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
393 expr = build_class_member_access_expr (current_class_ref, member,
394 /*access_path=*/NULL_TREE,
395 /*preserve_reference=*/false);
396 expr = build_delete (type, expr, sfk_complete_destructor,
397 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
399 if (expr != error_mark_node)
400 finish_eh_cleanup (expr);
404 /* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
405 the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */
408 build_field_list (tree t, tree list, int *uses_unions_p)
414 /* Note whether or not T is a union. */
415 if (TREE_CODE (t) == UNION_TYPE)
418 for (fields = TYPE_FIELDS (t); fields; fields = TREE_CHAIN (fields))
420 /* Skip CONST_DECLs for enumeration constants and so forth. */
421 if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
424 /* Keep track of whether or not any fields are unions. */
425 if (TREE_CODE (TREE_TYPE (fields)) == UNION_TYPE)
428 /* For an anonymous struct or union, we must recursively
429 consider the fields of the anonymous type. They can be
430 directly initialized from the constructor. */
431 if (ANON_AGGR_TYPE_P (TREE_TYPE (fields)))
433 /* Add this field itself. Synthesized copy constructors
434 initialize the entire aggregate. */
435 list = tree_cons (fields, NULL_TREE, list);
436 /* And now add the fields in the anonymous aggregate. */
437 list = build_field_list (TREE_TYPE (fields), list,
440 /* Add this field. */
441 else if (DECL_NAME (fields))
442 list = tree_cons (fields, NULL_TREE, list);
448 /* The MEM_INITS are a TREE_LIST. The TREE_PURPOSE of each list gives
449 a FIELD_DECL or BINFO in T that needs initialization. The
450 TREE_VALUE gives the initializer, or list of initializer arguments.
452 Return a TREE_LIST containing all of the initializations required
453 for T, in the order in which they should be performed. The output
454 list has the same format as the input. */
457 sort_mem_initializers (tree t, tree mem_inits)
466 /* Build up a list of initializations. The TREE_PURPOSE of entry
467 will be the subobject (a FIELD_DECL or BINFO) to initialize. The
468 TREE_VALUE will be the constructor arguments, or NULL if no
469 explicit initialization was provided. */
470 sorted_inits = NULL_TREE;
471 /* Process the virtual bases. */
472 for (base = CLASSTYPE_VBASECLASSES (t); base; base = TREE_CHAIN (base))
473 sorted_inits = tree_cons (TREE_VALUE (base), NULL_TREE, sorted_inits);
474 /* Process the direct bases. */
475 for (i = 0; i < CLASSTYPE_N_BASECLASSES (t); ++i)
477 base = BINFO_BASETYPE (TYPE_BINFO (t), i);
478 if (!TREE_VIA_VIRTUAL (base))
479 sorted_inits = tree_cons (base, NULL_TREE, sorted_inits);
481 /* Process the non-static data members. */
482 sorted_inits = build_field_list (t, sorted_inits, &uses_unions_p);
483 /* Reverse the entire list of initializations, so that they are in
484 the order that they will actually be performed. */
485 sorted_inits = nreverse (sorted_inits);
487 /* If the user presented the initializers in an order different from
488 that in which they will actually occur, we issue a warning. Keep
489 track of the next subobject which can be explicitly initialized
490 without issuing a warning. */
491 next_subobject = sorted_inits;
493 /* Go through the explicit initializers, filling in TREE_PURPOSE in
495 for (init = mem_inits; init; init = TREE_CHAIN (init))
500 subobject = TREE_PURPOSE (init);
502 /* If the explicit initializers are in sorted order, then
503 SUBOBJECT will be NEXT_SUBOBJECT, or something following
505 for (subobject_init = next_subobject;
507 subobject_init = TREE_CHAIN (subobject_init))
508 if (TREE_PURPOSE (subobject_init) == subobject)
511 /* Issue a warning if the explicit initializer order does not
512 match that which will actually occur. */
513 if (warn_reorder && !subobject_init)
515 if (TREE_CODE (TREE_PURPOSE (next_subobject)) == FIELD_DECL)
516 cp_warning_at ("`%D' will be initialized after",
517 TREE_PURPOSE (next_subobject));
519 warning ("base `%T' will be initialized after",
520 TREE_PURPOSE (next_subobject));
521 if (TREE_CODE (subobject) == FIELD_DECL)
522 cp_warning_at (" `%#D'", subobject);
524 warning (" base `%T'", subobject);
525 warning (" when initialized here");
528 /* Look again, from the beginning of the list. */
531 subobject_init = sorted_inits;
532 while (TREE_PURPOSE (subobject_init) != subobject)
533 subobject_init = TREE_CHAIN (subobject_init);
536 /* It is invalid to initialize the same subobject more than
538 if (TREE_VALUE (subobject_init))
540 if (TREE_CODE (subobject) == FIELD_DECL)
541 error ("multiple initializations given for `%D'", subobject);
543 error ("multiple initializations given for base `%T'",
547 /* Record the initialization. */
548 TREE_VALUE (subobject_init) = TREE_VALUE (init);
549 next_subobject = subobject_init;
554 If a ctor-initializer specifies more than one mem-initializer for
555 multiple members of the same union (including members of
556 anonymous unions), the ctor-initializer is ill-formed. */
559 tree last_field = NULL_TREE;
560 for (init = sorted_inits; init; init = TREE_CHAIN (init))
566 /* Skip uninitialized members and base classes. */
567 if (!TREE_VALUE (init)
568 || TREE_CODE (TREE_PURPOSE (init)) != FIELD_DECL)
570 /* See if this field is a member of a union, or a member of a
571 structure contained in a union, etc. */
572 field = TREE_PURPOSE (init);
573 for (field_type = DECL_CONTEXT (field);
574 !same_type_p (field_type, t);
575 field_type = TYPE_CONTEXT (field_type))
576 if (TREE_CODE (field_type) == UNION_TYPE)
578 /* If this field is not a member of a union, skip it. */
579 if (TREE_CODE (field_type) != UNION_TYPE)
582 /* It's only an error if we have two initializers for the same
590 /* See if LAST_FIELD and the field initialized by INIT are
591 members of the same union. If so, there's a problem,
592 unless they're actually members of the same structure
593 which is itself a member of a union. For example, given:
595 union { struct { int i; int j; }; };
597 initializing both `i' and `j' makes sense. */
598 field_type = DECL_CONTEXT (field);
602 tree last_field_type;
604 last_field_type = DECL_CONTEXT (last_field);
607 if (same_type_p (last_field_type, field_type))
609 if (TREE_CODE (field_type) == UNION_TYPE)
610 error ("initializations for multiple members of `%T'",
616 if (same_type_p (last_field_type, t))
619 last_field_type = TYPE_CONTEXT (last_field_type);
622 /* If we've reached the outermost class, then we're
624 if (same_type_p (field_type, t))
627 field_type = TYPE_CONTEXT (field_type);
638 /* Initialize all bases and members of CURRENT_CLASS_TYPE. MEM_INITS
639 is a TREE_LIST giving the explicit mem-initializer-list for the
640 constructor. The TREE_PURPOSE of each entry is a subobject (a
641 FIELD_DECL or a BINFO) of the CURRENT_CLASS_TYPE. The TREE_VALUE
642 is a TREE_LIST giving the arguments to the constructor or
643 void_type_node for an empty list of arguments. */
646 emit_mem_initializers (tree mem_inits)
648 /* Sort the mem-initializers into the order in which the
649 initializations should be performed. */
650 mem_inits = sort_mem_initializers (current_class_type, mem_inits);
652 in_base_initializer = 1;
654 /* Initialize base classes. */
656 && TREE_CODE (TREE_PURPOSE (mem_inits)) != FIELD_DECL)
658 tree subobject = TREE_PURPOSE (mem_inits);
659 tree arguments = TREE_VALUE (mem_inits);
661 /* If these initializations are taking place in a copy
662 constructor, the base class should probably be explicitly
664 if (extra_warnings && !arguments
665 && DECL_COPY_CONSTRUCTOR_P (current_function_decl)
666 && TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (subobject)))
667 warning ("base class `%#T' should be explicitly initialized in the "
669 BINFO_TYPE (subobject));
671 /* If an explicit -- but empty -- initializer list was present,
672 treat it just like default initialization at this point. */
673 if (arguments == void_type_node)
674 arguments = NULL_TREE;
676 /* Initialize the base. */
677 if (TREE_VIA_VIRTUAL (subobject))
678 construct_virtual_base (subobject, arguments);
683 base_addr = build_base_path (PLUS_EXPR, current_class_ptr,
685 expand_aggr_init_1 (subobject, NULL_TREE,
686 build_indirect_ref (base_addr, NULL),
689 expand_cleanup_for_base (subobject, NULL_TREE);
692 mem_inits = TREE_CHAIN (mem_inits);
694 in_base_initializer = 0;
696 /* Initialize the vptrs. */
697 initialize_vtbl_ptrs (current_class_ptr);
699 /* Initialize the data members. */
702 perform_member_init (TREE_PURPOSE (mem_inits),
703 TREE_VALUE (mem_inits));
704 mem_inits = TREE_CHAIN (mem_inits);
708 /* Returns the address of the vtable (i.e., the value that should be
709 assigned to the vptr) for BINFO. */
712 build_vtbl_address (tree binfo)
714 tree binfo_for = binfo;
717 if (BINFO_VPTR_INDEX (binfo) && TREE_VIA_VIRTUAL (binfo)
718 && BINFO_PRIMARY_P (binfo))
719 /* If this is a virtual primary base, then the vtable we want to store
720 is that for the base this is being used as the primary base of. We
721 can't simply skip the initialization, because we may be expanding the
722 inits of a subobject constructor where the virtual base layout
724 while (BINFO_PRIMARY_BASE_OF (binfo_for))
725 binfo_for = BINFO_PRIMARY_BASE_OF (binfo_for);
727 /* Figure out what vtable BINFO's vtable is based on, and mark it as
729 vtbl = get_vtbl_decl_for_binfo (binfo_for);
730 assemble_external (vtbl);
731 TREE_USED (vtbl) = 1;
733 /* Now compute the address to use when initializing the vptr. */
734 vtbl = unshare_expr (BINFO_VTABLE (binfo_for));
735 if (TREE_CODE (vtbl) == VAR_DECL)
736 vtbl = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (vtbl)), vtbl);
741 /* This code sets up the virtual function tables appropriate for
742 the pointer DECL. It is a one-ply initialization.
744 BINFO is the exact type that DECL is supposed to be. In
745 multiple inheritance, this might mean "C's A" if C : A, B. */
748 expand_virtual_init (tree binfo, tree decl)
753 /* Compute the initializer for vptr. */
754 vtbl = build_vtbl_address (binfo);
756 /* We may get this vptr from a VTT, if this is a subobject
757 constructor or subobject destructor. */
758 vtt_index = BINFO_VPTR_INDEX (binfo);
764 /* Compute the value to use, when there's a VTT. */
765 vtt_parm = current_vtt_parm;
766 vtbl2 = build (PLUS_EXPR,
767 TREE_TYPE (vtt_parm),
770 vtbl2 = build_indirect_ref (vtbl2, NULL);
771 vtbl2 = convert (TREE_TYPE (vtbl), vtbl2);
773 /* The actual initializer is the VTT value only in the subobject
774 constructor. In maybe_clone_body we'll substitute NULL for
775 the vtt_parm in the case of the non-subobject constructor. */
776 vtbl = build (COND_EXPR,
778 build (EQ_EXPR, boolean_type_node,
779 current_in_charge_parm, integer_zero_node),
784 /* Compute the location of the vtpr. */
785 vtbl_ptr = build_vfield_ref (build_indirect_ref (decl, NULL),
787 my_friendly_assert (vtbl_ptr != error_mark_node, 20010730);
789 /* Assign the vtable to the vptr. */
790 vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl, 0);
791 finish_expr_stmt (build_modify_expr (vtbl_ptr, NOP_EXPR, vtbl));
794 /* If an exception is thrown in a constructor, those base classes already
795 constructed must be destroyed. This function creates the cleanup
796 for BINFO, which has just been constructed. If FLAG is non-NULL,
797 it is a DECL which is nonzero when this base needs to be
801 expand_cleanup_for_base (tree binfo, tree flag)
805 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo)))
808 /* Call the destructor. */
809 expr = build_special_member_call (current_class_ref,
810 base_dtor_identifier,
813 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL);
815 expr = fold (build (COND_EXPR, void_type_node,
816 c_common_truthvalue_conversion (flag),
817 expr, integer_zero_node));
819 finish_eh_cleanup (expr);
822 /* Construct the virtual base-class VBASE passing the ARGUMENTS to its
826 construct_virtual_base (tree vbase, tree arguments)
833 /* If there are virtual base classes with destructors, we need to
834 emit cleanups to destroy them if an exception is thrown during
835 the construction process. These exception regions (i.e., the
836 period during which the cleanups must occur) begin from the time
837 the construction is complete to the end of the function. If we
838 create a conditional block in which to initialize the
839 base-classes, then the cleanup region for the virtual base begins
840 inside a block, and ends outside of that block. This situation
841 confuses the sjlj exception-handling code. Therefore, we do not
842 create a single conditional block, but one for each
843 initialization. (That way the cleanup regions always begin
844 in the outer block.) We trust the back-end to figure out
845 that the FLAG will not change across initializations, and
846 avoid doing multiple tests. */
847 flag = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl));
848 inner_if_stmt = begin_if_stmt ();
849 finish_if_stmt_cond (flag, inner_if_stmt);
850 compound_stmt = begin_compound_stmt (/*has_no_scope=*/true);
852 /* Compute the location of the virtual base. If we're
853 constructing virtual bases, then we must be the most derived
854 class. Therefore, we don't have to look up the virtual base;
855 we already know where it is. */
856 exp = convert_to_base_statically (current_class_ref, vbase);
858 expand_aggr_init_1 (vbase, current_class_ref, exp, arguments,
860 finish_compound_stmt (compound_stmt);
861 finish_then_clause (inner_if_stmt);
864 expand_cleanup_for_base (vbase, flag);
867 /* Find the context in which this FIELD can be initialized. */
870 initializing_context (tree field)
872 tree t = DECL_CONTEXT (field);
874 /* Anonymous union members can be initialized in the first enclosing
875 non-anonymous union context. */
876 while (t && ANON_AGGR_TYPE_P (t))
877 t = TYPE_CONTEXT (t);
881 /* Function to give error message if member initialization specification
882 is erroneous. FIELD is the member we decided to initialize.
883 TYPE is the type for which the initialization is being performed.
884 FIELD must be a member of TYPE.
886 MEMBER_NAME is the name of the member. */
889 member_init_ok_or_else (tree field, tree type, tree member_name)
891 if (field == error_mark_node)
895 error ("class `%T' does not have any field named `%D'", type,
899 if (TREE_CODE (field) == VAR_DECL)
901 error ("`%#D' is a static data member; it can only be "
902 "initialized at its definition",
906 if (TREE_CODE (field) != FIELD_DECL)
908 error ("`%#D' is not a non-static data member of `%T'",
912 if (initializing_context (field) != type)
914 error ("class `%T' does not have any field named `%D'", type,
922 /* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
923 is a _TYPE node or TYPE_DECL which names a base for that type.
924 Check the validity of NAME, and return either the base _TYPE, base
925 binfo, or the FIELD_DECL of the member. If NAME is invalid, return
926 NULL_TREE and issue a diagnostic.
928 An old style unnamed direct single base construction is permitted,
929 where NAME is NULL. */
932 expand_member_init (tree name)
937 if (!current_class_ref)
942 /* This is an obsolete unnamed base class initializer. The
943 parser will already have warned about its use. */
944 switch (CLASSTYPE_N_BASECLASSES (current_class_type))
947 error ("unnamed initializer for `%T', which has no base classes",
951 basetype = TYPE_BINFO_BASETYPE (current_class_type, 0);
954 error ("unnamed initializer for `%T', which uses multiple inheritance",
959 else if (TYPE_P (name))
961 basetype = TYPE_MAIN_VARIANT (name);
962 name = TYPE_NAME (name);
964 else if (TREE_CODE (name) == TYPE_DECL)
965 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (name));
967 basetype = NULL_TREE;
976 if (current_template_parms)
979 class_binfo = TYPE_BINFO (current_class_type);
980 direct_binfo = NULL_TREE;
981 virtual_binfo = NULL_TREE;
983 /* Look for a direct base. */
984 for (i = 0; i < BINFO_N_BASETYPES (class_binfo); ++i)
985 if (same_type_p (basetype,
986 TYPE_BINFO_BASETYPE (current_class_type, i)))
988 direct_binfo = BINFO_BASETYPE (class_binfo, i);
991 /* Look for a virtual base -- unless the direct base is itself
993 if (!direct_binfo || !TREE_VIA_VIRTUAL (direct_binfo))
996 = purpose_member (basetype,
997 CLASSTYPE_VBASECLASSES (current_class_type));
999 virtual_binfo = TREE_VALUE (virtual_binfo);
1002 /* [class.base.init]
1004 If a mem-initializer-id is ambiguous because it designates
1005 both a direct non-virtual base class and an inherited virtual
1006 base class, the mem-initializer is ill-formed. */
1007 if (direct_binfo && virtual_binfo)
1009 error ("'%D' is both a direct base and an indirect virtual base",
1014 if (!direct_binfo && !virtual_binfo)
1016 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
1017 error ("type `%D' is not a direct or virtual base of `%T'",
1018 name, current_class_type);
1020 error ("type `%D' is not a direct base of `%T'",
1021 name, current_class_type);
1025 return direct_binfo ? direct_binfo : virtual_binfo;
1029 if (TREE_CODE (name) == IDENTIFIER_NODE)
1030 field = lookup_field (current_class_type, name, 1, false);
1034 if (member_init_ok_or_else (field, current_class_type, name))
1041 /* This is like `expand_member_init', only it stores one aggregate
1044 INIT comes in two flavors: it is either a value which
1045 is to be stored in EXP, or it is a parameter list
1046 to go to a constructor, which will operate on EXP.
1047 If INIT is not a parameter list for a constructor, then set
1048 LOOKUP_ONLYCONVERTING.
1049 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1050 the initializer, if FLAGS is 0, then it is the (init) form.
1051 If `init' is a CONSTRUCTOR, then we emit a warning message,
1052 explaining that such initializations are invalid.
1054 If INIT resolves to a CALL_EXPR which happens to return
1055 something of the type we are looking for, then we know
1056 that we can safely use that call to perform the
1059 The virtual function table pointer cannot be set up here, because
1060 we do not really know its type.
1062 This never calls operator=().
1064 When initializing, nothing is CONST.
1066 A default copy constructor may have to be used to perform the
1069 A constructor or a conversion operator may have to be used to
1070 perform the initialization, but not both, as it would be ambiguous. */
1073 build_aggr_init (tree exp, tree init, int flags)
1078 tree type = TREE_TYPE (exp);
1079 int was_const = TREE_READONLY (exp);
1080 int was_volatile = TREE_THIS_VOLATILE (exp);
1083 if (init == error_mark_node)
1084 return error_mark_node;
1086 TREE_READONLY (exp) = 0;
1087 TREE_THIS_VOLATILE (exp) = 0;
1089 if (init && TREE_CODE (init) != TREE_LIST)
1090 flags |= LOOKUP_ONLYCONVERTING;
1092 if (TREE_CODE (type) == ARRAY_TYPE)
1096 /* An array may not be initialized use the parenthesized
1097 initialization form -- unless the initializer is "()". */
1098 if (init && TREE_CODE (init) == TREE_LIST)
1100 error ("bad array initializer");
1101 return error_mark_node;
1103 /* Must arrange to initialize each element of EXP
1104 from elements of INIT. */
1105 itype = init ? TREE_TYPE (init) : NULL_TREE;
1106 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
1107 TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type);
1108 if (itype && cp_type_quals (itype) != TYPE_UNQUALIFIED)
1109 itype = TREE_TYPE (init) = TYPE_MAIN_VARIANT (itype);
1110 stmt_expr = build_vec_init (exp, NULL_TREE, init,
1111 itype && same_type_p (itype,
1113 TREE_READONLY (exp) = was_const;
1114 TREE_THIS_VOLATILE (exp) = was_volatile;
1115 TREE_TYPE (exp) = type;
1117 TREE_TYPE (init) = itype;
1121 if (TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == PARM_DECL)
1122 /* Just know that we've seen something for this node. */
1123 TREE_USED (exp) = 1;
1125 TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type);
1126 is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
1127 destroy_temps = stmts_are_full_exprs_p ();
1128 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
1129 expand_aggr_init_1 (TYPE_BINFO (type), exp, exp,
1130 init, LOOKUP_NORMAL|flags);
1131 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
1132 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
1133 TREE_TYPE (exp) = type;
1134 TREE_READONLY (exp) = was_const;
1135 TREE_THIS_VOLATILE (exp) = was_volatile;
1140 /* Like build_aggr_init, but not just for aggregates. */
1143 build_init (tree decl, tree init, int flags)
1147 if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1148 expr = build_aggr_init (decl, init, flags);
1149 else if (CLASS_TYPE_P (TREE_TYPE (decl)))
1150 expr = build_special_member_call (decl, complete_ctor_identifier,
1151 build_tree_list (NULL_TREE, init),
1152 TYPE_BINFO (TREE_TYPE (decl)),
1153 LOOKUP_NORMAL|flags);
1155 expr = build (INIT_EXPR, TREE_TYPE (decl), decl, init);
1161 expand_default_init (tree binfo, tree true_exp, tree exp, tree init, int flags)
1163 tree type = TREE_TYPE (exp);
1166 /* It fails because there may not be a constructor which takes
1167 its own type as the first (or only parameter), but which does
1168 take other types via a conversion. So, if the thing initializing
1169 the expression is a unit element of type X, first try X(X&),
1170 followed by initialization by X. If neither of these work
1171 out, then look hard. */
1175 if (init && TREE_CODE (init) != TREE_LIST
1176 && (flags & LOOKUP_ONLYCONVERTING))
1178 /* Base subobjects should only get direct-initialization. */
1179 if (true_exp != exp)
1182 if (flags & DIRECT_BIND)
1183 /* Do nothing. We hit this in two cases: Reference initialization,
1184 where we aren't initializing a real variable, so we don't want
1185 to run a new constructor; and catching an exception, where we
1186 have already built up the constructor call so we could wrap it
1187 in an exception region. */;
1188 else if (BRACE_ENCLOSED_INITIALIZER_P (init))
1190 /* A brace-enclosed initializer for an aggregate. */
1191 my_friendly_assert (CP_AGGREGATE_TYPE_P (type), 20021016);
1192 init = digest_init (type, init, (tree *)NULL);
1195 init = ocp_convert (type, init, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
1197 if (TREE_CODE (init) == MUST_NOT_THROW_EXPR)
1198 /* We need to protect the initialization of a catch parm with a
1199 call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
1200 around the TARGET_EXPR for the copy constructor. See
1201 initialize_handler_parm. */
1203 TREE_OPERAND (init, 0) = build (INIT_EXPR, TREE_TYPE (exp), exp,
1204 TREE_OPERAND (init, 0));
1205 TREE_TYPE (init) = void_type_node;
1208 init = build (INIT_EXPR, TREE_TYPE (exp), exp, init);
1209 TREE_SIDE_EFFECTS (init) = 1;
1210 finish_expr_stmt (init);
1214 if (init == NULL_TREE
1215 || (TREE_CODE (init) == TREE_LIST && ! TREE_TYPE (init)))
1219 init = TREE_VALUE (parms);
1222 parms = build_tree_list (NULL_TREE, init);
1224 if (true_exp == exp)
1225 ctor_name = complete_ctor_identifier;
1227 ctor_name = base_ctor_identifier;
1229 rval = build_special_member_call (exp, ctor_name, parms, binfo, flags);
1230 if (TREE_SIDE_EFFECTS (rval))
1231 finish_expr_stmt (convert_to_void (rval, NULL));
1234 /* This function is responsible for initializing EXP with INIT
1237 BINFO is the binfo of the type for who we are performing the
1238 initialization. For example, if W is a virtual base class of A and B,
1240 If we are initializing B, then W must contain B's W vtable, whereas
1241 were we initializing C, W must contain C's W vtable.
1243 TRUE_EXP is nonzero if it is the true expression being initialized.
1244 In this case, it may be EXP, or may just contain EXP. The reason we
1245 need this is because if EXP is a base element of TRUE_EXP, we
1246 don't necessarily know by looking at EXP where its virtual
1247 baseclass fields should really be pointing. But we do know
1248 from TRUE_EXP. In constructors, we don't know anything about
1249 the value being initialized.
1251 FLAGS is just passed to `build_new_method_call'. See that function
1252 for its description. */
1255 expand_aggr_init_1 (tree binfo, tree true_exp, tree exp, tree init, int flags)
1257 tree type = TREE_TYPE (exp);
1259 my_friendly_assert (init != error_mark_node && type != error_mark_node, 211);
1260 my_friendly_assert (building_stmt_tree (), 20021010);
1262 /* Use a function returning the desired type to initialize EXP for us.
1263 If the function is a constructor, and its first argument is
1264 NULL_TREE, know that it was meant for us--just slide exp on
1265 in and expand the constructor. Constructors now come
1268 if (init && TREE_CODE (exp) == VAR_DECL
1269 && TREE_CODE (init) == CONSTRUCTOR
1270 && TREE_HAS_CONSTRUCTOR (init))
1272 /* If store_init_value returns NULL_TREE, the INIT has been
1273 record in the DECL_INITIAL for EXP. That means there's
1274 nothing more we have to do. */
1275 init = store_init_value (exp, init);
1277 finish_expr_stmt (init);
1281 /* We know that expand_default_init can handle everything we want
1283 expand_default_init (binfo, true_exp, exp, init, flags);
1286 /* Report an error if TYPE is not a user-defined, aggregate type. If
1287 OR_ELSE is nonzero, give an error message. */
1290 is_aggr_type (tree type, int or_else)
1292 if (type == error_mark_node)
1295 if (! IS_AGGR_TYPE (type)
1296 && TREE_CODE (type) != TEMPLATE_TYPE_PARM
1297 && TREE_CODE (type) != BOUND_TEMPLATE_TEMPLATE_PARM)
1300 error ("`%T' is not an aggregate type", type);
1306 /* Like is_aggr_typedef, but returns typedef if successful. */
1309 get_aggr_from_typedef (tree name, int or_else)
1313 if (name == error_mark_node)
1316 if (IDENTIFIER_HAS_TYPE_VALUE (name))
1317 type = IDENTIFIER_TYPE_VALUE (name);
1321 error ("`%T' fails to be an aggregate typedef", name);
1325 if (! IS_AGGR_TYPE (type)
1326 && TREE_CODE (type) != TEMPLATE_TYPE_PARM
1327 && TREE_CODE (type) != BOUND_TEMPLATE_TEMPLATE_PARM)
1330 error ("type `%T' is of non-aggregate type", type);
1337 get_type_value (tree name)
1339 if (name == error_mark_node)
1342 if (IDENTIFIER_HAS_TYPE_VALUE (name))
1343 return IDENTIFIER_TYPE_VALUE (name);
1348 /* Build a reference to a member of an aggregate. This is not a C++
1349 `&', but really something which can have its address taken, and
1350 then act as a pointer to member, for example TYPE :: FIELD can have
1351 its address taken by saying & TYPE :: FIELD. ADDRESS_P is true if
1352 this expression is the operand of "&".
1354 @@ Prints out lousy diagnostics for operator <typename>
1357 @@ This function should be rewritten and placed in search.c. */
1360 build_offset_ref (tree type, tree name, bool address_p)
1364 tree basebinfo = NULL_TREE;
1365 tree orig_name = name;
1367 /* class templates can come in as TEMPLATE_DECLs here. */
1368 if (TREE_CODE (name) == TEMPLATE_DECL)
1371 if (dependent_type_p (type) || type_dependent_expression_p (name))
1372 return build_min_nt (SCOPE_REF, type, name);
1374 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
1376 /* If the NAME is a TEMPLATE_ID_EXPR, we are looking at
1377 something like `a.template f<int>' or the like. For the most
1378 part, we treat this just like a.f. We do remember, however,
1379 the template-id that was used. */
1380 name = TREE_OPERAND (orig_name, 0);
1383 name = DECL_NAME (name);
1386 if (TREE_CODE (name) == COMPONENT_REF)
1387 name = TREE_OPERAND (name, 1);
1388 if (TREE_CODE (name) == OVERLOAD)
1389 name = DECL_NAME (OVL_CURRENT (name));
1392 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 0);
1395 if (type == NULL_TREE)
1396 return error_mark_node;
1398 /* Handle namespace names fully here. */
1399 if (TREE_CODE (type) == NAMESPACE_DECL)
1401 tree t = lookup_namespace_name (type, name);
1402 if (t == error_mark_node)
1404 if (TREE_CODE (orig_name) == TEMPLATE_ID_EXPR)
1405 /* Reconstruct the TEMPLATE_ID_EXPR. */
1406 t = build (TEMPLATE_ID_EXPR, TREE_TYPE (t),
1407 t, TREE_OPERAND (orig_name, 1));
1408 if (! type_unknown_p (t))
1411 t = convert_from_reference (t);
1416 if (! is_aggr_type (type, 1))
1417 return error_mark_node;
1419 if (TREE_CODE (name) == BIT_NOT_EXPR)
1421 if (! check_dtor_name (type, name))
1422 error ("qualified type `%T' does not match destructor name `~%T'",
1423 type, TREE_OPERAND (name, 0));
1424 name = dtor_identifier;
1427 if (!COMPLETE_TYPE_P (complete_type (type))
1428 && !TYPE_BEING_DEFINED (type))
1430 error ("incomplete type `%T' does not have member `%D'", type,
1432 return error_mark_node;
1435 decl = maybe_dummy_object (type, &basebinfo);
1437 if (BASELINK_P (name) || DECL_P (name))
1441 member = lookup_member (basebinfo, name, 1, 0);
1443 if (member == error_mark_node)
1444 return error_mark_node;
1449 error ("`%D' is not a member of type `%T'", name, type);
1450 return error_mark_node;
1453 if (processing_template_decl)
1455 if (TREE_CODE (orig_name) == TEMPLATE_ID_EXPR)
1456 return build_min (SCOPE_REF, TREE_TYPE (member), type, orig_name);
1458 return build_min (SCOPE_REF, TREE_TYPE (member), type, name);
1461 if (TREE_CODE (member) == TYPE_DECL)
1463 TREE_USED (member) = 1;
1466 /* static class members and class-specific enum
1467 values can be returned without further ado. */
1468 if (TREE_CODE (member) == VAR_DECL || TREE_CODE (member) == CONST_DECL)
1471 return convert_from_reference (member);
1474 if (TREE_CODE (member) == FIELD_DECL && DECL_C_BIT_FIELD (member))
1476 error ("invalid pointer to bit-field `%D'", member);
1477 return error_mark_node;
1480 /* A lot of this logic is now handled in lookup_member. */
1481 if (BASELINK_P (member))
1483 /* Go from the TREE_BASELINK to the member function info. */
1484 tree fnfields = member;
1485 tree t = BASELINK_FUNCTIONS (fnfields);
1487 if (TREE_CODE (orig_name) == TEMPLATE_ID_EXPR)
1489 /* The FNFIELDS are going to contain functions that aren't
1490 necessarily templates, and templates that don't
1491 necessarily match the explicit template parameters. We
1492 save all the functions, and the explicit parameters, and
1493 then figure out exactly what to instantiate with what
1494 arguments in instantiate_type. */
1496 if (TREE_CODE (t) != OVERLOAD)
1497 /* The code in instantiate_type which will process this
1498 expects to encounter OVERLOADs, not raw functions. */
1499 t = ovl_cons (t, NULL_TREE);
1501 t = build (TEMPLATE_ID_EXPR, TREE_TYPE (t), t,
1502 TREE_OPERAND (orig_name, 1));
1503 t = build (OFFSET_REF, unknown_type_node, decl, t);
1505 PTRMEM_OK_P (t) = 1;
1510 if (TREE_CODE (t) != TEMPLATE_ID_EXPR && !really_overloaded_fn (t))
1512 /* Get rid of a potential OVERLOAD around it. */
1513 t = OVL_CURRENT (t);
1515 /* Unique functions are handled easily. */
1517 /* For non-static member of base class, we need a special rule
1518 for access checking [class.protected]:
1520 If the access is to form a pointer to member, the
1521 nested-name-specifier shall name the derived class
1522 (or any class derived from that class). */
1523 if (address_p && DECL_P (t)
1524 && DECL_NONSTATIC_MEMBER_P (t))
1525 perform_or_defer_access_check (TYPE_BINFO (type), t);
1527 perform_or_defer_access_check (basebinfo, t);
1530 if (DECL_STATIC_FUNCTION_P (t))
1536 TREE_TYPE (fnfields) = unknown_type_node;
1540 else if (address_p && TREE_CODE (member) == FIELD_DECL)
1541 /* We need additional test besides the one in
1542 check_accessibility_of_qualified_id in case it is
1543 a pointer to non-static member. */
1544 perform_or_defer_access_check (TYPE_BINFO (type), member);
1548 /* If MEMBER is non-static, then the program has fallen afoul of
1551 An id-expression that denotes a nonstatic data member or
1552 nonstatic member function of a class can only be used:
1554 -- as part of a class member access (_expr.ref_) in which the
1555 object-expression refers to the member's class or a class
1556 derived from that class, or
1558 -- to form a pointer to member (_expr.unary.op_), or
1560 -- in the body of a nonstatic member function of that class or
1561 of a class derived from that class (_class.mfct.nonstatic_), or
1563 -- in a mem-initializer for a constructor for that class or for
1564 a class derived from that class (_class.base.init_). */
1565 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member))
1567 /* Build a representation of a the qualified name suitable
1568 for use as the operand to "&" -- even though the "&" is
1569 not actually present. */
1570 member = build (OFFSET_REF, TREE_TYPE (member), decl, member);
1571 /* In Microsoft mode, treat a non-static member function as if
1572 it were a pointer-to-member. */
1573 if (flag_ms_extensions)
1575 PTRMEM_OK_P (member) = 1;
1576 return build_unary_op (ADDR_EXPR, member, 0);
1578 error ("invalid use of non-static member function `%D'",
1579 TREE_OPERAND (member, 1));
1582 else if (TREE_CODE (member) == FIELD_DECL)
1584 error ("invalid use of non-static data member `%D'", member);
1585 return error_mark_node;
1590 /* In member functions, the form `type::name' is no longer
1591 equivalent to `this->type::name', at least not until
1592 resolve_offset_ref. */
1593 member = build (OFFSET_REF, TREE_TYPE (member), decl, member);
1594 PTRMEM_OK_P (member) = 1;
1598 /* If DECL is a `const' declaration, and its value is a known
1599 constant, then return that value. */
1602 decl_constant_value (tree decl)
1604 /* When we build a COND_EXPR, we don't know whether it will be used
1605 as an lvalue or as an rvalue. If it is an lvalue, it's not safe
1606 to replace the second and third operands with their
1607 initializers. So, we do that here. */
1608 if (TREE_CODE (decl) == COND_EXPR)
1613 d1 = decl_constant_value (TREE_OPERAND (decl, 1));
1614 d2 = decl_constant_value (TREE_OPERAND (decl, 2));
1616 if (d1 != TREE_OPERAND (decl, 1) || d2 != TREE_OPERAND (decl, 2))
1617 return build (COND_EXPR,
1619 TREE_OPERAND (decl, 0), d1, d2);
1623 && (/* Enumeration constants are constant. */
1624 TREE_CODE (decl) == CONST_DECL
1625 /* And so are variables with a 'const' type -- unless they
1626 are also 'volatile'. */
1627 || CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl)))
1628 && TREE_CODE (decl) != PARM_DECL
1629 && DECL_INITIAL (decl)
1630 && DECL_INITIAL (decl) != error_mark_node
1631 /* This is invalid if initial value is not constant.
1632 If it has either a function call, a memory reference,
1633 or a variable, then re-evaluating it could give different results. */
1634 && TREE_CONSTANT (DECL_INITIAL (decl))
1635 /* Check for cases where this is sub-optimal, even though valid. */
1636 && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
1637 return DECL_INITIAL (decl);
1641 /* Common subroutines of build_new and build_vec_delete. */
1643 /* Call the global __builtin_delete to delete ADDR. */
1646 build_builtin_delete_call (tree addr)
1648 mark_used (global_delete_fndecl);
1649 return build_call (global_delete_fndecl, build_tree_list (NULL_TREE, addr));
1652 /* Generate a C++ "new" expression. DECL is either a TREE_LIST
1653 (which needs to go through some sort of groktypename) or it
1654 is the name of the class we are newing. INIT is an initialization value.
1655 It is either an EXPRLIST, an EXPR_NO_COMMAS, or something in braces.
1656 If INIT is void_type_node, it means do *not* call a constructor
1659 For types with constructors, the data returned is initialized
1660 by the appropriate constructor.
1662 Whether the type has a constructor or not, if it has a pointer
1663 to a virtual function table, then that pointer is set up
1666 Unless I am mistaken, a call to new () will return initialized
1667 data regardless of whether the constructor itself is private or
1668 not. NOPE; new fails if the constructor is private (jcm).
1670 Note that build_new does nothing to assure that any special
1671 alignment requirements of the type are met. Rather, it leaves
1672 it up to malloc to do the right thing. Otherwise, folding to
1673 the right alignment cal cause problems if the user tries to later
1674 free the memory returned by `new'.
1676 PLACEMENT is the `placement' list for user-defined operator new (). */
1679 build_new (tree placement, tree decl, tree init, int use_global_new)
1682 tree nelts = NULL_TREE, t;
1685 if (decl == error_mark_node)
1686 return error_mark_node;
1688 if (TREE_CODE (decl) == TREE_LIST)
1690 tree absdcl = TREE_VALUE (decl);
1691 tree last_absdcl = NULL_TREE;
1693 if (current_function_decl
1694 && DECL_CONSTRUCTOR_P (current_function_decl))
1695 my_friendly_assert (immediate_size_expand == 0, 19990926);
1697 nelts = integer_one_node;
1699 if (absdcl && TREE_CODE (absdcl) == CALL_EXPR)
1701 while (absdcl && TREE_CODE (absdcl) == INDIRECT_REF)
1703 last_absdcl = absdcl;
1704 absdcl = TREE_OPERAND (absdcl, 0);
1707 if (absdcl && TREE_CODE (absdcl) == ARRAY_REF)
1709 /* Probably meant to be a vec new. */
1712 while (TREE_OPERAND (absdcl, 0)
1713 && TREE_CODE (TREE_OPERAND (absdcl, 0)) == ARRAY_REF)
1715 last_absdcl = absdcl;
1716 absdcl = TREE_OPERAND (absdcl, 0);
1720 this_nelts = TREE_OPERAND (absdcl, 1);
1721 if (this_nelts != error_mark_node)
1723 if (this_nelts == NULL_TREE)
1724 error ("new of array type fails to specify size");
1725 else if (processing_template_decl)
1728 absdcl = TREE_OPERAND (absdcl, 0);
1732 if (build_expr_type_conversion (WANT_INT | WANT_ENUM,
1735 pedwarn ("size in array new must have integral type");
1737 this_nelts = save_expr (cp_convert (sizetype, this_nelts));
1738 absdcl = TREE_OPERAND (absdcl, 0);
1739 if (this_nelts == integer_zero_node)
1741 warning ("zero size array reserves no space");
1742 nelts = integer_zero_node;
1745 nelts = cp_build_binary_op (MULT_EXPR, nelts, this_nelts);
1749 nelts = integer_zero_node;
1753 TREE_OPERAND (last_absdcl, 0) = absdcl;
1755 TREE_VALUE (decl) = absdcl;
1757 type = groktypename (decl);
1758 if (! type || type == error_mark_node)
1759 return error_mark_node;
1761 else if (TREE_CODE (decl) == IDENTIFIER_NODE)
1763 if (IDENTIFIER_HAS_TYPE_VALUE (decl))
1765 /* An aggregate type. */
1766 type = IDENTIFIER_TYPE_VALUE (decl);
1767 decl = TYPE_MAIN_DECL (type);
1771 /* A builtin type. */
1772 decl = lookup_name (decl, 1);
1773 my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 215);
1774 type = TREE_TYPE (decl);
1777 else if (TREE_CODE (decl) == TYPE_DECL)
1779 type = TREE_TYPE (decl);
1784 decl = TYPE_MAIN_DECL (type);
1787 if (processing_template_decl)
1790 t = tree_cons (tree_cons (NULL_TREE, type, NULL_TREE),
1791 build_min_nt (ARRAY_REF, NULL_TREE, nelts),
1796 rval = build_min (NEW_EXPR, build_pointer_type (type),
1797 placement, t, init);
1798 NEW_EXPR_USE_GLOBAL (rval) = use_global_new;
1799 TREE_SIDE_EFFECTS (rval) = 1;
1803 /* ``A reference cannot be created by the new operator. A reference
1804 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
1805 returned by new.'' ARM 5.3.3 */
1806 if (TREE_CODE (type) == REFERENCE_TYPE)
1808 error ("new cannot be applied to a reference type");
1809 type = TREE_TYPE (type);
1812 if (TREE_CODE (type) == FUNCTION_TYPE)
1814 error ("new cannot be applied to a function type");
1815 return error_mark_node;
1818 /* When the object being created is an array, the new-expression yields a
1819 pointer to the initial element (if any) of the array. For example,
1820 both new int and new int[10] return an int*. 5.3.4. */
1821 if (TREE_CODE (type) == ARRAY_TYPE && has_array == 0)
1823 nelts = array_type_nelts_top (type);
1825 type = TREE_TYPE (type);
1829 t = build_nt (ARRAY_REF, type, nelts);
1833 rval = build (NEW_EXPR, build_pointer_type (type), placement, t, init);
1834 NEW_EXPR_USE_GLOBAL (rval) = use_global_new;
1835 TREE_SIDE_EFFECTS (rval) = 1;
1836 rval = build_new_1 (rval);
1837 if (rval == error_mark_node)
1838 return error_mark_node;
1840 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
1841 rval = build1 (NOP_EXPR, TREE_TYPE (rval), rval);
1842 TREE_NO_WARNING (rval) = 1;
1847 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
1850 build_java_class_ref (tree type)
1852 tree name = NULL_TREE, class_decl;
1853 static tree CL_suffix = NULL_TREE;
1854 if (CL_suffix == NULL_TREE)
1855 CL_suffix = get_identifier("class$");
1856 if (jclass_node == NULL_TREE)
1858 jclass_node = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
1859 if (jclass_node == NULL_TREE)
1860 fatal_error ("call to Java constructor, while `jclass' undefined");
1862 jclass_node = TREE_TYPE (jclass_node);
1865 /* Mangle the class$ field. */
1868 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1869 if (DECL_NAME (field) == CL_suffix)
1871 mangle_decl (field);
1872 name = DECL_ASSEMBLER_NAME (field);
1876 internal_error ("can't find class$");
1879 class_decl = IDENTIFIER_GLOBAL_VALUE (name);
1880 if (class_decl == NULL_TREE)
1882 class_decl = build_decl (VAR_DECL, name, TREE_TYPE (jclass_node));
1883 TREE_STATIC (class_decl) = 1;
1884 DECL_EXTERNAL (class_decl) = 1;
1885 TREE_PUBLIC (class_decl) = 1;
1886 DECL_ARTIFICIAL (class_decl) = 1;
1887 DECL_IGNORED_P (class_decl) = 1;
1888 pushdecl_top_level (class_decl);
1889 make_decl_rtl (class_decl, NULL);
1894 /* Returns the size of the cookie to use when allocating an array
1895 whose elements have the indicated TYPE. Assumes that it is already
1896 known that a cookie is needed. */
1899 get_cookie_size (tree type)
1903 /* We need to allocate an additional max (sizeof (size_t), alignof
1904 (true_type)) bytes. */
1908 sizetype_size = size_in_bytes (sizetype);
1909 type_align = size_int (TYPE_ALIGN_UNIT (type));
1910 if (INT_CST_LT_UNSIGNED (type_align, sizetype_size))
1911 cookie_size = sizetype_size;
1913 cookie_size = type_align;
1918 /* Called from cplus_expand_expr when expanding a NEW_EXPR. The return
1919 value is immediately handed to expand_expr. */
1922 build_new_1 (tree exp)
1924 tree placement, init;
1925 tree true_type, size, rval;
1926 /* The type of the new-expression. (This type is always a pointer
1929 /* The type pointed to by POINTER_TYPE. */
1931 /* The type being allocated. For "new T[...]" this will be an
1934 /* A pointer type pointing to to the FULL_TYPE. */
1935 tree full_pointer_type;
1936 tree outer_nelts = NULL_TREE;
1937 tree nelts = NULL_TREE;
1938 tree alloc_call, alloc_expr;
1939 /* The address returned by the call to "operator new". This node is
1940 a VAR_DECL and is therefore reusable. */
1943 tree cookie_expr, init_expr;
1945 enum tree_code code;
1946 int nothrow, check_new;
1947 /* Nonzero if the user wrote `::new' rather than just `new'. */
1948 int globally_qualified_p;
1949 int use_java_new = 0;
1950 /* If non-NULL, the number of extra bytes to allocate at the
1951 beginning of the storage allocated for an array-new expression in
1952 order to store the number of elements. */
1953 tree cookie_size = NULL_TREE;
1954 /* True if the function we are calling is a placement allocation
1956 bool placement_allocation_fn_p;
1957 tree args = NULL_TREE;
1958 /* True if the storage must be initialized, either by a constructor
1959 or due to an explicit new-initializer. */
1960 bool is_initialized;
1961 /* The address of the thing allocated, not including any cookie. In
1962 particular, if an array cookie is in use, DATA_ADDR is the
1963 address of the first array element. This node is a VAR_DECL, and
1964 is therefore reusable. */
1966 tree init_preeval_expr = NULL_TREE;
1968 placement = TREE_OPERAND (exp, 0);
1969 type = TREE_OPERAND (exp, 1);
1970 init = TREE_OPERAND (exp, 2);
1971 globally_qualified_p = NEW_EXPR_USE_GLOBAL (exp);
1973 if (TREE_CODE (type) == ARRAY_REF)
1976 nelts = outer_nelts = TREE_OPERAND (type, 1);
1977 type = TREE_OPERAND (type, 0);
1979 /* Use an incomplete array type to avoid VLA headaches. */
1980 full_type = build_cplus_array_type (type, NULL_TREE);
1987 code = has_array ? VEC_NEW_EXPR : NEW_EXPR;
1989 /* If our base type is an array, then make sure we know how many elements
1991 while (TREE_CODE (true_type) == ARRAY_TYPE)
1993 tree this_nelts = array_type_nelts_top (true_type);
1994 nelts = cp_build_binary_op (MULT_EXPR, nelts, this_nelts);
1995 true_type = TREE_TYPE (true_type);
1998 if (!complete_type_or_else (true_type, exp))
1999 return error_mark_node;
2001 if (TREE_CODE (true_type) == VOID_TYPE)
2003 error ("invalid type `void' for new");
2004 return error_mark_node;
2007 if (abstract_virtuals_error (NULL_TREE, true_type))
2008 return error_mark_node;
2010 is_initialized = (TYPE_NEEDS_CONSTRUCTING (type) || init);
2011 if (CP_TYPE_CONST_P (true_type) && !is_initialized)
2013 error ("uninitialized const in `new' of `%#T'", true_type);
2014 return error_mark_node;
2017 size = size_in_bytes (true_type);
2019 size = size_binop (MULT_EXPR, size, convert (sizetype, nelts));
2021 /* Allocate the object. */
2022 if (! placement && TYPE_FOR_JAVA (true_type))
2024 tree class_addr, alloc_decl;
2025 tree class_decl = build_java_class_ref (true_type);
2026 static const char alloc_name[] = "_Jv_AllocObject";
2030 if (!get_global_value_if_present (get_identifier (alloc_name),
2033 error ("call to Java constructor with `%s' undefined", alloc_name);
2034 return error_mark_node;
2036 else if (really_overloaded_fn (alloc_decl))
2038 error ("`%D' should never be overloaded", alloc_decl);
2039 return error_mark_node;
2041 alloc_decl = OVL_CURRENT (alloc_decl);
2042 class_addr = build1 (ADDR_EXPR, jclass_node, class_decl);
2043 alloc_call = (build_function_call
2045 build_tree_list (NULL_TREE, class_addr)));
2052 fnname = ansi_opname (code);
2054 if (!globally_qualified_p
2055 && CLASS_TYPE_P (true_type)
2057 ? TYPE_HAS_ARRAY_NEW_OPERATOR (true_type)
2058 : TYPE_HAS_NEW_OPERATOR (true_type)))
2060 /* Use a class-specific operator new. */
2061 /* If a cookie is required, add some extra space. */
2062 if (has_array && TYPE_VEC_NEW_USES_COOKIE (true_type))
2064 cookie_size = get_cookie_size (true_type);
2065 size = size_binop (PLUS_EXPR, size, cookie_size);
2067 /* Create the argument list. */
2068 args = tree_cons (NULL_TREE, size, placement);
2069 /* Do name-lookup to find the appropriate operator. */
2070 fns = lookup_fnfields (true_type, fnname, /*protect=*/2);
2071 if (TREE_CODE (fns) == TREE_LIST)
2073 error ("request for member `%D' is ambiguous", fnname);
2074 print_candidates (fns);
2075 return error_mark_node;
2077 alloc_call = build_new_method_call (build_dummy_object (true_type),
2079 /*conversion_path=*/NULL_TREE,
2084 /* Use a global operator new. */
2085 /* See if a cookie might be required. */
2086 if (has_array && TYPE_VEC_NEW_USES_COOKIE (true_type))
2087 cookie_size = get_cookie_size (true_type);
2089 cookie_size = NULL_TREE;
2091 alloc_call = build_operator_new_call (fnname, placement,
2092 &size, &cookie_size);
2096 if (alloc_call == error_mark_node)
2097 return error_mark_node;
2099 /* In the simple case, we can stop now. */
2100 pointer_type = build_pointer_type (type);
2101 if (!cookie_size && !is_initialized)
2102 return build_nop (pointer_type, alloc_call);
2104 /* While we're working, use a pointer to the type we've actually
2105 allocated. Store the result of the call in a variable so that we
2106 can use it more than once. */
2107 full_pointer_type = build_pointer_type (full_type);
2108 alloc_expr = get_target_expr (build_nop (full_pointer_type, alloc_call));
2109 alloc_node = TARGET_EXPR_SLOT (alloc_expr);
2111 /* Strip any COMPOUND_EXPRs from ALLOC_CALL. */
2112 while (TREE_CODE (alloc_call) == COMPOUND_EXPR)
2113 alloc_call = TREE_OPERAND (alloc_call, 1);
2114 alloc_fn = get_callee_fndecl (alloc_call);
2115 my_friendly_assert (alloc_fn != NULL_TREE, 20020325);
2117 /* Now, check to see if this function is actually a placement
2118 allocation function. This can happen even when PLACEMENT is NULL
2119 because we might have something like:
2121 struct S { void* operator new (size_t, int i = 0); };
2123 A call to `new S' will get this allocation function, even though
2124 there is no explicit placement argument. If there is more than
2125 one argument, or there are variable arguments, then this is a
2126 placement allocation function. */
2127 placement_allocation_fn_p
2128 = (type_num_arguments (TREE_TYPE (alloc_fn)) > 1
2129 || varargs_function_p (alloc_fn));
2131 /* Preevaluate the placement args so that we don't reevaluate them for a
2132 placement delete. */
2133 if (placement_allocation_fn_p)
2136 stabilize_call (alloc_call, &inits);
2138 alloc_expr = build (COMPOUND_EXPR, TREE_TYPE (alloc_expr), inits,
2142 /* unless an allocation function is declared with an empty excep-
2143 tion-specification (_except.spec_), throw(), it indicates failure to
2144 allocate storage by throwing a bad_alloc exception (clause _except_,
2145 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2146 cation function is declared with an empty exception-specification,
2147 throw(), it returns null to indicate failure to allocate storage and a
2148 non-null pointer otherwise.
2150 So check for a null exception spec on the op new we just called. */
2152 nothrow = TYPE_NOTHROW_P (TREE_TYPE (alloc_fn));
2153 check_new = (flag_check_new || nothrow) && ! use_java_new;
2159 /* Adjust so we're pointing to the start of the object. */
2160 data_addr = get_target_expr (build (PLUS_EXPR, full_pointer_type,
2161 alloc_node, cookie_size));
2163 /* Store the number of bytes allocated so that we can know how
2164 many elements to destroy later. We use the last sizeof
2165 (size_t) bytes to store the number of elements. */
2166 cookie = build (MINUS_EXPR, build_pointer_type (sizetype),
2167 data_addr, size_in_bytes (sizetype));
2168 cookie = build_indirect_ref (cookie, NULL);
2170 cookie_expr = build (MODIFY_EXPR, sizetype, cookie, nelts);
2171 data_addr = TARGET_EXPR_SLOT (data_addr);
2175 cookie_expr = NULL_TREE;
2176 data_addr = alloc_node;
2179 /* Now initialize the allocated object. Note that we preevaluate the
2180 initialization expression, apart from the actual constructor call or
2181 assignment--we do this because we want to delay the allocation as long
2182 as possible in order to minimize the size of the exception region for
2183 placement delete. */
2188 init_expr = build_indirect_ref (data_addr, NULL);
2190 if (init == void_zero_node)
2191 init = build_default_init (full_type, nelts);
2192 else if (init && has_array)
2193 pedwarn ("ISO C++ forbids initialization in array new");
2198 = build_vec_init (init_expr,
2199 cp_build_binary_op (MINUS_EXPR, outer_nelts,
2201 init, /*from_array=*/0);
2203 /* An array initialization is stable because the initialization
2204 of each element is a full-expression, so the temporaries don't
2208 else if (TYPE_NEEDS_CONSTRUCTING (type))
2210 init_expr = build_special_member_call (init_expr,
2211 complete_ctor_identifier,
2212 init, TYPE_BINFO (true_type),
2214 stable = stabilize_init (init_expr, &init_preeval_expr);
2218 /* We are processing something like `new int (10)', which
2219 means allocate an int, and initialize it with 10. */
2221 if (TREE_CODE (init) == TREE_LIST)
2222 init = build_x_compound_expr_from_list (init, "new initializer");
2224 else if (TREE_CODE (init) == CONSTRUCTOR
2225 && TREE_TYPE (init) == NULL_TREE)
2228 init_expr = build_modify_expr (init_expr, INIT_EXPR, init);
2229 stable = stabilize_init (init_expr, &init_preeval_expr);
2232 if (init_expr == error_mark_node)
2233 return error_mark_node;
2235 /* If any part of the object initialization terminates by throwing an
2236 exception and a suitable deallocation function can be found, the
2237 deallocation function is called to free the memory in which the
2238 object was being constructed, after which the exception continues
2239 to propagate in the context of the new-expression. If no
2240 unambiguous matching deallocation function can be found,
2241 propagating the exception does not cause the object's memory to be
2243 if (flag_exceptions && ! use_java_new)
2245 enum tree_code dcode = has_array ? VEC_DELETE_EXPR : DELETE_EXPR;
2248 /* The Standard is unclear here, but the right thing to do
2249 is to use the same method for finding deallocation
2250 functions that we use for finding allocation functions. */
2251 cleanup = build_op_delete_call (dcode, alloc_node, size,
2252 globally_qualified_p,
2253 (placement_allocation_fn_p
2254 ? alloc_call : NULL_TREE));
2259 /* This is much simpler if we were able to preevaluate all of
2260 the arguments to the constructor call. */
2261 init_expr = build (TRY_CATCH_EXPR, void_type_node,
2262 init_expr, cleanup);
2264 /* Ack! First we allocate the memory. Then we set our sentry
2265 variable to true, and expand a cleanup that deletes the
2266 memory if sentry is true. Then we run the constructor, and
2267 finally clear the sentry.
2269 We need to do this because we allocate the space first, so
2270 if there are any temporaries with cleanups in the
2271 constructor args and we weren't able to preevaluate them, we
2272 need this EH region to extend until end of full-expression
2273 to preserve nesting. */
2275 tree end, sentry, begin;
2277 begin = get_target_expr (boolean_true_node);
2278 CLEANUP_EH_ONLY (begin) = 1;
2280 sentry = TARGET_EXPR_SLOT (begin);
2282 TARGET_EXPR_CLEANUP (begin)
2283 = build (COND_EXPR, void_type_node, sentry,
2284 cleanup, void_zero_node);
2286 end = build (MODIFY_EXPR, TREE_TYPE (sentry),
2287 sentry, boolean_false_node);
2290 = build (COMPOUND_EXPR, void_type_node, begin,
2291 build (COMPOUND_EXPR, void_type_node, init_expr,
2298 init_expr = NULL_TREE;
2300 /* Now build up the return value in reverse order. */
2305 rval = build (COMPOUND_EXPR, TREE_TYPE (rval), init_expr, rval);
2307 rval = build (COMPOUND_EXPR, TREE_TYPE (rval), cookie_expr, rval);
2309 if (rval == alloc_node)
2310 /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
2311 and return the call (which doesn't need to be adjusted). */
2312 rval = TARGET_EXPR_INITIAL (alloc_expr);
2317 tree ifexp = cp_build_binary_op (NE_EXPR, alloc_node,
2319 rval = build_conditional_expr (ifexp, rval, alloc_node);
2322 /* Perform the allocation before anything else, so that ALLOC_NODE
2323 has been initialized before we start using it. */
2324 rval = build (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
2327 if (init_preeval_expr)
2328 rval = build (COMPOUND_EXPR, TREE_TYPE (rval), init_preeval_expr, rval);
2330 /* Convert to the final type. */
2331 rval = build_nop (pointer_type, rval);
2333 /* A new-expression is never an lvalue. */
2334 if (real_lvalue_p (rval))
2335 rval = build1 (NON_LVALUE_EXPR, TREE_TYPE (rval), rval);
2341 build_vec_delete_1 (tree base, tree maxindex, tree type,
2342 special_function_kind auto_delete_vec, int use_global_delete)
2345 tree ptype = build_pointer_type (type = complete_type (type));
2346 tree size_exp = size_in_bytes (type);
2348 /* Temporary variables used by the loop. */
2349 tree tbase, tbase_init;
2351 /* This is the body of the loop that implements the deletion of a
2352 single element, and moves temp variables to next elements. */
2355 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2358 /* This is the thing that governs what to do after the loop has run. */
2359 tree deallocate_expr = 0;
2361 /* This is the BIND_EXPR which holds the outermost iterator of the
2362 loop. It is convenient to set this variable up and test it before
2363 executing any other code in the loop.
2364 This is also the containing expression returned by this function. */
2365 tree controller = NULL_TREE;
2367 /* We should only have 1-D arrays here. */
2368 if (TREE_CODE (type) == ARRAY_TYPE)
2371 if (! IS_AGGR_TYPE (type) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2374 /* The below is short by the cookie size. */
2375 virtual_size = size_binop (MULT_EXPR, size_exp,
2376 convert (sizetype, maxindex));
2378 tbase = create_temporary_var (ptype);
2379 tbase_init = build_modify_expr (tbase, NOP_EXPR,
2380 fold (build (PLUS_EXPR, ptype,
2383 DECL_REGISTER (tbase) = 1;
2384 controller = build (BIND_EXPR, void_type_node, tbase, NULL_TREE, NULL_TREE);
2385 TREE_SIDE_EFFECTS (controller) = 1;
2387 body = build (EXIT_EXPR, void_type_node,
2388 build (EQ_EXPR, boolean_type_node, base, tbase));
2389 body = build_compound_expr
2390 (body, build_modify_expr (tbase, NOP_EXPR,
2391 build (MINUS_EXPR, ptype, tbase, size_exp)));
2392 body = build_compound_expr
2393 (body, build_delete (ptype, tbase, sfk_complete_destructor,
2394 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1));
2396 loop = build (LOOP_EXPR, void_type_node, body);
2397 loop = build_compound_expr (tbase_init, loop);
2400 /* If the delete flag is one, or anything else with the low bit set,
2401 delete the storage. */
2402 if (auto_delete_vec != sfk_base_destructor)
2406 /* The below is short by the cookie size. */
2407 virtual_size = size_binop (MULT_EXPR, size_exp,
2408 convert (sizetype, maxindex));
2410 if (! TYPE_VEC_NEW_USES_COOKIE (type))
2417 cookie_size = get_cookie_size (type);
2419 = cp_convert (ptype,
2420 cp_build_binary_op (MINUS_EXPR,
2421 cp_convert (string_type_node,
2424 /* True size with header. */
2425 virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size);
2428 if (auto_delete_vec == sfk_deleting_destructor)
2429 deallocate_expr = build_x_delete (base_tbd,
2430 2 | use_global_delete,
2435 if (!deallocate_expr)
2438 body = deallocate_expr;
2440 body = build_compound_expr (body, deallocate_expr);
2443 body = integer_zero_node;
2445 /* Outermost wrapper: If pointer is null, punt. */
2446 body = fold (build (COND_EXPR, void_type_node,
2447 fold (build (NE_EXPR, boolean_type_node, base,
2448 convert (TREE_TYPE (base),
2449 integer_zero_node))),
2450 body, integer_zero_node));
2451 body = build1 (NOP_EXPR, void_type_node, body);
2455 TREE_OPERAND (controller, 1) = body;
2459 if (TREE_CODE (base) == SAVE_EXPR)
2460 /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */
2461 body = build (COMPOUND_EXPR, void_type_node, base, body);
2463 return convert_to_void (body, /*implicit=*/NULL);
2466 /* Create an unnamed variable of the indicated TYPE. */
2469 create_temporary_var (tree type)
2473 decl = build_decl (VAR_DECL, NULL_TREE, type);
2474 TREE_USED (decl) = 1;
2475 DECL_ARTIFICIAL (decl) = 1;
2476 DECL_SOURCE_LOCATION (decl) = input_location;
2477 DECL_IGNORED_P (decl) = 1;
2478 DECL_CONTEXT (decl) = current_function_decl;
2483 /* Create a new temporary variable of the indicated TYPE, initialized
2486 It is not entered into current_binding_level, because that breaks
2487 things when it comes time to do final cleanups (which take place
2488 "outside" the binding contour of the function). */
2491 get_temp_regvar (tree type, tree init)
2495 decl = create_temporary_var (type);
2496 add_decl_stmt (decl);
2498 finish_expr_stmt (build_modify_expr (decl, INIT_EXPR, init));
2503 /* `build_vec_init' returns tree structure that performs
2504 initialization of a vector of aggregate types.
2506 BASE is a reference to the vector, of ARRAY_TYPE.
2507 MAXINDEX is the maximum index of the array (one less than the
2508 number of elements). It is only used if
2509 TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
2510 INIT is the (possibly NULL) initializer.
2512 FROM_ARRAY is 0 if we should init everything with INIT
2513 (i.e., every element initialized from INIT).
2514 FROM_ARRAY is 1 if we should index into INIT in parallel
2515 with initialization of DECL.
2516 FROM_ARRAY is 2 if we should index into INIT in parallel,
2517 but use assignment instead of initialization. */
2520 build_vec_init (tree base, tree maxindex, tree init, int from_array)
2523 tree base2 = NULL_TREE;
2525 tree itype = NULL_TREE;
2527 /* The type of the array. */
2528 tree atype = TREE_TYPE (base);
2529 /* The type of an element in the array. */
2530 tree type = TREE_TYPE (atype);
2531 /* The type of a pointer to an element in the array. */
2536 tree try_block = NULL_TREE;
2537 tree try_body = NULL_TREE;
2538 int num_initialized_elts = 0;
2541 if (TYPE_DOMAIN (atype))
2542 maxindex = array_type_nelts (atype);
2544 if (maxindex == NULL_TREE || maxindex == error_mark_node)
2545 return error_mark_node;
2549 ? (!CLASS_TYPE_P (type) || !TYPE_HAS_COMPLEX_ASSIGN_REF (type))
2550 : !TYPE_NEEDS_CONSTRUCTING (type))
2551 && ((TREE_CODE (init) == CONSTRUCTOR
2552 /* Don't do this if the CONSTRUCTOR might contain something
2553 that might throw and require us to clean up. */
2554 && (CONSTRUCTOR_ELTS (init) == NULL_TREE
2555 || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (target_type (type))))
2558 /* Do non-default initialization of POD arrays resulting from
2559 brace-enclosed initializers. In this case, digest_init and
2560 store_constructor will handle the semantics for us. */
2562 stmt_expr = build (INIT_EXPR, atype, base, init);
2566 maxindex = cp_convert (ptrdiff_type_node, maxindex);
2567 ptype = build_pointer_type (type);
2568 size = size_in_bytes (type);
2569 if (TREE_CODE (TREE_TYPE (base)) == ARRAY_TYPE)
2570 base = cp_convert (ptype, decay_conversion (base));
2572 /* The code we are generating looks like:
2576 ptrdiff_t iterator = maxindex;
2578 for (; iterator != -1; --iterator) {
2579 ... initialize *t1 ...
2583 ... destroy elements that were constructed ...
2588 We can omit the try and catch blocks if we know that the
2589 initialization will never throw an exception, or if the array
2590 elements do not have destructors. We can omit the loop completely if
2591 the elements of the array do not have constructors.
2593 We actually wrap the entire body of the above in a STMT_EXPR, for
2596 When copying from array to another, when the array elements have
2597 only trivial copy constructors, we should use __builtin_memcpy
2598 rather than generating a loop. That way, we could take advantage
2599 of whatever cleverness the back-end has for dealing with copies
2600 of blocks of memory. */
2602 is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
2603 destroy_temps = stmts_are_full_exprs_p ();
2604 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2605 rval = get_temp_regvar (ptype, base);
2606 base = get_temp_regvar (ptype, rval);
2607 iterator = get_temp_regvar (ptrdiff_type_node, maxindex);
2609 /* Protect the entire array initialization so that we can destroy
2610 the partially constructed array if an exception is thrown.
2611 But don't do this if we're assigning. */
2612 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2615 try_block = begin_try_block ();
2616 try_body = begin_compound_stmt (/*has_no_scope=*/true);
2619 if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR)
2621 /* Do non-default initialization of non-POD arrays resulting from
2622 brace-enclosed initializers. */
2627 for (elts = CONSTRUCTOR_ELTS (init); elts; elts = TREE_CHAIN (elts))
2629 tree elt = TREE_VALUE (elts);
2630 tree baseref = build1 (INDIRECT_REF, type, base);
2632 num_initialized_elts++;
2634 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
2635 if (IS_AGGR_TYPE (type) || TREE_CODE (type) == ARRAY_TYPE)
2636 finish_expr_stmt (build_aggr_init (baseref, elt, 0));
2638 finish_expr_stmt (build_modify_expr (baseref, NOP_EXPR,
2640 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2642 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base, 0));
2643 finish_expr_stmt (build_unary_op (PREDECREMENT_EXPR, iterator, 0));
2646 /* Clear out INIT so that we don't get confused below. */
2649 else if (from_array)
2651 /* If initializing one array from another, initialize element by
2652 element. We rely upon the below calls the do argument
2656 base2 = decay_conversion (init);
2657 itype = TREE_TYPE (base2);
2658 base2 = get_temp_regvar (itype, base2);
2659 itype = TREE_TYPE (itype);
2661 else if (TYPE_LANG_SPECIFIC (type)
2662 && TYPE_NEEDS_CONSTRUCTING (type)
2663 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
2665 error ("initializer ends prematurely");
2666 return error_mark_node;
2670 /* Now, default-initialize any remaining elements. We don't need to
2671 do that if a) the type does not need constructing, or b) we've
2672 already initialized all the elements.
2674 We do need to keep going if we're copying an array. */
2677 || (TYPE_NEEDS_CONSTRUCTING (type)
2678 && ! (host_integerp (maxindex, 0)
2679 && (num_initialized_elts
2680 == tree_low_cst (maxindex, 0) + 1))))
2682 /* If the ITERATOR is equal to -1, then we don't have to loop;
2683 we've already initialized all the elements. */
2688 for_stmt = begin_for_stmt ();
2689 finish_for_init_stmt (for_stmt);
2690 finish_for_cond (build (NE_EXPR, boolean_type_node,
2691 iterator, integer_minus_one_node),
2693 finish_for_expr (build_unary_op (PREDECREMENT_EXPR, iterator, 0),
2696 /* Otherwise, loop through the elements. */
2697 for_body = begin_compound_stmt (/*has_no_scope=*/true);
2701 tree to = build1 (INDIRECT_REF, type, base);
2705 from = build1 (INDIRECT_REF, itype, base2);
2709 if (from_array == 2)
2710 elt_init = build_modify_expr (to, NOP_EXPR, from);
2711 else if (TYPE_NEEDS_CONSTRUCTING (type))
2712 elt_init = build_aggr_init (to, from, 0);
2714 elt_init = build_modify_expr (to, NOP_EXPR, from);
2718 else if (TREE_CODE (type) == ARRAY_TYPE)
2722 ("cannot initialize multi-dimensional array with initializer");
2723 elt_init = build_vec_init (build1 (INDIRECT_REF, type, base),
2727 elt_init = build_aggr_init (build1 (INDIRECT_REF, type, base),
2730 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
2731 finish_expr_stmt (elt_init);
2732 current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2734 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base, 0));
2736 finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base2, 0));
2738 finish_compound_stmt (for_body);
2739 finish_for_stmt (for_stmt);
2742 /* Make sure to cleanup any partially constructed elements. */
2743 if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2747 tree m = cp_build_binary_op (MINUS_EXPR, maxindex, iterator);
2749 /* Flatten multi-dimensional array since build_vec_delete only
2750 expects one-dimensional array. */
2751 if (TREE_CODE (type) == ARRAY_TYPE)
2753 m = cp_build_binary_op (MULT_EXPR, m,
2754 array_type_nelts_total (type));
2755 type = strip_array_types (type);
2758 finish_compound_stmt (try_body);
2759 finish_cleanup_try_block (try_block);
2760 e = build_vec_delete_1 (rval, m, type, sfk_base_destructor,
2761 /*use_global_delete=*/0);
2762 finish_cleanup (e, try_block);
2765 /* The value of the array initialization is the array itself, RVAL
2766 is a pointer to the first element. */
2767 finish_stmt_expr_expr (rval);
2769 stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
2771 /* Now convert make the result have the correct type. */
2772 atype = build_pointer_type (atype);
2773 stmt_expr = build1 (NOP_EXPR, atype, stmt_expr);
2774 stmt_expr = build_indirect_ref (stmt_expr, NULL);
2776 current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
2780 /* Free up storage of type TYPE, at address ADDR.
2782 TYPE is a POINTER_TYPE and can be ptr_type_node for no special type
2785 VIRTUAL_SIZE is the amount of storage that was allocated, and is
2786 used as the second argument to operator delete. It can include
2787 things like padding and magic size cookies. It has virtual in it,
2788 because if you have a base pointer and you delete through a virtual
2789 destructor, it should be the size of the dynamic object, not the
2790 static object, see Free Store 12.5 ISO C++.
2792 This does not call any destructors. */
2795 build_x_delete (tree addr, int which_delete, tree virtual_size)
2797 int use_global_delete = which_delete & 1;
2798 int use_vec_delete = !!(which_delete & 2);
2799 enum tree_code code = use_vec_delete ? VEC_DELETE_EXPR : DELETE_EXPR;
2801 return build_op_delete_call (code, addr, virtual_size, use_global_delete,
2805 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
2809 build_dtor_call (tree exp, special_function_kind dtor_kind, int flags)
2815 case sfk_complete_destructor:
2816 name = complete_dtor_identifier;
2819 case sfk_base_destructor:
2820 name = base_dtor_identifier;
2823 case sfk_deleting_destructor:
2824 name = deleting_dtor_identifier;
2831 exp = convert_from_reference (exp);
2832 fn = lookup_fnfields (TREE_TYPE (exp), name, /*protect=*/2);
2833 return build_new_method_call (exp, fn,
2835 /*conversion_path=*/NULL_TREE,
2839 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
2840 ADDR is an expression which yields the store to be destroyed.
2841 AUTO_DELETE is the name of the destructor to call, i.e., either
2842 sfk_complete_destructor, sfk_base_destructor, or
2843 sfk_deleting_destructor.
2845 FLAGS is the logical disjunction of zero or more LOOKUP_
2846 flags. See cp-tree.h for more info. */
2849 build_delete (tree type, tree addr, special_function_kind auto_delete,
2850 int flags, int use_global_delete)
2854 if (addr == error_mark_node)
2855 return error_mark_node;
2857 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
2858 set to `error_mark_node' before it gets properly cleaned up. */
2859 if (type == error_mark_node)
2860 return error_mark_node;
2862 type = TYPE_MAIN_VARIANT (type);
2864 if (TREE_CODE (type) == POINTER_TYPE)
2866 bool complete_p = true;
2868 type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
2869 if (TREE_CODE (type) == ARRAY_TYPE)
2872 /* We don't want to warn about delete of void*, only other
2873 incomplete types. Deleting other incomplete types
2874 invokes undefined behavior, but it is not ill-formed, so
2875 compile to something that would even do The Right Thing
2876 (TM) should the type have a trivial dtor and no delete
2878 if (!VOID_TYPE_P (type))
2880 complete_type (type);
2881 if (!COMPLETE_TYPE_P (type))
2883 warning ("possible problem detected in invocation of "
2884 "delete operator:");
2885 cxx_incomplete_type_diagnostic (addr, type, 1);
2886 inform ("neither the destructor nor the class-specific "
\r
2887 "operator delete will be called, even if they are "
\r
2888 "declared when the class is defined.");
2892 if (VOID_TYPE_P (type) || !complete_p || !IS_AGGR_TYPE (type))
2893 /* Call the builtin operator delete. */
2894 return build_builtin_delete_call (addr);
2895 if (TREE_SIDE_EFFECTS (addr))
2896 addr = save_expr (addr);
2898 /* Throw away const and volatile on target type of addr. */
2899 addr = convert_force (build_pointer_type (type), addr, 0);
2901 else if (TREE_CODE (type) == ARRAY_TYPE)
2905 if (TYPE_DOMAIN (type) == NULL_TREE)
2907 error ("unknown array size in delete");
2908 return error_mark_node;
2910 return build_vec_delete (addr, array_type_nelts (type),
2911 auto_delete, use_global_delete);
2915 /* Don't check PROTECT here; leave that decision to the
2916 destructor. If the destructor is accessible, call it,
2917 else report error. */
2918 addr = build_unary_op (ADDR_EXPR, addr, 0);
2919 if (TREE_SIDE_EFFECTS (addr))
2920 addr = save_expr (addr);
2922 addr = convert_force (build_pointer_type (type), addr, 0);
2925 my_friendly_assert (IS_AGGR_TYPE (type), 220);
2927 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2929 if (auto_delete != sfk_deleting_destructor)
2930 return void_zero_node;
2932 return build_op_delete_call
2933 (DELETE_EXPR, addr, cxx_sizeof_nowarn (type), use_global_delete,
2938 tree do_delete = NULL_TREE;
2941 my_friendly_assert (TYPE_HAS_DESTRUCTOR (type), 20011213);
2943 /* For `::delete x', we must not use the deleting destructor
2944 since then we would not be sure to get the global `operator
2946 if (use_global_delete && auto_delete == sfk_deleting_destructor)
2948 /* We will use ADDR multiple times so we must save it. */
2949 addr = save_expr (addr);
2950 /* Delete the object. */
2951 do_delete = build_builtin_delete_call (addr);
2952 /* Otherwise, treat this like a complete object destructor
2954 auto_delete = sfk_complete_destructor;
2956 /* If the destructor is non-virtual, there is no deleting
2957 variant. Instead, we must explicitly call the appropriate
2958 `operator delete' here. */
2959 else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type))
2960 && auto_delete == sfk_deleting_destructor)
2962 /* We will use ADDR multiple times so we must save it. */
2963 addr = save_expr (addr);
2964 /* Build the call. */
2965 do_delete = build_op_delete_call (DELETE_EXPR,
2967 cxx_sizeof_nowarn (type),
2970 /* Call the complete object destructor. */
2971 auto_delete = sfk_complete_destructor;
2973 else if (auto_delete == sfk_deleting_destructor
2974 && TYPE_GETS_REG_DELETE (type))
2976 /* Make sure we have access to the member op delete, even though
2977 we'll actually be calling it from the destructor. */
2978 build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
2979 /*global_p=*/false, NULL_TREE);
2982 expr = build_dtor_call (build_indirect_ref (addr, NULL),
2983 auto_delete, flags);
2985 expr = build (COMPOUND_EXPR, void_type_node, expr, do_delete);
2987 if (flags & LOOKUP_DESTRUCTOR)
2988 /* Explicit destructor call; don't check for null pointer. */
2989 ifexp = integer_one_node;
2991 /* Handle deleting a null pointer. */
2992 ifexp = fold (cp_build_binary_op (NE_EXPR, addr, integer_zero_node));
2994 if (ifexp != integer_one_node)
2995 expr = build (COND_EXPR, void_type_node,
2996 ifexp, expr, void_zero_node);
3002 /* At the beginning of a destructor, push cleanups that will call the
3003 destructors for our base classes and members.
3005 Called from begin_destructor_body. */
3008 push_base_cleanups (void)
3011 int i, n_baseclasses;
3015 /* Run destructors for all virtual baseclasses. */
3016 if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type))
3019 tree cond = (condition_conversion
3020 (build (BIT_AND_EXPR, integer_type_node,
3021 current_in_charge_parm,
3022 integer_two_node)));
3024 vbases = CLASSTYPE_VBASECLASSES (current_class_type);
3025 /* The CLASSTYPE_VBASECLASSES list is in initialization
3026 order, which is also the right order for pushing cleanups. */
3028 vbases = TREE_CHAIN (vbases))
3030 tree vbase = TREE_VALUE (vbases);
3031 tree base_type = BINFO_TYPE (vbase);
3033 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (base_type))
3035 expr = build_special_member_call (current_class_ref,
3036 base_dtor_identifier,
3040 | LOOKUP_NONVIRTUAL));
3041 expr = build (COND_EXPR, void_type_node, cond,
3042 expr, void_zero_node);
3043 finish_decl_cleanup (NULL_TREE, expr);
3048 binfos = BINFO_BASETYPES (TYPE_BINFO (current_class_type));
3049 n_baseclasses = CLASSTYPE_N_BASECLASSES (current_class_type);
3051 /* Take care of the remaining baseclasses. */
3052 for (i = 0; i < n_baseclasses; i++)
3054 tree base_binfo = TREE_VEC_ELT (binfos, i);
3055 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))
3056 || TREE_VIA_VIRTUAL (base_binfo))
3059 expr = build_special_member_call (current_class_ref,
3060 base_dtor_identifier,
3061 NULL_TREE, base_binfo,
3062 LOOKUP_NORMAL | LOOKUP_NONVIRTUAL);
3063 finish_decl_cleanup (NULL_TREE, expr);
3066 for (member = TYPE_FIELDS (current_class_type); member;
3067 member = TREE_CHAIN (member))
3069 if (TREE_CODE (member) != FIELD_DECL || DECL_ARTIFICIAL (member))
3071 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (member)))
3073 tree this_member = (build_class_member_access_expr
3074 (current_class_ref, member,
3075 /*access_path=*/NULL_TREE,
3076 /*preserve_reference=*/false));
3077 tree this_type = TREE_TYPE (member);
3078 expr = build_delete (this_type, this_member,
3079 sfk_complete_destructor,
3080 LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
3082 finish_decl_cleanup (NULL_TREE, expr);
3087 /* For type TYPE, delete the virtual baseclass objects of DECL. */
3090 build_vbase_delete (tree type, tree decl)
3092 tree vbases = CLASSTYPE_VBASECLASSES (type);
3094 tree addr = build_unary_op (ADDR_EXPR, decl, 0);
3096 my_friendly_assert (addr != error_mark_node, 222);
3098 for (result = convert_to_void (integer_zero_node, NULL);
3099 vbases; vbases = TREE_CHAIN (vbases))
3101 tree base_addr = convert_force
3102 (build_pointer_type (BINFO_TYPE (TREE_VALUE (vbases))), addr, 0);
3103 tree base_delete = build_delete
3104 (TREE_TYPE (base_addr), base_addr, sfk_base_destructor,
3105 LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0);
3107 result = build_compound_expr (result, base_delete);
3112 /* Build a C++ vector delete expression.
3113 MAXINDEX is the number of elements to be deleted.
3114 ELT_SIZE is the nominal size of each element in the vector.
3115 BASE is the expression that should yield the store to be deleted.
3116 This function expands (or synthesizes) these calls itself.
3117 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3119 This also calls delete for virtual baseclasses of elements of the vector.
3121 Update: MAXINDEX is no longer needed. The size can be extracted from the
3122 start of the vector for pointers, and from the type for arrays. We still
3123 use MAXINDEX for arrays because it happens to already have one of the
3124 values we'd have to extract. (We could use MAXINDEX with pointers to
3125 confirm the size, and trap if the numbers differ; not clear that it'd
3126 be worth bothering.) */
3129 build_vec_delete (tree base, tree maxindex,
3130 special_function_kind auto_delete_vec, int use_global_delete)
3134 tree base_init = NULL_TREE;
3136 type = TREE_TYPE (base);
3138 if (TREE_CODE (type) == POINTER_TYPE)
3140 /* Step back one from start of vector, and read dimension. */
3143 if (TREE_SIDE_EFFECTS (base))
3145 base_init = get_target_expr (base);
3146 base = TARGET_EXPR_SLOT (base_init);
3148 type = strip_array_types (TREE_TYPE (type));
3149 cookie_addr = build (MINUS_EXPR,
3150 build_pointer_type (sizetype),
3152 TYPE_SIZE_UNIT (sizetype));
3153 maxindex = build_indirect_ref (cookie_addr, NULL);
3155 else if (TREE_CODE (type) == ARRAY_TYPE)
3157 /* Get the total number of things in the array, maxindex is a
3159 maxindex = array_type_nelts_total (type);
3160 type = strip_array_types (type);
3161 base = build_unary_op (ADDR_EXPR, base, 1);
3162 if (TREE_SIDE_EFFECTS (base))
3164 base_init = get_target_expr (base);
3165 base = TARGET_EXPR_SLOT (base_init);
3170 if (base != error_mark_node)
3171 error ("type to vector delete is neither pointer or array type");
3172 return error_mark_node;
3175 rval = build_vec_delete_1 (base, maxindex, type, auto_delete_vec,
3178 rval = build (COMPOUND_EXPR, TREE_TYPE (rval), base_init, rval);