| blob | dab7dc8a68fae37ce97311f04593d6cb20e9ff8f |
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
4 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)
12 any later version.
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. */
58 /* We are about to generate some complex initialization code.
59 Conceptually, it is all a single expression. However, we may want
60 to include conditionals, loops, and other such statement-level
61 constructs. Therefore, we build the initialization code inside a
62 statement-expression. This function starts such an expression.
63 STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
64 pass them back to finish_init_stmts when the expression is
65 complete. */
67 static bool
69 {
76 }
78 /* Finish out the statement-expression begun by the previous call to
79 begin_init_stmts. Returns the statement-expression itself. */
81 static tree
83 {
91 }
93 /* Constructors */
95 /* Called from initialize_vtbl_ptrs via dfs_walk. BINFO is the base
96 which we want to initialize the vtable pointer for, DATA is
97 TREE_LIST whose TREE_VALUE is the this ptr expression. */
99 static tree
101 {
106 {
112 }
115 }
117 /* Initialize all the vtable pointers in the object pointed to by
118 ADDR. */
120 void
122 {
123 tree list;
124 tree type;
129 /* Walk through the hierarchy, initializing the vptr in each base
130 class. We do these in pre-order because we can't find the virtual
131 bases for a class until we've initialized the vtbl for that
132 class. */
134 }
136 /* Return an expression for the zero-initialization of an object with
137 type T. This expression will either be a constant (in the case
138 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
139 aggregate), or NULL (in the case that T does not require
140 initialization). In either case, the value can be used as
141 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
142 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
143 is the number of elements in the array. If STATIC_STORAGE_P is
144 TRUE, initializers are only generated for entities for which
145 zero-initialization does not simply mean filling the storage with
146 zero bytes. */
148 tree
150 {
153 /* [dcl.init]
155 To zero-initialize an object of type T means:
157 -- if T is a scalar type, the storage is set to the value of zero
158 converted to T.
160 -- if T is a non-union class type, the storage for each nonstatic
161 data member and each base-class subobject is zero-initialized.
163 -- if T is a union type, the storage for its first data member is
164 zero-initialized.
166 -- if T is an array type, the storage for each element is
167 zero-initialized.
169 -- if T is a reference type, no initialization is performed. */
174 ;
176 /* In order to save space, we do not explicitly build initializers
177 for items that do not need them. GCC's semantics are that
178 items with static storage duration that are not otherwise
179 initialized are initialized to zero. */
180 ;
184 {
185 tree field;
188 /* Iterate over the fields, building initializations. */
190 {
194 /* Note that for class types there will be FIELD_DECLs
195 corresponding to base classes as well. Thus, iterating
196 over TYPE_FIELDs will result in correct initialization of
197 all of the subobjects. */
199 {
202 static_storage_p);
205 }
207 /* For unions, only the first field is initialized. */
210 }
212 /* Build a constructor to contain the initializations. */
214 }
216 {
217 tree max_index;
220 /* Iterate over the array elements, building initializations. */
224 else
227 /* If we have an error_mark here, we should just return error mark
228 as we don't know the size of the array yet. */
233 /* A zero-sized array, which is accepted as an extension, will
234 have an upper bound of -1. */
236 {
242 /* If this is a one element array, we just use a regular init. */
245 else
247 max_index);
251 static_storage_p);
252 }
254 /* Build a constructor to contain the initializations. */
256 }
259 else
262 /* In all cases, the initializer is a constant. */
267 }
269 /* Build an expression for the default-initialization of an object of
270 the indicated TYPE. If NELTS is non-NULL, and TYPE is an
271 ARRAY_TYPE, NELTS is the number of elements in the array. If
272 initialization of TYPE requires calling constructors, this function
273 returns NULL_TREE; the caller is responsible for arranging for the
274 constructors to be called. */
276 tree
278 {
279 /* [dcl.init]:
281 To default-initialize an object of type T means:
283 --if T is a non-POD class type (clause _class_), the default construc-
284 tor for T is called (and the initialization is ill-formed if T has
285 no accessible default constructor);
287 --if T is an array type, each element is default-initialized;
289 --otherwise, the storage for the object is zero-initialized.
291 A program that calls for default-initialization of an entity of refer-
292 ence type is ill-formed. */
294 /* If TYPE_NEEDS_CONSTRUCTING is true, the caller is responsible for
295 performing the initialization. This is confusing in that some
296 non-PODs do not have TYPE_NEEDS_CONSTRUCTING set. (For example,
297 a class with a pointer-to-data member as a non-static data member
298 does not have TYPE_NEEDS_CONSTRUCTING set.) Therefore, we end up
299 passing non-PODs to build_zero_init below, which is contrary to
300 the semantics quoted above from [dcl.init].
302 It happens, however, that the behavior of the constructor the
303 standard says we should have generated would be precisely the
304 same as that obtained by calling build_zero_init below, so things
305 work out OK. */
310 /* At this point, TYPE is either a POD class type, an array of POD
311 classes, or something even more innocuous. */
313 }
315 /* Return a suitable initializer for value-initializing an object of type
316 TYPE, as described in [dcl.init]. If HAVE_CTOR is true, the initializer
317 for an enclosing object is already calling the constructor for this
318 object. */
320 static tree
322 {
323 /* [dcl.init]
325 To value-initialize an object of type T means:
327 - if T is a class type (clause 9) with a user-provided constructor
328 (12.1), then the default constructor for T is called (and the
329 initialization is ill-formed if T has no accessible default
330 constructor);
332 - if T is a non-union class type without a user-provided constructor,
333 then every non-static data member and base-class component of T is
334 value-initialized;92)
336 - if T is an array type, then each element is value-initialized;
338 - otherwise, the object is zero-initialized.
340 A program that calls for default-initialization or
341 value-initialization of an entity of reference type is ill-formed.
343 92) Value-initialization for such a class object may be implemented by
344 zero-initializing the object and then calling the default
345 constructor. */
348 {
350 return build_cplus_new
354 tf_warning_or_error));
356 {
361 /* Iterate over the fields, building initializations. */
363 {
374 /* We could skip vfields and fields of types with
375 user-defined constructors, but I think that won't improve
376 performance at all; it should be simpler in general just
377 to zero out the entire object than try to only zero the
378 bits that actually need it. */
380 /* Note that for class types there will be FIELD_DECLs
381 corresponding to base classes as well. Thus, iterating
382 over TYPE_FIELDs will result in correct initialization of
383 all of the subobjects. */
388 }
390 /* Build a constructor to contain the zero- initializations. */
393 {
394 /* This is a class that needs constructing, but doesn't have
395 a user-defined constructor. So we need to zero-initialize
396 the object and then call the implicitly defined ctor.
397 Implement this by sticking the zero-initialization inside
398 the TARGET_EXPR for the constructor call;
399 cp_gimplify_init_expr will know how to handle it. */
400 tree ctor = build_special_member_call
411 }
413 }
414 }
416 {
419 /* Iterate over the array elements, building initializations. */
422 /* If we have an error_mark here, we should just return error mark
423 as we don't know the size of the array yet. */
428 /* A zero-sized array, which is accepted as an extension, will
429 have an upper bound of -1. */
431 {
437 /* If this is a one element array, we just use a regular init. */
440 else
442 max_index);
445 }
447 /* Build a constructor to contain the initializations. */
449 }
452 }
454 /* Return a suitable initializer for value-initializing an object of type
455 TYPE, as described in [dcl.init]. */
457 tree
459 {
461 }
463 /* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of
464 arguments. If TREE_LIST is void_type_node, an empty initializer
465 list was given; if NULL_TREE no initializer was given. */
467 static void
469 {
470 tree decl;
476 /* Effective C++ rule 12 requires that all data members be
477 initialized. */
485 /* Get an lvalue for the data member. */
489 tf_warning_or_error);
493 /* Deal with this here, as we will get confused if we try to call the
494 assignment op for an anonymous union. This can happen in a
495 synthesized copy constructor. */
497 {
499 {
502 }
503 }
505 {
511 {
512 /* Initialization of one array from another. */
516 tf_warning_or_error));
517 }
518 else
520 tf_warning_or_error));
521 }
522 else
523 {
525 {
527 {
533 }
534 /* member traversal: note it leaves init NULL */
541 }
543 /* There was an explicit member initialization. Do some work
544 in that case. */
549 tf_warning_or_error));
550 }
553 {
554 tree expr;
559 tf_warning_or_error);
565 }
566 }
568 /* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
569 the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */
571 static tree
573 {
574 tree fields;
578 /* Note whether or not T is a union. */
583 {
584 /* Skip CONST_DECLs for enumeration constants and so forth. */
588 /* Keep track of whether or not any fields are unions. */
592 /* For an anonymous struct or union, we must recursively
593 consider the fields of the anonymous type. They can be
594 directly initialized from the constructor. */
596 {
597 /* Add this field itself. Synthesized copy constructors
598 initialize the entire aggregate. */
600 /* And now add the fields in the anonymous aggregate. */
602 uses_unions_p);
603 }
604 /* Add this field. */
607 }
610 }
612 /* The MEM_INITS are a TREE_LIST. The TREE_PURPOSE of each list gives
613 a FIELD_DECL or BINFO in T that needs initialization. The
614 TREE_VALUE gives the initializer, or list of initializer arguments.
616 Return a TREE_LIST containing all of the initializations required
617 for T, in the order in which they should be performed. The output
618 list has the same format as the input. */
620 static tree
622 {
623 tree init;
625 tree sorted_inits;
626 tree next_subobject;
631 /* Build up a list of initializations. The TREE_PURPOSE of entry
632 will be the subobject (a FIELD_DECL or BINFO) to initialize. The
633 TREE_VALUE will be the constructor arguments, or NULL if no
634 explicit initialization was provided. */
637 /* Process the virtual bases. */
642 /* Process the direct bases. */
648 /* Process the non-static data members. */
650 /* Reverse the entire list of initializations, so that they are in
651 the order that they will actually be performed. */
654 /* If the user presented the initializers in an order different from
655 that in which they will actually occur, we issue a warning. Keep
656 track of the next subobject which can be explicitly initialized
657 without issuing a warning. */
660 /* Go through the explicit initializers, filling in TREE_PURPOSE in
661 the SORTED_INITS. */
663 {
664 tree subobject;
665 tree subobject_init;
669 /* If the explicit initializers are in sorted order, then
670 SUBOBJECT will be NEXT_SUBOBJECT, or something following
671 it. */
673 subobject_init;
678 /* Issue a warning if the explicit initializer order does not
679 match that which will actually occur.
680 ??? Are all these on the correct lines? */
682 {
686 else
691 else
694 }
696 /* Look again, from the beginning of the list. */
698 {
702 }
704 /* It is invalid to initialize the same subobject more than
705 once. */
707 {
711 else
714 }
716 /* Record the initialization. */
719 }
721 /* [class.base.init]
723 If a ctor-initializer specifies more than one mem-initializer for
724 multiple members of the same union (including members of
725 anonymous unions), the ctor-initializer is ill-formed. */
727 {
730 {
731 tree field;
732 tree field_type;
735 /* Skip uninitialized members and base classes. */
739 /* See if this field is a member of a union, or a member of a
740 structure contained in a union, etc. */
747 /* If this field is not a member of a union, skip it. */
751 /* It's only an error if we have two initializers for the same
752 union type. */
754 {
757 }
759 /* See if LAST_FIELD and the field initialized by INIT are
760 members of the same union. If so, there's a problem,
761 unless they're actually members of the same structure
762 which is itself a member of a union. For example, given:
764 union { struct { int i; int j; }; };
766 initializing both `i' and `j' makes sense. */
769 do
770 {
771 tree last_field_type;
775 {
777 {
783 }
789 }
791 /* If we've reached the outermost class, then we're
792 done. */
797 }
801 }
802 }
805 }
807 /* Initialize all bases and members of CURRENT_CLASS_TYPE. MEM_INITS
808 is a TREE_LIST giving the explicit mem-initializer-list for the
809 constructor. The TREE_PURPOSE of each entry is a subobject (a
810 FIELD_DECL or a BINFO) of the CURRENT_CLASS_TYPE. The TREE_VALUE
811 is a TREE_LIST giving the arguments to the constructor or
812 void_type_node for an empty list of arguments. */
814 void
816 {
817 /* We will already have issued an error message about the fact that
818 the type is incomplete. */
822 /* Sort the mem-initializers into the order in which the
823 initializations should be performed. */
828 /* Initialize base classes. */
831 {
835 /* If these initializations are taking place in a copy constructor,
836 the base class should probably be explicitly initialized if there
837 is a user-defined constructor in the base class (other than the
838 default constructor, which will be called anyway). */
846 /* If an explicit -- but empty -- initializer list was present,
847 treat it just like default initialization at this point. */
851 /* Initialize the base. */
854 else
855 {
856 tree base_addr;
862 tf_warning_or_error),
863 arguments,
864 LOOKUP_NORMAL,
865 tf_warning_or_error);
867 }
870 }
873 /* Initialize the vptrs. */
876 /* Initialize the data members. */
878 {
882 }
883 }
885 /* Returns the address of the vtable (i.e., the value that should be
886 assigned to the vptr) for BINFO. */
888 static tree
890 {
892 tree vtbl;
895 /* If this is a virtual primary base, then the vtable we want to store
896 is that for the base this is being used as the primary base of. We
897 can't simply skip the initialization, because we may be expanding the
898 inits of a subobject constructor where the virtual base layout
899 can be different. */
903 /* Figure out what vtable BINFO's vtable is based on, and mark it as
904 used. */
909 /* Now compute the address to use when initializing the vptr. */
915 }
917 /* This code sets up the virtual function tables appropriate for
918 the pointer DECL. It is a one-ply initialization.
920 BINFO is the exact type that DECL is supposed to be. In
921 multiple inheritance, this might mean "C's A" if C : A, B. */
923 static void
925 {
927 tree vtt_index;
929 /* Compute the initializer for vptr. */
932 /* We may get this vptr from a VTT, if this is a subobject
933 constructor or subobject destructor. */
936 {
937 tree vtbl2;
938 tree vtt_parm;
940 /* Compute the value to use, when there's a VTT. */
944 vtt_parm,
945 vtt_index);
949 /* The actual initializer is the VTT value only in the subobject
950 constructor. In maybe_clone_body we'll substitute NULL for
951 the vtt_parm in the case of the non-subobject constructor. */
956 vtbl2,
957 vtbl);
958 }
960 /* Compute the location of the vtpr. */
962 tf_warning_or_error),
966 /* Assign the vtable to the vptr. */
969 tf_warning_or_error));
970 }
972 /* If an exception is thrown in a constructor, those base classes already
973 constructed must be destroyed. This function creates the cleanup
974 for BINFO, which has just been constructed. If FLAG is non-NULL,
975 it is a DECL which is nonzero when this base needs to be
976 destroyed. */
978 static void
980 {
981 tree expr;
986 /* Call the destructor. */
988 base_dtor_identifier,
989 NULL_TREE,
990 binfo,
992 tf_warning_or_error);
999 }
1001 /* Construct the virtual base-class VBASE passing the ARGUMENTS to its
1002 constructor. */
1004 static void
1006 {
1007 tree inner_if_stmt;
1008 tree exp;
1009 tree flag;
1011 /* If there are virtual base classes with destructors, we need to
1012 emit cleanups to destroy them if an exception is thrown during
1013 the construction process. These exception regions (i.e., the
1014 period during which the cleanups must occur) begin from the time
1015 the construction is complete to the end of the function. If we
1016 create a conditional block in which to initialize the
1017 base-classes, then the cleanup region for the virtual base begins
1018 inside a block, and ends outside of that block. This situation
1019 confuses the sjlj exception-handling code. Therefore, we do not
1020 create a single conditional block, but one for each
1021 initialization. (That way the cleanup regions always begin
1022 in the outer block.) We trust the back end to figure out
1023 that the FLAG will not change across initializations, and
1024 avoid doing multiple tests. */
1029 /* Compute the location of the virtual base. If we're
1030 constructing virtual bases, then we must be the most derived
1031 class. Therefore, we don't have to look up the virtual base;
1032 we already know where it is. */
1041 }
1043 /* Find the context in which this FIELD can be initialized. */
1045 static tree
1047 {
1050 /* Anonymous union members can be initialized in the first enclosing
1051 non-anonymous union context. */
1055 }
1057 /* Function to give error message if member initialization specification
1058 is erroneous. FIELD is the member we decided to initialize.
1059 TYPE is the type for which the initialization is being performed.
1060 FIELD must be a member of TYPE.
1062 MEMBER_NAME is the name of the member. */
1064 static int
1066 {
1070 {
1072 member_name);
1074 }
1076 {
1079 field);
1081 }
1083 {
1087 }
1089 {
1091 member_name);
1093 }
1096 }
1098 /* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
1099 is a _TYPE node or TYPE_DECL which names a base for that type.
1100 Check the validity of NAME, and return either the base _TYPE, base
1101 binfo, or the FIELD_DECL of the member. If NAME is invalid, return
1102 NULL_TREE and issue a diagnostic.
1104 An old style unnamed direct single base construction is permitted,
1105 where NAME is NULL. */
1107 tree
1109 {
1110 tree basetype;
1111 tree field;
1117 {
1118 /* This is an obsolete unnamed base class initializer. The
1119 parser will already have warned about its use. */
1121 {
1124 current_class_type);
1127 basetype = BINFO_TYPE
1132 current_class_type);
1134 }
1135 }
1137 {
1140 }
1143 else
1147 {
1148 tree class_binfo;
1149 tree direct_binfo;
1150 tree virtual_binfo;
1160 /* Look for a direct base. */
1165 /* Look for a virtual base -- unless the direct base is itself
1166 virtual. */
1170 /* [class.base.init]
1172 If a mem-initializer-id is ambiguous because it designates
1173 both a direct non-virtual base class and an inherited virtual
1174 base class, the mem-initializer is ill-formed. */
1176 {
1178 basetype);
1180 }
1183 {
1187 else
1191 }
1194 }
1195 else
1196 {
1199 else
1204 }
1207 }
1209 /* This is like `expand_member_init', only it stores one aggregate
1210 value into another.
1212 INIT comes in two flavors: it is either a value which
1213 is to be stored in EXP, or it is a parameter list
1214 to go to a constructor, which will operate on EXP.
1215 If INIT is not a parameter list for a constructor, then set
1216 LOOKUP_ONLYCONVERTING.
1217 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1218 the initializer, if FLAGS is 0, then it is the (init) form.
1219 If `init' is a CONSTRUCTOR, then we emit a warning message,
1220 explaining that such initializations are invalid.
1222 If INIT resolves to a CALL_EXPR which happens to return
1223 something of the type we are looking for, then we know
1224 that we can safely use that call to perform the
1225 initialization.
1227 The virtual function table pointer cannot be set up here, because
1228 we do not really know its type.
1230 This never calls operator=().
1232 When initializing, nothing is CONST.
1234 A default copy constructor may have to be used to perform the
1235 initialization.
1237 A constructor or a conversion operator may have to be used to
1238 perform the initialization, but not both, as it would be ambiguous. */
1240 tree
1242 {
1243 tree stmt_expr;
1244 tree compound_stmt;
1261 {
1262 tree itype;
1264 /* An array may not be initialized use the parenthesized
1265 initialization form -- unless the initializer is "()". */
1267 {
1271 }
1272 /* Must arrange to initialize each element of EXP
1273 from elements of INIT. */
1283 complain);
1290 }
1293 /* Just know that we've seen something for this node. */
1307 }
1309 static void
1311 tsubst_flags_t complain)
1312 {
1314 tree ctor_name;
1316 /* It fails because there may not be a constructor which takes
1317 its own type as the first (or only parameter), but which does
1318 take other types via a conversion. So, if the thing initializing
1319 the expression is a unit element of type X, first try X(X&),
1320 followed by initialization by X. If neither of these work
1321 out, then look hard. */
1322 tree rval;
1323 tree parms;
1327 {
1328 /* Base subobjects should only get direct-initialization. */
1332 /* Do nothing. We hit this in two cases: Reference initialization,
1333 where we aren't initializing a real variable, so we don't want
1334 to run a new constructor; and catching an exception, where we
1335 have already built up the constructor call so we could wrap it
1338 {
1339 /* A brace-enclosed initializer for an aggregate. */
1342 }
1343 else
1347 /* We need to protect the initialization of a catch parm with a
1348 call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
1349 around the TARGET_EXPR for the copy constructor. See
1350 initialize_handler_parm. */
1351 {
1355 }
1356 else
1361 }
1365 {
1369 }
1370 else
1375 else
1379 complain);
1382 }
1384 /* This function is responsible for initializing EXP with INIT
1385 (if any).
1387 BINFO is the binfo of the type for who we are performing the
1388 initialization. For example, if W is a virtual base class of A and B,
1389 and C : A, B.
1390 If we are initializing B, then W must contain B's W vtable, whereas
1391 were we initializing C, W must contain C's W vtable.
1393 TRUE_EXP is nonzero if it is the true expression being initialized.
1394 In this case, it may be EXP, or may just contain EXP. The reason we
1395 need this is because if EXP is a base element of TRUE_EXP, we
1396 don't necessarily know by looking at EXP where its virtual
1397 baseclass fields should really be pointing. But we do know
1398 from TRUE_EXP. In constructors, we don't know anything about
1399 the value being initialized.
1401 FLAGS is just passed to `build_new_method_call'. See that function
1402 for its description. */
1404 static void
1406 tsubst_flags_t complain)
1407 {
1413 /* Use a function returning the desired type to initialize EXP for us.
1414 If the function is a constructor, and its first argument is
1415 NULL_TREE, know that it was meant for us--just slide exp on
1416 in and expand the constructor. Constructors now come
1417 as TARGET_EXPRs. */
1421 {
1422 /* If store_init_value returns NULL_TREE, the INIT has been
1423 recorded as the DECL_INITIAL for EXP. That means there's
1424 nothing more we have to do. */
1429 }
1431 /* We know that expand_default_init can handle everything we want
1432 at this point. */
1434 }
1436 /* Report an error if TYPE is not a user-defined, class type. If
1437 OR_ELSE is nonzero, give an error message. */
1439 int
1441 {
1446 {
1450 }
1452 }
1454 tree
1456 {
1462 else
1464 }
1466 /* Build a reference to a member of an aggregate. This is not a C++
1467 `&', but really something which can have its address taken, and
1468 then act as a pointer to member, for example TYPE :: FIELD can have
1469 its address taken by saying & TYPE :: FIELD. ADDRESS_P is true if
1470 this expression is the operand of "&".
1472 @@ Prints out lousy diagnostics for operator <typename>
1473 @@ fields.
1475 @@ This function should be rewritten and placed in search.c. */
1477 tree
1479 {
1480 tree decl;
1483 /* class templates can come in as TEMPLATE_DECLs here. */
1496 /* Callers should call mark_used before this point. */
1501 {
1504 }
1506 /* Entities other than non-static members need no further
1507 processing. */
1514 {
1517 }
1519 /* Set up BASEBINFO for member lookup. */
1522 /* A lot of this logic is now handled in lookup_member. */
1524 {
1525 /* Go from the TREE_BASELINK to the member function info. */
1529 {
1530 /* Get rid of a potential OVERLOAD around it. */
1533 /* Unique functions are handled easily. */
1535 /* For non-static member of base class, we need a special rule
1536 for access checking [class.protected]:
1538 If the access is to form a pointer to member, the
1539 nested-name-specifier shall name the derived class
1540 (or any class derived from that class). */
1544 else
1550 }
1551 else
1553 }
1555 /* We need additional test besides the one in
1556 check_accessibility_of_qualified_id in case it is
1557 a pointer to non-static member. */
1561 {
1562 /* If MEMBER is non-static, then the program has fallen afoul of
1563 [expr.prim]:
1565 An id-expression that denotes a nonstatic data member or
1566 nonstatic member function of a class can only be used:
1568 -- as part of a class member access (_expr.ref_) in which the
1569 object-expression refers to the member's class or a class
1570 derived from that class, or
1572 -- to form a pointer to member (_expr.unary.op_), or
1574 -- in the body of a nonstatic member function of that class or
1575 of a class derived from that class (_class.mfct.nonstatic_), or
1577 -- in a mem-initializer for a constructor for that class or for
1578 a class derived from that class (_class.base.init_). */
1580 {
1581 /* Build a representation of a the qualified name suitable
1582 for use as the operand to "&" -- even though the "&" is
1583 not actually present. */
1585 /* In Microsoft mode, treat a non-static member function as if
1586 it were a pointer-to-member. */
1588 {
1591 tf_warning_or_error);
1592 }
1596 }
1598 {
1601 }
1603 }
1608 }
1610 /* If DECL is a scalar enumeration constant or variable with a
1611 constant initializer, return the initializer (or, its initializers,
1612 recursively); otherwise, return DECL. If INTEGRAL_P, the
1613 initializer is only returned if DECL is an integral
1614 constant-expression. */
1616 static tree
1618 {
1620 || (integral_p
1624 {
1625 tree init;
1626 /* Static data members in template classes may have
1627 non-dependent initializers. References to such non-static
1628 data members are not value-dependent, so we must retrieve the
1629 initializer here. The DECL_INITIAL will have the right type,
1630 but will not have been folded because that would prevent us
1631 from performing all appropriate semantic checks at
1632 instantiation time. */
1637 {
1641 }
1642 else
1643 {
1644 /* If DECL is a static data member in a template
1645 specialization, we must instantiate it here. The
1646 initializer for the static data member is not processed
1647 until needed; we need it now. */
1650 }
1655 || (integral_p
1658 /* Do not return an aggregate constant (of which
1659 string literals are a special case), as we do not
1660 want to make inadvertent copies of such entities,
1661 and we must be sure that their addresses are the
1662 same everywhere. */
1667 }
1669 }
1671 /* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by
1672 constant of integral or enumeration type, then return that value.
1673 These are those variables permitted in constant expressions by
1674 [5.19/1]. */
1676 tree
1678 {
1680 }
1682 /* A more relaxed version of integral_constant_value, used by the
1683 common C/C++ code and by the C++ front end for optimization
1684 purposes. */
1686 tree
1688 {
1691 }
1692 \f
1693 /* Common subroutines of build_new and build_vec_delete. */
1695 /* Call the global __builtin_delete to delete ADDR. */
1697 static tree
1699 {
1702 }
1703 \f
1704 /* Build and return a NEW_EXPR. If NELTS is non-NULL, TYPE[NELTS] is
1705 the type of the object being allocated; otherwise, it's just TYPE.
1706 INIT is the initializer, if any. USE_GLOBAL_NEW is true if the
1707 user explicitly wrote "::operator new". PLACEMENT, if non-NULL, is
1708 the TREE_LIST of arguments to be provided as arguments to a
1709 placement new operator. This routine performs no semantic checks;
1710 it just creates and returns a NEW_EXPR. */
1712 static tree
1715 {
1716 tree new_expr;
1724 }
1726 /* Make sure that there are no aliasing issues with T, a placement new
1727 expression applied to PLACEMENT, by recording the change in dynamic
1728 type. If placement new is inlined, as it is with libstdc++, and if
1729 the type of the placement new differs from the type of the
1730 placement location itself, then alias analysis may think it is OK
1731 to interchange writes to the location from before the placement new
1732 and from after the placement new. We have to prevent type-based
1733 alias analysis from applying. PLACEMENT may be NULL, which means
1734 that we couldn't capture it in a temporary variable, in which case
1735 we use a memory clobber. */
1737 static tree
1739 {
1740 tree type_change;
1745 /* If we are not using type based aliasing, we don't have to do
1746 anything. */
1750 /* If we have a pointer and a location, record the change in dynamic
1751 type. Otherwise we need a general memory clobber. */
1757 placement);
1758 else
1759 {
1760 /* Build a memory clobber. */
1763 NULL_TREE,
1764 NULL_TREE,
1767 NULL_TREE));
1770 }
1773 }
1775 /* Generate code for a new-expression, including calling the "operator
1776 new" function, initializing the object, and, if an exception occurs
1777 during construction, cleaning up. The arguments are as for
1778 build_raw_new_expr. */
1780 static tree
1783 {
1785 /* True iff this is a call to "operator new[]" instead of just
1786 "operator new". */
1788 /* True iff ARRAY_P is true and the bound of the array type is
1789 not necessarily a compile time constant. For example, VLA_P is
1790 true for "new int[f()]". */
1792 /* The type being allocated. If ARRAY_P is true, this will be an
1793 ARRAY_TYPE. */
1794 tree full_type;
1795 /* If ARRAY_P is true, the element type of the array. This is an
1796 never ARRAY_TYPE; for something like "new int[3][4]", the
1797 ELT_TYPE is "int". If ARRAY_P is false, this is the same type as
1798 FULL_TYPE. */
1799 tree elt_type;
1800 /* The type of the new-expression. (This type is always a pointer
1801 type.) */
1802 tree pointer_type;
1803 /* A pointer type pointing to the FULL_TYPE. */
1804 tree full_pointer_type;
1807 /* The address returned by the call to "operator new". This node is
1808 a VAR_DECL and is therefore reusable. */
1809 tree alloc_node;
1810 tree alloc_fn;
1814 /* If non-NULL, the number of extra bytes to allocate at the
1815 beginning of the storage allocated for an array-new expression in
1816 order to store the number of elements. */
1819 /* True if the function we are calling is a placement allocation
1820 function. */
1823 /* True if the storage must be initialized, either by a constructor
1824 or due to an explicit new-initializer. */
1826 /* The address of the thing allocated, not including any cookie. In
1827 particular, if an array cookie is in use, DATA_ADDR is the
1828 address of the first array element. This node is a VAR_DECL, and
1829 is therefore reusable. */
1830 tree data_addr;
1834 {
1835 tree index;
1840 /* ??? The middle-end will error on us for building a VLA outside a
1841 function context. Methinks that's not it's purvey. So we'll do
1842 our own VLA layout later. */
1848 /* We need a copy of the type as build_array_type will return a shared copy
1849 of the incomplete array type. */
1853 }
1854 else
1855 {
1858 {
1863 }
1864 }
1866 /* If our base type is an array, then make sure we know how many elements
1867 it has. */
1873 complain);
1876 {
1880 }
1887 {
1891 }
1895 {
1898 {
1901 /* Do our own VLA layout. Setting TYPE_SIZE/_UNIT is
1902 necessary in order for the <INIT_EXPR <*foo> <CONSTRUCTOR
1903 ...>> to be valid. */
1908 }
1909 }
1913 /* Allocate the object. */
1915 {
1916 tree class_addr;
1926 {
1930 }
1932 {
1936 }
1939 alloc_call = (cp_build_function_call
1942 complain));
1943 }
1945 {
1948 }
1949 else
1950 {
1951 tree fnname;
1952 tree fns;
1958 && (array_p
1961 {
1962 /* Use a class-specific operator new. */
1963 /* If a cookie is required, add some extra space. */
1965 {
1968 }
1969 /* Create the argument list. */
1971 /* Do name-lookup to find the appropriate operator. */
1974 {
1978 }
1980 {
1982 {
1985 }
1987 }
1991 LOOKUP_NORMAL,
1993 complain);
1994 }
1995 else
1996 {
1997 /* Use a global operator new. */
1998 /* See if a cookie might be required. */
2001 else
2007 }
2008 }
2015 /* If PLACEMENT is a simple pointer type and is not passed by reference,
2016 then copy it into PLACEMENT_EXPR. */
2025 {
2030 {
2034 }
2035 }
2037 /* In the simple case, we can stop now. */
2040 {
2045 }
2047 /* While we're working, use a pointer to the type we've actually
2048 allocated. Store the result of the call in a variable so that we
2049 can use it more than once. */
2054 /* Strip any COMPOUND_EXPRs from ALLOC_CALL. */
2058 /* Now, check to see if this function is actually a placement
2059 allocation function. This can happen even when PLACEMENT is NULL
2060 because we might have something like:
2062 struct S { void* operator new (size_t, int i = 0); };
2064 A call to `new S' will get this allocation function, even though
2065 there is no explicit placement argument. If there is more than
2066 one argument, or there are variable arguments, then this is a
2067 placement allocation function. */
2068 placement_allocation_fn_p
2072 /* Preevaluate the placement args so that we don't reevaluate them for a
2073 placement delete. */
2075 {
2076 tree inits;
2080 alloc_expr);
2081 }
2083 /* unless an allocation function is declared with an empty excep-
2084 tion-specification (_except.spec_), throw(), it indicates failure to
2085 allocate storage by throwing a bad_alloc exception (clause _except_,
2086 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2087 cation function is declared with an empty exception-specification,
2088 throw(), it returns null to indicate failure to allocate storage and a
2089 non-null pointer otherwise.
2091 So check for a null exception spec on the op new we just called. */
2097 {
2098 tree cookie;
2099 tree cookie_ptr;
2100 tree size_ptr_type;
2102 /* Adjust so we're pointing to the start of the object. */
2106 /* Store the number of bytes allocated so that we can know how
2107 many elements to destroy later. We use the last sizeof
2108 (size_t) bytes to store the number of elements. */
2118 {
2119 /* Also store the element size. */
2129 }
2131 }
2132 else
2133 {
2136 }
2138 /* Now initialize the allocated object. Note that we preevaluate the
2139 initialization expression, apart from the actual constructor call or
2140 assignment--we do this because we want to delay the allocation as long
2141 as possible in order to minimize the size of the exception region for
2142 placement delete. */
2144 {
2150 {
2154 {
2157 }
2159 {
2162 else
2164 }
2165 init_expr
2168 integer_one_node,
2169 complain),
2170 init,
2171 explicit_default_init_p,
2173 complain);
2175 /* An array initialization is stable because the initialization
2176 of each element is a full-expression, so the temporaries don't
2177 leak out. */
2179 }
2180 else
2181 {
2186 {
2188 complete_ctor_identifier,
2190 LOOKUP_NORMAL,
2191 complain);
2193 }
2194 else
2195 {
2196 /* We are processing something like `new int (10)', which
2197 means allocate an int, and initialize it with 10. */
2202 else
2207 complain);
2209 }
2210 }
2215 /* If any part of the object initialization terminates by throwing an
2216 exception and a suitable deallocation function can be found, the
2217 deallocation function is called to free the memory in which the
2218 object was being constructed, after which the exception continues
2219 to propagate in the context of the new-expression. If no
2220 unambiguous matching deallocation function can be found,
2221 propagating the exception does not cause the object's memory to be
2222 freed. */
2224 {
2226 tree cleanup;
2228 /* The Standard is unclear here, but the right thing to do
2229 is to use the same method for finding deallocation
2230 functions that we use for finding allocation functions. */
2232 globally_qualified_p,
2233 (placement_allocation_fn_p
2235 alloc_fn);
2240 /* This is much simpler if we were able to preevaluate all of
2241 the arguments to the constructor call. */
2244 else
2245 /* Ack! First we allocate the memory. Then we set our sentry
2246 variable to true, and expand a cleanup that deletes the
2247 memory if sentry is true. Then we run the constructor, and
2248 finally clear the sentry.
2250 We need to do this because we allocate the space first, so
2251 if there are any temporaries with cleanups in the
2252 constructor args and we weren't able to preevaluate them, we
2253 need this EH region to extend until end of full-expression
2254 to preserve nesting. */
2255 {
2270 init_expr
2273 end));
2274 }
2276 }
2277 }
2278 else
2281 /* Now build up the return value in reverse order. */
2291 /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
2292 and return the call (which doesn't need to be adjusted). */
2294 else
2295 {
2297 {
2299 integer_zero_node,
2300 complain);
2302 complain);
2303 }
2305 /* Perform the allocation before anything else, so that ALLOC_NODE
2306 has been initialized before we start using it. */
2308 }
2313 /* Convert to the final type. */
2316 /* A new-expression is never an lvalue. */
2323 }
2325 /* Generate a representation for a C++ "new" expression. PLACEMENT is
2326 a TREE_LIST of placement-new arguments (or NULL_TREE if none). If
2327 NELTS is NULL, TYPE is the type of the storage to be allocated. If
2328 NELTS is not NULL, then this is an array-new allocation; TYPE is
2329 the type of the elements in the array and NELTS is the number of
2330 elements in the array. INIT, if non-NULL, is the initializer for
2331 the new object, or void_zero_node to indicate an initializer of
2332 "()". If USE_GLOBAL_NEW is true, then the user explicitly wrote
2333 "::new" rather than just "new". */
2335 tree
2338 {
2339 tree rval;
2340 tree orig_placement;
2341 tree orig_nelts;
2342 tree orig_init;
2353 {
2360 use_global_new);
2366 }
2369 {
2371 {
2374 else
2376 }
2378 }
2380 /* ``A reference cannot be created by the new operator. A reference
2381 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2382 returned by new.'' ARM 5.3.3 */
2384 {
2387 else
2390 }
2393 {
2397 }
2399 /* The type allocated must be complete. If the new-type-id was
2400 "T[N]" then we are just checking that "T" is complete here, but
2401 that is equivalent, since the value of "N" doesn't matter. */
2411 use_global_new);
2413 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
2418 }
2420 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
2422 tree
2424 {
2430 {
2433 {
2436 }
2438 }
2440 /* Mangle the class$ field. */
2441 {
2442 tree field;
2445 {
2449 }
2451 {
2454 }
2455 }
2459 {
2468 }
2470 }
2471 \f
2472 static tree
2475 {
2476 tree virtual_size;
2480 /* Temporary variables used by the loop. */
2483 /* This is the body of the loop that implements the deletion of a
2484 single element, and moves temp variables to next elements. */
2485 tree body;
2487 /* This is the LOOP_EXPR that governs the deletion of the elements. */
2490 /* This is the thing that governs what to do after the loop has run. */
2493 /* This is the BIND_EXPR which holds the outermost iterator of the
2494 loop. It is convenient to set this variable up and test it before
2495 executing any other code in the loop.
2496 This is also the containing expression returned by this function. */
2498 tree tmp;
2500 /* We should only have 1-D arrays here. */
2506 /* The below is short by the cookie size. */
2514 virtual_size),
2515 tf_warning_or_error);
2525 body = build_compound_expr
2528 tf_warning_or_error));
2529 body = build_compound_expr
2536 no_destructor:
2537 /* If the delete flag is one, or anything else with the low bit set,
2538 delete the storage. */
2540 {
2541 tree base_tbd;
2543 /* The below is short by the cookie size. */
2548 /* no header */
2550 else
2551 {
2552 tree cookie_size;
2555 base_tbd
2559 base),
2560 cookie_size,
2561 tf_warning_or_error));
2562 /* True size with header. */
2564 }
2572 }
2576 ;
2579 else
2585 /* Outermost wrapper: If pointer is null, punt. */
2589 integer_zero_node)),
2594 {
2597 }
2600 /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */
2604 }
2606 /* Create an unnamed variable of the indicated TYPE. */
2608 tree
2610 {
2611 tree decl;
2621 }
2623 /* Create a new temporary variable of the indicated TYPE, initialized
2624 to INIT.
2626 It is not entered into current_binding_level, because that breaks
2627 things when it comes time to do final cleanups (which take place
2628 "outside" the binding contour of the function). */
2630 static tree
2632 {
2633 tree decl;
2639 tf_warning_or_error));
2642 }
2644 /* `build_vec_init' returns tree structure that performs
2645 initialization of a vector of aggregate types.
2647 BASE is a reference to the vector, of ARRAY_TYPE.
2648 MAXINDEX is the maximum index of the array (one less than the
2649 number of elements). It is only used if
2650 TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
2652 INIT is the (possibly NULL) initializer.
2654 If EXPLICIT_DEFAULT_INIT_P is true, then INIT must be NULL. All
2655 elements in the array are default-initialized.
2657 FROM_ARRAY is 0 if we should init everything with INIT
2658 (i.e., every element initialized from INIT).
2659 FROM_ARRAY is 1 if we should index into INIT in parallel
2660 with initialization of DECL.
2661 FROM_ARRAY is 2 if we should index into INIT in parallel,
2662 but use assignment instead of initialization. */
2664 tree
2668 {
2669 tree rval;
2671 tree size;
2673 tree iterator;
2674 /* The type of the array. */
2676 /* The type of an element in the array. */
2678 /* The element type reached after removing all outer array
2679 types. */
2680 tree inner_elt_type;
2681 /* The type of a pointer to an element in the array. */
2682 tree ptype;
2683 tree stmt_expr;
2684 tree compound_stmt;
2706 /* Don't do this if the CONSTRUCTOR might contain something
2707 that might throw and require us to clean up. */
2711 {
2712 /* Do non-default initialization of POD arrays resulting from
2713 brace-enclosed initializers. In this case, digest_init and
2714 store_constructor will handle the semantics for us. */
2718 }
2726 /* The code we are generating looks like:
2727 ({
2728 T* t1 = (T*) base;
2729 T* rval = t1;
2730 ptrdiff_t iterator = maxindex;
2731 try {
2732 for (; iterator != -1; --iterator) {
2733 ... initialize *t1 ...
2734 ++t1;
2735 }
2736 } catch (...) {
2737 ... destroy elements that were constructed ...
2738 }
2739 rval;
2740 })
2742 We can omit the try and catch blocks if we know that the
2743 initialization will never throw an exception, or if the array
2744 elements do not have destructors. We can omit the loop completely if
2745 the elements of the array do not have constructors.
2747 We actually wrap the entire body of the above in a STMT_EXPR, for
2748 tidiness.
2750 When copying from array to another, when the array elements have
2751 only trivial copy constructors, we should use __builtin_memcpy
2752 rather than generating a loop. That way, we could take advantage
2753 of whatever cleverness the back end has for dealing with copies
2754 of blocks of memory. */
2763 /* Protect the entire array initialization so that we can destroy
2764 the partially constructed array if an exception is thrown.
2765 But don't do this if we're assigning. */
2768 {
2770 }
2773 {
2774 /* Do non-default initialization of non-POD arrays resulting from
2775 brace-enclosed initializers. */
2777 tree elt;
2781 {
2784 num_initialized_elts++;
2789 else
2795 complain));
2797 complain));
2798 }
2800 /* Clear out INIT so that we don't get confused below. */
2802 }
2804 {
2805 /* If initializing one array from another, initialize element by
2806 element. We rely upon the below calls the do argument
2807 checking. */
2809 {
2814 }
2818 {
2822 }
2823 }
2825 /* Now, default-initialize any remaining elements. We don't need to
2826 do that if a) the type does not need constructing, or b) we've
2827 already initialized all the elements.
2829 We do need to keep going if we're copying an array. */
2834 && (num_initialized_elts
2836 {
2837 /* If the ITERATOR is equal to -1, then we don't have to loop;
2838 we've already initialized all the elements. */
2839 tree for_stmt;
2840 tree elt_init;
2841 tree to;
2847 for_stmt);
2849 complain),
2850 for_stmt);
2855 {
2856 tree from;
2860 else
2865 complain);
2870 complain);
2871 else
2873 }
2875 {
2877 sorry
2883 }
2885 elt_init = (cp_build_modify_expr
2889 complain));
2890 else
2898 complain));
2901 complain));
2904 }
2906 /* Make sure to cleanup any partially constructed elements. */
2909 {
2910 tree e;
2912 complain);
2914 /* Flatten multi-dimensional array since build_vec_delete only
2915 expects one-dimensional array. */
2919 complain);
2926 }
2928 /* The value of the array initialization is the array itself, RVAL
2929 is a pointer to the first element. */
2934 /* Now convert make the result have the correct type. */
2941 }
2943 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
2944 build_delete. */
2946 static tree
2948 {
2949 tree name;
2950 tree fn;
2952 {
2967 }
2972 flags,
2974 tf_warning_or_error);
2975 }
2977 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
2978 ADDR is an expression which yields the store to be destroyed.
2979 AUTO_DELETE is the name of the destructor to call, i.e., either
2980 sfk_complete_destructor, sfk_base_destructor, or
2981 sfk_deleting_destructor.
2983 FLAGS is the logical disjunction of zero or more LOOKUP_
2984 flags. See cp-tree.h for more info. */
2986 tree
2989 {
2990 tree expr;
2995 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
2996 set to `error_mark_node' before it gets properly cleaned up. */
3003 {
3010 /* We don't want to warn about delete of void*, only other
3011 incomplete types. Deleting other incomplete types
3012 invokes undefined behavior, but it is not ill-formed, so
3013 compile to something that would even do The Right Thing
3014 (TM) should the type have a trivial dtor and no delete
3015 operator. */
3017 {
3020 {
3025 "operator delete will be called, even if they are "
3028 }
3029 }
3031 /* Call the builtin operator delete. */
3036 /* Throw away const and volatile on target type of addr. */
3038 }
3040 {
3041 handle_array:
3044 {
3047 }
3050 }
3051 else
3052 {
3053 /* Don't check PROTECT here; leave that decision to the
3054 destructor. If the destructor is accessible, call it,
3055 else report error. */
3061 }
3066 {
3072 use_global_delete,
3075 }
3076 else
3077 {
3080 tree ifexp;
3085 /* For `::delete x', we must not use the deleting destructor
3086 since then we would not be sure to get the global `operator
3087 delete'. */
3089 {
3090 /* We will use ADDR multiple times so we must save it. */
3093 /* Delete the object. */
3095 /* Otherwise, treat this like a complete object destructor
3096 call. */
3098 }
3099 /* If the destructor is non-virtual, there is no deleting
3100 variant. Instead, we must explicitly call the appropriate
3101 `operator delete' here. */
3104 {
3105 /* We will use ADDR multiple times so we must save it. */
3107 /* Build the call. */
3109 addr,
3114 /* Call the complete object destructor. */
3116 }
3119 {
3120 /* Make sure we have access to the member op delete, even though
3121 we'll actually be calling it from the destructor. */
3126 }
3129 tf_warning_or_error),
3134 /* We need to calculate this before the dtor changes the vptr. */
3139 /* Explicit destructor call; don't check for null pointer. */
3141 else
3142 /* Handle deleting a null pointer. */
3144 tf_warning_or_error));
3151 }
3152 }
3154 /* At the beginning of a destructor, push cleanups that will call the
3155 destructors for our base classes and members.
3157 Called from begin_destructor_body. */
3159 void
3161 {
3164 tree member;
3165 tree expr;
3168 /* Run destructors for all virtual baseclasses. */
3170 {
3171 tree cond = (condition_conversion
3173 current_in_charge_parm,
3174 integer_two_node)));
3176 /* The CLASSTYPE_VBASECLASSES vector is in initialization
3177 order, which is also the right order for pushing cleanups. */
3180 {
3182 {
3184 base_dtor_identifier,
3185 NULL_TREE,
3186 base_binfo,
3187 (LOOKUP_NORMAL
3189 tf_warning_or_error);
3193 }
3194 }
3195 }
3197 /* Take care of the remaining baseclasses. */
3200 {
3206 base_dtor_identifier,
3209 tf_warning_or_error);
3211 }
3215 {
3221 {
3222 tree this_member = (build_class_member_access_expr
3226 tf_warning_or_error));
3229 sfk_complete_destructor,
3233 }
3234 }
3235 }
3237 /* Build a C++ vector delete expression.
3238 MAXINDEX is the number of elements to be deleted.
3239 ELT_SIZE is the nominal size of each element in the vector.
3240 BASE is the expression that should yield the store to be deleted.
3241 This function expands (or synthesizes) these calls itself.
3242 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3244 This also calls delete for virtual baseclasses of elements of the vector.
3246 Update: MAXINDEX is no longer needed. The size can be extracted from the
3247 start of the vector for pointers, and from the type for arrays. We still
3248 use MAXINDEX for arrays because it happens to already have one of the
3249 values we'd have to extract. (We could use MAXINDEX with pointers to
3250 confirm the size, and trap if the numbers differ; not clear that it'd
3251 be worth bothering.) */
3253 tree
3256 {
3257 tree type;
3258 tree rval;
3264 {
3265 /* Step back one from start of vector, and read dimension. */
3266 tree cookie_addr;
3269 {
3272 }
3277 base,
3278 cookie_addr);
3280 }
3282 {
3283 /* Get the total number of things in the array, maxindex is a
3284 bad name. */
3289 {
3292 }
3293 }
3294 else
3295 {
3299 }
3302 use_global_delete);
3307 }