| blob | 871ddb5e68673c08e1502879068394b694713be7 |
1 /* Handle initialization things in C++.
2 Copyright (C) 1987-2015 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 /* High-level class interface. */
53 /* We are about to generate some complex initialization code.
54 Conceptually, it is all a single expression. However, we may want
55 to include conditionals, loops, and other such statement-level
56 constructs. Therefore, we build the initialization code inside a
57 statement-expression. This function starts such an expression.
58 STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
59 pass them back to finish_init_stmts when the expression is
60 complete. */
62 static bool
64 {
71 }
73 /* Finish out the statement-expression begun by the previous call to
74 begin_init_stmts. Returns the statement-expression itself. */
76 static tree
78 {
86 }
88 /* Constructors */
90 /* Called from initialize_vtbl_ptrs via dfs_walk. BINFO is the base
91 which we want to initialize the vtable pointer for, DATA is
92 TREE_LIST whose TREE_VALUE is the this ptr expression. */
94 static tree
96 {
101 {
105 tf_warning_or_error);
108 }
111 }
113 /* Initialize all the vtable pointers in the object pointed to by
114 ADDR. */
116 void
118 {
119 tree list;
120 tree type;
125 /* Walk through the hierarchy, initializing the vptr in each base
126 class. We do these in pre-order because we can't find the virtual
127 bases for a class until we've initialized the vtbl for that
128 class. */
130 }
132 /* Return an expression for the zero-initialization of an object with
133 type T. This expression will either be a constant (in the case
134 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
135 aggregate), or NULL (in the case that T does not require
136 initialization). In either case, the value can be used as
137 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
138 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
139 is the number of elements in the array. If STATIC_STORAGE_P is
140 TRUE, initializers are only generated for entities for which
141 zero-initialization does not simply mean filling the storage with
142 zero bytes. FIELD_SIZE, if non-NULL, is the bit size of the field,
143 subfields with bit positions at or above that bit size shouldn't
144 be added. Note that this only works when the result is assigned
145 to a base COMPONENT_REF; if we only have a pointer to the base subobject,
146 expand_assignment will end up clearing the full size of TYPE. */
148 static tree
150 tree field_size)
151 {
154 /* [dcl.init]
156 To zero-initialize an object of type T means:
158 -- if T is a scalar type, the storage is set to the value of zero
159 converted to T.
161 -- if T is a non-union class type, the storage for each nonstatic
162 data member and each base-class subobject is zero-initialized.
164 -- if T is a union type, the storage for its first data member is
165 zero-initialized.
167 -- if T is an array type, the storage for each element is
168 zero-initialized.
170 -- if T is a reference type, no initialization is performed. */
175 ;
177 /* In order to save space, we do not explicitly build initializers
178 for items that do not need them. GCC's semantics are that
179 items with static storage duration that are not otherwise
180 initialized are initialized to zero. */
181 ;
187 {
188 tree field;
191 /* Iterate over the fields, building initializations. */
193 {
200 /* Don't add virtual bases for base classes if they are beyond
201 the size of the current field, that means it is present
202 somewhere else in the object. */
204 {
209 }
211 /* Note that for class types there will be FIELD_DECLs
212 corresponding to base classes as well. Thus, iterating
213 over TYPE_FIELDs will result in correct initialization of
214 all of the subobjects. */
216 {
217 tree new_field_size
224 static_storage_p,
225 new_field_size);
228 }
230 /* For unions, only the first field is initialized. */
233 }
235 /* Build a constructor to contain the initializations. */
237 }
239 {
240 tree max_index;
243 /* Iterate over the array elements, building initializations. */
248 else
251 /* If we have an error_mark here, we should just return error mark
252 as we don't know the size of the array yet. */
257 /* A zero-sized array, which is accepted as an extension, will
258 have an upper bound of -1. */
260 {
261 constructor_elt ce;
263 /* If this is a one element array, we just use a regular init. */
266 else
268 max_index);
274 {
277 }
278 }
280 /* Build a constructor to contain the initializations. */
282 }
285 else
288 /* In all cases, the initializer is a constant. */
293 }
295 /* Return an expression for the zero-initialization of an object with
296 type T. This expression will either be a constant (in the case
297 that T is a scalar), or a CONSTRUCTOR (in the case that T is an
298 aggregate), or NULL (in the case that T does not require
299 initialization). In either case, the value can be used as
300 DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
301 initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
302 is the number of elements in the array. If STATIC_STORAGE_P is
303 TRUE, initializers are only generated for entities for which
304 zero-initialization does not simply mean filling the storage with
305 zero bytes. */
307 tree
309 {
311 }
313 /* Return a suitable initializer for value-initializing an object of type
314 TYPE, as described in [dcl.init]. */
316 tree
318 {
319 /* [dcl.init]
321 To value-initialize an object of type T means:
323 - if T is a class type (clause 9) with either no default constructor
324 (12.1) or a default constructor that is user-provided or deleted,
325 then then the object is default-initialized;
327 - if T is a (possibly cv-qualified) class type without a user-provided
328 or deleted default constructor, then the object is zero-initialized
329 and the semantic constraints for default-initialization are checked,
330 and if T has a non-trivial default constructor, the object is
331 default-initialized;
333 - if T is an array type, then each element is value-initialized;
335 - otherwise, the object is zero-initialized.
337 A program that calls for default-initialization or
338 value-initialization of an entity of reference type is ill-formed. */
340 /* The AGGR_INIT_EXPR tweaking below breaks in templates. */
346 {
347 tree ctor =
350 complain);
360 {
361 /* This is a class that needs constructing, but doesn't have
362 a user-provided constructor. So we need to zero-initialize
363 the object and then call the implicitly defined ctor.
364 This will be handled in simplify_aggr_init_expr. */
367 }
368 }
370 /* Discard any access checking during subobject initialization;
371 the checks are implied by the call to the ctor which we have
372 verified is OK (cpp0x/defaulted46.C). */
377 }
379 /* Like build_value_init, but don't call the constructor for TYPE. Used
380 for base initializers. */
382 tree
384 {
386 {
390 }
391 /* FIXME the class and array cases should just use digest_init once it is
392 SFINAE-enabled. */
394 {
399 {
400 tree field;
403 /* Iterate over the fields, building initializations. */
405 {
416 /* We could skip vfields and fields of types with
417 user-defined constructors, but I think that won't improve
418 performance at all; it should be simpler in general just
419 to zero out the entire object than try to only zero the
420 bits that actually need it. */
422 /* Note that for class types there will be FIELD_DECLs
423 corresponding to base classes as well. Thus, iterating
424 over TYPE_FIELDs will result in correct initialization of
425 all of the subobjects. */
434 /* We shouldn't have gotten here for anything that would need
435 non-trivial initialization, and gimplify_init_ctor_preeval
436 would need to be fixed to allow it. */
439 }
441 /* Build a constructor to contain the zero- initializations. */
443 }
444 }
446 {
449 /* Iterate over the array elements, building initializations. */
452 /* If we have an error_mark here, we should just return error mark
453 as we don't know the size of the array yet. */
455 {
458 type);
460 }
463 /* A zero-sized array, which is accepted as an extension, will
464 have an upper bound of -1. */
466 {
467 constructor_elt ce;
469 /* If this is a one element array, we just use a regular init. */
472 else
483 /* We shouldn't have gotten here for anything that would need
484 non-trivial initialization, and gimplify_init_ctor_preeval
485 would need to be fixed to allow it. */
488 }
490 /* Build a constructor to contain the initializations. */
492 }
494 {
498 }
500 {
504 }
507 }
509 /* Initialize current class with INIT, a TREE_LIST of
510 arguments for a target constructor. If TREE_LIST is void_type_node,
511 an empty initializer list was given. */
513 static void
515 {
521 tf_warning_or_error));
523 {
525 LOOKUP_NORMAL
526 |LOOKUP_NONVIRTUAL
532 }
533 }
535 /* Return the non-static data initializer for FIELD_DECL MEMBER. */
537 tree
539 {
540 tree init;
545 {
546 /* Use a PLACEHOLDER_EXPR when we don't have a 'this' parameter to
547 refer to; constexpr evaluation knows what to do with it. */
550 }
553 {
558 /* Check recursive instantiation. */
560 {
564 }
565 else
566 {
569 /* Do deferred instantiation of the NSDMI. */
570 init = (tsubst_copy_and_build
577 }
578 }
579 else
580 {
583 {
584 unparsed:
589 }
590 /* Strip redundant TARGET_EXPR so we don't need to remap it, and
591 so the aggregate init code below will see a CONSTRUCTOR. */
596 }
600 }
602 /* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of
603 arguments. If TREE_LIST is void_type_node, an empty initializer
604 list was given; if NULL_TREE no initializer was given. */
606 static void
608 {
609 tree decl;
612 /* Use the non-static data member initializer if there was no
613 mem-initializer for this field. */
620 /* Effective C++ rule 12 requires that all data members be
621 initialized. */
625 member);
627 /* Get an lvalue for the data member. */
631 tf_warning_or_error);
637 {
639 /* Handle references. */
646 member);
647 }
650 {
651 /* mem() means value-initialization. */
653 {
657 }
658 else
659 {
665 }
666 }
667 /* Deal with this here, as we will get confused if we try to call the
668 assignment op for an anonymous union. This can happen in a
669 synthesized copy constructor. */
671 {
673 {
676 }
677 }
680 /* Pre-digested NSDMI. */
683 /* { } mem-initializer. */
688 {
689 /* With references and list-initialization, we need to deal with
690 extending temporary lifetimes. 12.2p5: "A temporary bound to a
691 reference member in a constructor’s ctor-initializer (12.6.2)
692 persists until the constructor exits." */
697 tf_warning_or_error);
699 {
704 }
707 /* A FIELD_DECL doesn't really have a suitable lifetime, but
708 make_temporary_var_for_ref_to_temp will treat it as automatic and
709 set_up_extended_ref_temp wants to use the decl in a warning. */
719 }
722 {
724 {
726 {
729 else
733 }
737 {
741 }
742 else
744 }
745 else
746 {
753 {
754 /* TYPE_NEEDS_CONSTRUCTING can be set just because we have a
755 vtable; still give this diagnostic. */
760 }
762 tf_warning_or_error));
763 }
764 }
765 else
766 {
768 {
769 tree core_type;
770 /* member traversal: note it leaves init NULL */
772 {
777 }
779 {
784 }
794 }
796 /* There was an explicit member initialization. Do some work
797 in that case. */
799 tf_warning_or_error);
803 tf_warning_or_error));
804 }
807 {
808 tree expr;
813 tf_warning_or_error);
816 tf_warning_or_error);
821 }
822 }
824 /* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
825 the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order. */
827 static tree
829 {
830 tree fields;
832 /* Note whether or not T is a union. */
837 {
838 tree fieldtype;
840 /* Skip CONST_DECLs for enumeration constants and so forth. */
845 /* Keep track of whether or not any fields are unions. */
849 /* For an anonymous struct or union, we must recursively
850 consider the fields of the anonymous type. They can be
851 directly initialized from the constructor. */
853 {
854 /* Add this field itself. Synthesized copy constructors
855 initialize the entire aggregate. */
857 /* And now add the fields in the anonymous aggregate. */
859 }
860 /* Add this field. */
863 }
866 }
868 /* The MEM_INITS are a TREE_LIST. The TREE_PURPOSE of each list gives
869 a FIELD_DECL or BINFO in T that needs initialization. The
870 TREE_VALUE gives the initializer, or list of initializer arguments.
872 Return a TREE_LIST containing all of the initializations required
873 for T, in the order in which they should be performed. The output
874 list has the same format as the input. */
876 static tree
878 {
879 tree init;
881 tree sorted_inits;
882 tree next_subobject;
887 /* Build up a list of initializations. The TREE_PURPOSE of entry
888 will be the subobject (a FIELD_DECL or BINFO) to initialize. The
889 TREE_VALUE will be the constructor arguments, or NULL if no
890 explicit initialization was provided. */
893 /* Process the virtual bases. */
898 /* Process the direct bases. */
904 /* Process the non-static data members. */
906 /* Reverse the entire list of initializations, so that they are in
907 the order that they will actually be performed. */
910 /* If the user presented the initializers in an order different from
911 that in which they will actually occur, we issue a warning. Keep
912 track of the next subobject which can be explicitly initialized
913 without issuing a warning. */
916 /* Go through the explicit initializers, filling in TREE_PURPOSE in
917 the SORTED_INITS. */
919 {
920 tree subobject;
921 tree subobject_init;
925 /* If the explicit initializers are in sorted order, then
926 SUBOBJECT will be NEXT_SUBOBJECT, or something following
927 it. */
929 subobject_init;
934 /* Issue a warning if the explicit initializer order does not
935 match that which will actually occur.
936 ??? Are all these on the correct lines? */
938 {
942 else
947 else
951 }
953 /* Look again, from the beginning of the list. */
955 {
959 }
961 /* It is invalid to initialize the same subobject more than
962 once. */
964 {
968 subobject);
969 else
972 subobject);
973 }
975 /* Record the initialization. */
978 }
980 /* [class.base.init]
982 If a ctor-initializer specifies more than one mem-initializer for
983 multiple members of the same union (including members of
984 anonymous unions), the ctor-initializer is ill-formed.
986 Here we also splice out uninitialized union members. */
988 {
992 {
993 tree field;
994 tree ctx;
1000 /* Skip base classes. */
1004 /* If this is an anonymous union with no explicit initializer,
1005 splice it out. */
1009 /* See if this field is a member of a union, or a member of a
1010 structure contained in a union, etc. */
1017 /* If this field is not a member of a union, skip it. */
1021 /* If this union member has no explicit initializer and no NSDMI,
1022 splice it out. */
1025 else
1028 /* It's only an error if we have two initializers for the same
1029 union type. */
1031 {
1034 }
1036 /* See if LAST_FIELD and the field initialized by INIT are
1037 members of the same union. If so, there's a problem,
1038 unless they're actually members of the same structure
1039 which is itself a member of a union. For example, given:
1041 union { struct { int i; int j; }; };
1043 initializing both `i' and `j' makes sense. */
1048 {
1049 /* A mem-initializer hides an NSDMI. */
1054 else
1055 {
1058 ctx);
1060 }
1061 }
1065 next:
1068 splice:
1071 }
1072 }
1075 }
1077 /* Initialize all bases and members of CURRENT_CLASS_TYPE. MEM_INITS
1078 is a TREE_LIST giving the explicit mem-initializer-list for the
1079 constructor. The TREE_PURPOSE of each entry is a subobject (a
1080 FIELD_DECL or a BINFO) of the CURRENT_CLASS_TYPE. The TREE_VALUE
1081 is a TREE_LIST giving the arguments to the constructor or
1082 void_type_node for an empty list of arguments. */
1084 void
1086 {
1089 /* We will already have issued an error message about the fact that
1090 the type is incomplete. */
1097 {
1098 /* Delegating constructor. */
1102 }
1108 /* Sort the mem-initializers into the order in which the
1109 initializations should be performed. */
1114 /* Initialize base classes. */
1118 {
1122 /* We already have issued an error message. */
1127 {
1128 /* If these initializations are taking place in a copy constructor,
1129 the base class should probably be explicitly initialized if there
1130 is a user-defined constructor in the base class (other than the
1131 default constructor, which will be called anyway). */
1139 }
1141 /* Initialize the base. */
1144 else
1145 {
1146 tree base_addr;
1152 tf_warning_or_error),
1153 arguments,
1154 flags,
1155 tf_warning_or_error);
1157 }
1158 }
1161 /* Initialize the vptrs. */
1164 /* Initialize the data members. */
1166 {
1170 }
1171 }
1173 /* Returns the address of the vtable (i.e., the value that should be
1174 assigned to the vptr) for BINFO. */
1176 tree
1178 {
1180 tree vtbl;
1183 /* If this is a virtual primary base, then the vtable we want to store
1184 is that for the base this is being used as the primary base of. We
1185 can't simply skip the initialization, because we may be expanding the
1186 inits of a subobject constructor where the virtual base layout
1187 can be different. */
1191 /* Figure out what vtable BINFO's vtable is based on, and mark it as
1192 used. */
1196 /* Now compute the address to use when initializing the vptr. */
1202 }
1204 /* This code sets up the virtual function tables appropriate for
1205 the pointer DECL. It is a one-ply initialization.
1207 BINFO is the exact type that DECL is supposed to be. In
1208 multiple inheritance, this might mean "C's A" if C : A, B. */
1210 static void
1212 {
1214 tree vtt_index;
1216 /* Compute the initializer for vptr. */
1219 /* We may get this vptr from a VTT, if this is a subobject
1220 constructor or subobject destructor. */
1223 {
1224 tree vtbl2;
1225 tree vtt_parm;
1227 /* Compute the value to use, when there's a VTT. */
1233 /* The actual initializer is the VTT value only in the subobject
1234 constructor. In maybe_clone_body we'll substitute NULL for
1235 the vtt_parm in the case of the non-subobject constructor. */
1240 vtbl2,
1241 vtbl);
1242 }
1244 /* Compute the location of the vtpr. */
1246 tf_warning_or_error),
1250 /* Assign the vtable to the vptr. */
1253 tf_warning_or_error));
1254 }
1256 /* If an exception is thrown in a constructor, those base classes already
1257 constructed must be destroyed. This function creates the cleanup
1258 for BINFO, which has just been constructed. If FLAG is non-NULL,
1259 it is a DECL which is nonzero when this base needs to be
1260 destroyed. */
1262 static void
1264 {
1265 tree expr;
1270 /* Call the destructor. */
1272 base_dtor_identifier,
1273 NULL,
1274 binfo,
1276 tf_warning_or_error);
1288 }
1290 /* Construct the virtual base-class VBASE passing the ARGUMENTS to its
1291 constructor. */
1293 static void
1295 {
1296 tree inner_if_stmt;
1297 tree exp;
1298 tree flag;
1300 /* If there are virtual base classes with destructors, we need to
1301 emit cleanups to destroy them if an exception is thrown during
1302 the construction process. These exception regions (i.e., the
1303 period during which the cleanups must occur) begin from the time
1304 the construction is complete to the end of the function. If we
1305 create a conditional block in which to initialize the
1306 base-classes, then the cleanup region for the virtual base begins
1307 inside a block, and ends outside of that block. This situation
1308 confuses the sjlj exception-handling code. Therefore, we do not
1309 create a single conditional block, but one for each
1310 initialization. (That way the cleanup regions always begin
1311 in the outer block.) We trust the back end to figure out
1312 that the FLAG will not change across initializations, and
1313 avoid doing multiple tests. */
1318 /* Compute the location of the virtual base. If we're
1319 constructing virtual bases, then we must be the most derived
1320 class. Therefore, we don't have to look up the virtual base;
1321 we already know where it is. */
1330 }
1332 /* Find the context in which this FIELD can be initialized. */
1334 static tree
1336 {
1339 /* Anonymous union members can be initialized in the first enclosing
1340 non-anonymous union context. */
1344 }
1346 /* Function to give error message if member initialization specification
1347 is erroneous. FIELD is the member we decided to initialize.
1348 TYPE is the type for which the initialization is being performed.
1349 FIELD must be a member of TYPE.
1351 MEMBER_NAME is the name of the member. */
1353 static int
1355 {
1359 {
1361 member_name);
1363 }
1365 {
1368 field);
1370 }
1372 {
1376 }
1378 {
1380 member_name);
1382 }
1385 }
1387 /* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
1388 is a _TYPE node or TYPE_DECL which names a base for that type.
1389 Check the validity of NAME, and return either the base _TYPE, base
1390 binfo, or the FIELD_DECL of the member. If NAME is invalid, return
1391 NULL_TREE and issue a diagnostic.
1393 An old style unnamed direct single base construction is permitted,
1394 where NAME is NULL. */
1396 tree
1398 {
1399 tree basetype;
1400 tree field;
1406 {
1407 /* This is an obsolete unnamed base class initializer. The
1408 parser will already have warned about its use. */
1410 {
1413 current_class_type);
1416 basetype = BINFO_TYPE
1421 current_class_type);
1423 }
1424 }
1426 {
1429 }
1432 else
1436 {
1437 tree class_binfo;
1438 tree direct_binfo;
1439 tree virtual_binfo;
1450 /* Look for a direct base. */
1455 /* Look for a virtual base -- unless the direct base is itself
1456 virtual. */
1460 /* [class.base.init]
1462 If a mem-initializer-id is ambiguous because it designates
1463 both a direct non-virtual base class and an inherited virtual
1464 base class, the mem-initializer is ill-formed. */
1466 {
1468 basetype);
1470 }
1473 {
1477 else
1481 }
1484 }
1485 else
1486 {
1489 else
1494 }
1497 }
1499 /* This is like `expand_member_init', only it stores one aggregate
1500 value into another.
1502 INIT comes in two flavors: it is either a value which
1503 is to be stored in EXP, or it is a parameter list
1504 to go to a constructor, which will operate on EXP.
1505 If INIT is not a parameter list for a constructor, then set
1506 LOOKUP_ONLYCONVERTING.
1507 If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1508 the initializer, if FLAGS is 0, then it is the (init) form.
1509 If `init' is a CONSTRUCTOR, then we emit a warning message,
1510 explaining that such initializations are invalid.
1512 If INIT resolves to a CALL_EXPR which happens to return
1513 something of the type we are looking for, then we know
1514 that we can safely use that call to perform the
1515 initialization.
1517 The virtual function table pointer cannot be set up here, because
1518 we do not really know its type.
1520 This never calls operator=().
1522 When initializing, nothing is CONST.
1524 A default copy constructor may have to be used to perform the
1525 initialization.
1527 A constructor or a conversion operator may have to be used to
1528 perform the initialization, but not both, as it would be ambiguous. */
1530 tree
1532 {
1533 tree stmt_expr;
1534 tree compound_stmt;
1555 {
1556 tree itype;
1558 /* An array may not be initialized use the parenthesized
1559 initialization form -- unless the initializer is "()". */
1561 {
1565 }
1566 /* Must arrange to initialize each element of EXP
1567 from elements of INIT. */
1577 complain);
1581 /* Restore the type of init unless it was used directly. */
1585 }
1589 /* Just know that we've seen something for this node. */
1603 }
1605 static void
1607 tsubst_flags_t complain)
1608 {
1610 tree ctor_name;
1612 /* It fails because there may not be a constructor which takes
1613 its own type as the first (or only parameter), but which does
1614 take other types via a conversion. So, if the thing initializing
1615 the expression is a unit element of type X, first try X(X&),
1616 followed by initialization by X. If neither of these work
1617 out, then look hard. */
1618 tree rval;
1621 /* If we have direct-initialization from an initializer list, pull
1622 it out of the TREE_LIST so the code below can see it. */
1625 {
1629 }
1633 /* A brace-enclosed initializer for an aggregate. In C++0x this can
1634 happen for direct-initialization, too. */
1635 {
1638 }
1640 /* A CONSTRUCTOR of the target's type is a previously digested
1641 initializer, whether that happened just above or in
1642 cp_parser_late_parsing_nsdmi.
1644 A TARGET_EXPR with TARGET_EXPR_DIRECT_INIT_P or TARGET_EXPR_LIST_INIT_P
1645 set represents the whole initialization, so we shouldn't build up
1646 another ctor call. */
1653 {
1654 /* Early initialization via a TARGET_EXPR only works for
1655 complete objects. */
1662 }
1666 {
1667 /* Base subobjects should only get direct-initialization. */
1671 /* Do nothing. We hit this in two cases: Reference initialization,
1672 where we aren't initializing a real variable, so we don't want
1673 to run a new constructor; and catching an exception, where we
1674 have already built up the constructor call so we could wrap it
1676 else
1681 /* We need to protect the initialization of a catch parm with a
1682 call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
1683 around the TARGET_EXPR for the copy constructor. See
1684 initialize_handler_parm. */
1685 {
1689 }
1690 else
1695 }
1700 {
1704 }
1705 else
1710 {
1711 /* Delegating constructor. */
1712 tree complete;
1713 tree base;
1716 /* Unshare the arguments for the second call. */
1719 {
1722 }
1725 complain);
1731 complain);
1736 base,
1737 complete);
1738 }
1739 else
1740 {
1743 else
1746 complain);
1747 }
1753 {
1756 {
1760 }
1761 }
1763 /* FIXME put back convert_to_void? */
1766 }
1768 /* This function is responsible for initializing EXP with INIT
1769 (if any).
1771 BINFO is the binfo of the type for who we are performing the
1772 initialization. For example, if W is a virtual base class of A and B,
1773 and C : A, B.
1774 If we are initializing B, then W must contain B's W vtable, whereas
1775 were we initializing C, W must contain C's W vtable.
1777 TRUE_EXP is nonzero if it is the true expression being initialized.
1778 In this case, it may be EXP, or may just contain EXP. The reason we
1779 need this is because if EXP is a base element of TRUE_EXP, we
1780 don't necessarily know by looking at EXP where its virtual
1781 baseclass fields should really be pointing. But we do know
1782 from TRUE_EXP. In constructors, we don't know anything about
1783 the value being initialized.
1785 FLAGS is just passed to `build_new_method_call'. See that function
1786 for its description. */
1788 static void
1790 tsubst_flags_t complain)
1791 {
1797 /* Use a function returning the desired type to initialize EXP for us.
1798 If the function is a constructor, and its first argument is
1799 NULL_TREE, know that it was meant for us--just slide exp on
1800 in and expand the constructor. Constructors now come
1801 as TARGET_EXPRs. */
1805 {
1807 /* If store_init_value returns NULL_TREE, the INIT has been
1808 recorded as the DECL_INITIAL for EXP. That means there's
1809 nothing more we have to do. */
1815 }
1817 /* If an explicit -- but empty -- initializer list was present,
1818 that's value-initialization. */
1820 {
1821 /* If the type has data but no user-provided ctor, we need to zero
1822 out the object. */
1825 {
1828 /* Don't clobber already initialized virtual bases. */
1831 field_size);
1834 }
1836 /* If we don't need to mess with the constructor at all,
1837 then we're done. */
1841 /* Otherwise fall through and call the constructor. */
1843 }
1845 /* We know that expand_default_init can handle everything we want
1846 at this point. */
1848 }
1850 /* Report an error if TYPE is not a user-defined, class type. If
1851 OR_ELSE is nonzero, give an error message. */
1853 int
1855 {
1860 {
1864 }
1866 }
1868 tree
1870 {
1876 else
1878 }
1880 /* Build a reference to a member of an aggregate. This is not a C++
1881 `&', but really something which can have its address taken, and
1882 then act as a pointer to member, for example TYPE :: FIELD can have
1883 its address taken by saying & TYPE :: FIELD. ADDRESS_P is true if
1884 this expression is the operand of "&".
1886 @@ Prints out lousy diagnostics for operator <typename>
1887 @@ fields.
1889 @@ This function should be rewritten and placed in search.c. */
1891 tree
1893 tsubst_flags_t complain)
1894 {
1895 tree decl;
1898 /* class templates can come in as TEMPLATE_DECLs here. */
1911 /* Callers should call mark_used before this point. */
1916 {
1920 }
1922 /* Entities other than non-static members need no further
1923 processing. */
1930 {
1934 }
1936 /* Set up BASEBINFO for member lookup. */
1939 /* A lot of this logic is now handled in lookup_member. */
1941 {
1942 /* Go from the TREE_BASELINK to the member function info. */
1946 {
1947 /* Get rid of a potential OVERLOAD around it. */
1950 /* Unique functions are handled easily. */
1952 /* For non-static member of base class, we need a special rule
1953 for access checking [class.protected]:
1955 If the access is to form a pointer to member, the
1956 nested-name-specifier shall name the derived class
1957 (or any class derived from that class). */
1961 complain);
1962 else
1964 complain);
1969 }
1970 else
1972 }
1974 /* We need additional test besides the one in
1975 check_accessibility_of_qualified_id in case it is
1976 a pointer to non-static member. */
1978 complain);
1981 {
1982 /* If MEMBER is non-static, then the program has fallen afoul of
1983 [expr.prim]:
1985 An id-expression that denotes a nonstatic data member or
1986 nonstatic member function of a class can only be used:
1988 -- as part of a class member access (_expr.ref_) in which the
1989 object-expression refers to the member's class or a class
1990 derived from that class, or
1992 -- to form a pointer to member (_expr.unary.op_), or
1994 -- in the body of a nonstatic member function of that class or
1995 of a class derived from that class (_class.mfct.nonstatic_), or
1997 -- in a mem-initializer for a constructor for that class or for
1998 a class derived from that class (_class.base.init_). */
2000 {
2001 /* Build a representation of the qualified name suitable
2002 for use as the operand to "&" -- even though the "&" is
2003 not actually present. */
2005 /* In Microsoft mode, treat a non-static member function as if
2006 it were a pointer-to-member. */
2008 {
2011 }
2016 }
2018 {
2022 }
2024 }
2029 }
2031 /* If DECL is a scalar enumeration constant or variable with a
2032 constant initializer, return the initializer (or, its initializers,
2033 recursively); otherwise, return DECL. If STRICT_P, the
2034 initializer is only returned if DECL is a
2035 constant-expression. If RETURN_AGGREGATE_CST_OK_P, it is ok to
2036 return an aggregate constant. */
2038 static tree
2040 {
2042 || (strict_p
2046 {
2047 tree init;
2048 /* If DECL is a static data member in a template
2049 specialization, we must instantiate it here. The
2050 initializer for the static data member is not processed
2051 until needed; we need it now. */
2056 {
2058 /* Treat the error as a constant to avoid cascading errors on
2059 excessively recursive template instantiation (c++/9335). */
2061 else
2063 }
2064 /* Initializers in templates are generally expanded during
2065 instantiation, so before that for const int i(2)
2066 INIT is a TREE_LIST with the actual initializer as
2067 TREE_VALUE. */
2069 && init
2076 || (!return_aggregate_cst_ok_p
2077 /* Unless RETURN_AGGREGATE_CST_OK_P is true, do not
2078 return an aggregate constant (of which string
2079 literals are a special case), as we do not want
2080 to make inadvertent copies of such entities, and
2081 we must be sure that their addresses are the
2082 same everywhere. */
2087 }
2089 }
2091 /* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by constant
2092 of integral or enumeration type, or a constexpr variable of scalar type,
2093 then return that value. These are those variables permitted in constant
2094 expressions by [5.19/1]. */
2096 tree
2098 {
2101 }
2103 /* Like scalar_constant_value, but can also return aggregate initializers. */
2105 tree
2107 {
2110 }
2112 /* A more relaxed version of scalar_constant_value, used by the
2113 common C/C++ code. */
2115 tree
2117 {
2120 }
2121 \f
2122 /* Common subroutines of build_new and build_vec_delete. */
2123 \f
2124 /* Build and return a NEW_EXPR. If NELTS is non-NULL, TYPE[NELTS] is
2125 the type of the object being allocated; otherwise, it's just TYPE.
2126 INIT is the initializer, if any. USE_GLOBAL_NEW is true if the
2127 user explicitly wrote "::operator new". PLACEMENT, if non-NULL, is
2128 a vector of arguments to be provided as arguments to a placement
2129 new operator. This routine performs no semantic checks; it just
2130 creates and returns a NEW_EXPR. */
2132 static tree
2135 {
2136 tree init_list;
2137 tree new_expr;
2139 /* If INIT is NULL, the we want to store NULL_TREE in the NEW_EXPR.
2140 If INIT is not NULL, then we want to store VOID_ZERO_NODE. This
2141 permits us to distinguish the case of a missing initializer "new
2142 int" from an empty initializer "new int()". */
2147 else
2152 init_list);
2157 }
2159 /* Diagnose uninitialized const members or reference members of type
2160 TYPE. USING_NEW is used to disambiguate the diagnostic between a
2161 new expression without a new-initializer and a declaration. Returns
2162 the error count. */
2164 static int
2167 {
2168 tree field;
2175 {
2176 tree field_type;
2187 {
2190 {
2192 {
2196 else
2198 }
2199 else
2200 {
2205 else
2208 }
2211 }
2212 }
2215 {
2218 {
2220 {
2224 else
2226 }
2227 else
2228 {
2233 else
2236 }
2239 }
2240 }
2243 error_count
2246 }
2248 }
2250 int
2252 {
2254 }
2256 /* Call __cxa_bad_array_new_length to indicate that the size calculation
2257 overflowed. Pretend it returns sizetype so that it plays nicely in the
2258 COND_EXPR. */
2260 tree
2262 {
2266 NULL_TREE));
2269 }
2271 /* Generate code for a new-expression, including calling the "operator
2272 new" function, initializing the object, and, if an exception occurs
2273 during construction, cleaning up. The arguments are as for
2274 build_raw_new_expr. This may change PLACEMENT and INIT. */
2276 static tree
2279 tsubst_flags_t complain)
2280 {
2282 /* True iff this is a call to "operator new[]" instead of just
2283 "operator new". */
2285 /* If ARRAY_P is true, the element type of the array. This is never
2286 an ARRAY_TYPE; for something like "new int[3][4]", the
2287 ELT_TYPE is "int". If ARRAY_P is false, this is the same type as
2288 TYPE. */
2289 tree elt_type;
2290 /* The type of the new-expression. (This type is always a pointer
2291 type.) */
2292 tree pointer_type;
2293 tree non_const_pointer_type;
2295 /* For arrays, a bounds checks on the NELTS parameter. */
2300 /* Size of the inner array elements. */
2301 offset_int inner_size;
2302 /* The address returned by the call to "operator new". This node is
2303 a VAR_DECL and is therefore reusable. */
2304 tree alloc_node;
2305 tree alloc_fn;
2309 /* If non-NULL, the number of extra bytes to allocate at the
2310 beginning of the storage allocated for an array-new expression in
2311 order to store the number of elements. */
2313 tree placement_first;
2315 /* True if the function we are calling is a placement allocation
2316 function. */
2318 /* True if the storage must be initialized, either by a constructor
2319 or due to an explicit new-initializer. */
2321 /* The address of the thing allocated, not including any cookie. In
2322 particular, if an array cookie is in use, DATA_ADDR is the
2323 address of the first array element. This node is a VAR_DECL, and
2324 is therefore reusable. */
2325 tree data_addr;
2330 {
2333 }
2335 {
2336 /* Transforms new (T[N]) to new T[N]. The former is a GNU
2337 extension for variable N. (This also covers new T where T is
2338 a VLA typedef.) */
2344 }
2346 /* If our base type is an array, then make sure we know how many elements
2347 it has. */
2351 {
2355 {
2360 {
2364 }
2366 }
2367 else
2368 {
2370 {
2374 }
2376 }
2380 inner_nelts_cst,
2381 complain);
2382 }
2385 {
2388 }
2393 /* Warn if we performed the (T[N]) to T[N] transformation and N is
2394 variable. */
2397 {
2399 {
2404 else
2409 }
2410 else
2412 }
2415 {
2419 }
2427 {
2429 /* A program that calls for default-initialization [...] of an
2430 entity of reference type is ill-formed. */
2434 /* A new-expression that creates an object of type T initializes
2435 that object as follows:
2436 - If the new-initializer is omitted:
2437 -- If T is a (possibly cv-qualified) non-POD class type
2438 (or array thereof), the object is default-initialized (8.5).
2439 [...]
2440 -- Otherwise, the object created has indeterminate
2441 value. If T is a const-qualified type, or a (possibly
2442 cv-qualified) POD class type (or array thereof)
2443 containing (directly or indirectly) a member of
2444 const-qualified type, the program is ill-formed; */
2454 }
2458 {
2462 }
2466 {
2467 /* Maximum available size in bytes. Half of the address space
2468 minus the cookie size. */
2469 offset_int max_size
2471 /* Maximum number of outer elements which can be allocated. */
2472 offset_int max_outer_nelts;
2473 tree max_outer_nelts_tree;
2479 /* Unconditionally subtract the cookie size. This decreases the
2480 maximum object size and is safe even if we choose not to use
2481 a cookie after all. */
2487 {
2491 }
2494 /* Only keep the top-most seven bits, to simplify encoding the
2495 constant in the instruction stream. */
2496 {
2500 shift);
2501 }
2506 outer_nelts,
2507 max_outer_nelts_tree);
2508 }
2512 /* If PLACEMENT is a single simple pointer type not passed by
2513 reference, prepare to capture it in a temporary variable. Do
2514 this now, since PLACEMENT will change in the calls below. */
2520 /* Allocate the object. */
2522 {
2523 tree class_addr;
2524 tree class_decl;
2528 {
2531 }
2540 {
2544 }
2546 {
2550 }
2555 }
2557 {
2560 }
2561 else
2562 {
2563 tree fnname;
2564 tree fns;
2570 && (array_p
2573 {
2574 /* Use a class-specific operator new. */
2575 /* If a cookie is required, add some extra space. */
2578 else
2579 {
2581 /* No size arithmetic necessary, so the size check is
2582 not needed. */
2585 }
2586 /* Perform the overflow check. */
2593 /* Create the argument list. */
2595 /* Do name-lookup to find the appropriate operator. */
2598 {
2602 }
2604 {
2606 {
2609 }
2611 }
2615 LOOKUP_NORMAL,
2617 complain);
2618 }
2619 else
2620 {
2621 /* Use a global operator new. */
2622 /* See if a cookie might be required. */
2624 {
2626 /* No size arithmetic necessary, so the size check is
2627 not needed. */
2630 }
2634 outer_nelts_check,
2636 }
2637 }
2644 /* If we found a simple case of PLACEMENT_EXPR above, then copy it
2645 into a temporary variable. */
2652 {
2657 {
2661 }
2662 }
2664 /* In the simple case, we can stop now. */
2669 /* Store the result of the allocation call in a variable so that we can
2670 use it more than once. */
2674 /* Strip any COMPOUND_EXPRs from ALLOC_CALL. */
2678 /* Now, check to see if this function is actually a placement
2679 allocation function. This can happen even when PLACEMENT is NULL
2680 because we might have something like:
2682 struct S { void* operator new (size_t, int i = 0); };
2684 A call to `new S' will get this allocation function, even though
2685 there is no explicit placement argument. If there is more than
2686 one argument, or there are variable arguments, then this is a
2687 placement allocation function. */
2688 placement_allocation_fn_p
2692 /* Preevaluate the placement args so that we don't reevaluate them for a
2693 placement delete. */
2695 {
2696 tree inits;
2700 alloc_expr);
2701 }
2703 /* unless an allocation function is declared with an empty excep-
2704 tion-specification (_except.spec_), throw(), it indicates failure to
2705 allocate storage by throwing a bad_alloc exception (clause _except_,
2706 _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2707 cation function is declared with an empty exception-specification,
2708 throw(), it returns null to indicate failure to allocate storage and a
2709 non-null pointer otherwise.
2711 So check for a null exception spec on the op new we just called. */
2717 {
2718 tree cookie;
2719 tree cookie_ptr;
2720 tree size_ptr_type;
2722 /* Adjust so we're pointing to the start of the object. */
2725 /* Store the number of bytes allocated so that we can know how
2726 many elements to destroy later. We use the last sizeof
2727 (size_t) bytes to store the number of elements. */
2738 {
2739 /* Also store the element size. */
2750 }
2751 }
2752 else
2753 {
2756 }
2758 /* Now use a pointer to the type we've actually allocated. */
2760 /* But we want to operate on a non-const version to start with,
2761 since we'll be modifying the elements. */
2762 non_const_pointer_type = build_pointer_type
2766 /* Any further uses of alloc_node will want this type, too. */
2769 /* Now initialize the allocated object. Note that we preevaluate the
2770 initialization expression, apart from the actual constructor call or
2771 assignment--we do this because we want to delay the allocation as long
2772 as possible in order to minimize the size of the exception region for
2773 placement delete. */
2775 {
2780 {
2783 }
2786 {
2787 /* build_value_init doesn't work in templates, and we don't need
2788 the initializer anyway since we're going to throw it away and
2789 rebuild it at instantiation time, so just build up a single
2790 constructor call to get any appropriate diagnostics. */
2794 complete_ctor_identifier,
2796 LOOKUP_NORMAL,
2797 complain);
2799 }
2801 {
2805 {
2809 else
2810 {
2814 complain);
2815 else
2816 /* We'll check the length at runtime. */
2820 }
2821 }
2823 {
2827 else
2830 }
2831 init_expr
2835 integer_one_node,
2836 complain),
2837 vecinit,
2838 explicit_value_init_p,
2840 complain);
2842 /* An array initialization is stable because the initialization
2843 of each element is a full-expression, so the temporaries don't
2844 leak out. */
2846 }
2847 else
2848 {
2852 {
2854 complete_ctor_identifier,
2856 LOOKUP_NORMAL,
2857 complain);
2858 }
2860 {
2861 /* Something like `new int()'. */
2866 }
2867 else
2868 {
2869 tree ie;
2871 /* We are processing something like `new int (10)', which
2872 means allocate an int, and initialize it with 10. */
2875 complain);
2877 complain);
2878 }
2880 }
2885 /* If any part of the object initialization terminates by throwing an
2886 exception and a suitable deallocation function can be found, the
2887 deallocation function is called to free the memory in which the
2888 object was being constructed, after which the exception continues
2889 to propagate in the context of the new-expression. If no
2890 unambiguous matching deallocation function can be found,
2891 propagating the exception does not cause the object's memory to be
2892 freed. */
2894 {
2896 tree cleanup;
2898 /* The Standard is unclear here, but the right thing to do
2899 is to use the same method for finding deallocation
2900 functions that we use for finding allocation functions. */
2901 cleanup = (build_op_delete_call
2903 alloc_node,
2904 size,
2905 globally_qualified_p,
2907 alloc_fn,
2908 complain));
2913 /* This is much simpler if we were able to preevaluate all of
2914 the arguments to the constructor call. */
2915 {
2916 /* CLEANUP is compiler-generated, so no diagnostics. */
2920 /* Likewise, this try-catch is compiler-generated. */
2922 }
2923 else
2924 /* Ack! First we allocate the memory. Then we set our sentry
2925 variable to true, and expand a cleanup that deletes the
2926 memory if sentry is true. Then we run the constructor, and
2927 finally clear the sentry.
2929 We need to do this because we allocate the space first, so
2930 if there are any temporaries with cleanups in the
2931 constructor args and we weren't able to preevaluate them, we
2932 need this EH region to extend until end of full-expression
2933 to preserve nesting. */
2934 {
2942 /* CLEANUP is compiler-generated, so no diagnostics. */
2952 init_expr
2955 end));
2956 /* Likewise, this is compiler-generated. */
2958 }
2959 }
2960 }
2961 else
2964 /* Now build up the return value in reverse order. */
2974 /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
2975 and return the call (which doesn't need to be adjusted). */
2977 else
2978 {
2980 {
2983 nullptr_node,
2984 complain);
2987 }
2989 /* Perform the allocation before anything else, so that ALLOC_NODE
2990 has been initialized before we start using it. */
2992 }
2997 /* A new-expression is never an lvalue. */
3001 }
3003 /* Generate a representation for a C++ "new" expression. *PLACEMENT
3004 is a vector of placement-new arguments (or NULL if none). If NELTS
3005 is NULL, TYPE is the type of the storage to be allocated. If NELTS
3006 is not NULL, then this is an array-new allocation; TYPE is the type
3007 of the elements in the array and NELTS is the number of elements in
3008 the array. *INIT, if non-NULL, is the initializer for the new
3009 object, or an empty vector to indicate an initializer of "()". If
3010 USE_GLOBAL_NEW is true, then the user explicitly wrote "::new"
3011 rather than just "new". This may change PLACEMENT and INIT. */
3013 tree
3016 {
3017 tree rval;
3026 /* Don't do auto deduction where it might affect mangling. */
3028 {
3031 {
3035 }
3036 }
3039 {
3046 use_global_new);
3057 }
3060 {
3062 {
3065 else
3067 }
3070 }
3072 /* ``A reference cannot be created by the new operator. A reference
3073 is not an object (8.2.2, 8.4.3), so a pointer to it could not be
3074 returned by new.'' ARM 5.3.3 */
3076 {
3079 else
3082 }
3085 {
3089 }
3091 /* The type allocated must be complete. If the new-type-id was
3092 "T[N]" then we are just checking that "T" is complete here, but
3093 that is equivalent, since the value of "N" doesn't matter. */
3102 {
3108 }
3110 /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain. */
3115 }
3117 /* Given a Java class, return a decl for the corresponding java.lang.Class. */
3119 tree
3121 {
3127 {
3130 {
3133 }
3135 }
3137 /* Mangle the class$ field. */
3138 {
3139 tree field;
3142 {
3146 }
3148 {
3151 }
3152 }
3156 {
3166 }
3168 }
3169 \f
3170 static tree
3172 special_function_kind auto_delete_vec,
3174 {
3175 tree virtual_size;
3177 tree size_exp;
3179 /* Temporary variables used by the loop. */
3182 /* This is the body of the loop that implements the deletion of a
3183 single element, and moves temp variables to next elements. */
3184 tree body;
3186 /* This is the LOOP_EXPR that governs the deletion of the elements. */
3189 /* This is the thing that governs what to do after the loop has run. */
3192 /* This is the BIND_EXPR which holds the outermost iterator of the
3193 loop. It is convenient to set this variable up and test it before
3194 executing any other code in the loop.
3195 This is also the containing expression returned by this function. */
3197 tree tmp;
3199 /* We should only have 1-D arrays here. */
3206 {
3209 "possible problem detected in invocation of "
3211 {
3214 "class-specific operator delete [] will be called, "
3216 }
3217 /* This size won't actually be used. */
3220 }
3227 {
3228 /* Make sure the destructor is callable. */
3230 {
3233 complain);
3236 }
3238 }
3240 /* The below is short by the cookie size. */
3245 tbase_init
3249 base),
3250 virtual_size),
3251 complain);
3269 complain);
3277 no_destructor:
3278 /* Delete the storage if appropriate. */
3280 {
3281 tree base_tbd;
3283 /* The below is short by the cookie size. */
3288 /* no header */
3290 else
3291 {
3292 tree cookie_size;
3296 MINUS_EXPR,
3299 cookie_size,
3300 complain);
3304 /* True size with header. */
3306 }
3313 complain);
3314 }
3318 ;
3321 else
3327 /* Outermost wrapper: If pointer is null, punt. */
3332 nullptr_node)),
3337 {
3340 }
3343 /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */
3347 }
3349 /* Create an unnamed variable of the indicated TYPE. */
3351 tree
3353 {
3354 tree decl;
3364 }
3366 /* Create a new temporary variable of the indicated TYPE, initialized
3367 to INIT.
3369 It is not entered into current_binding_level, because that breaks
3370 things when it comes time to do final cleanups (which take place
3371 "outside" the binding contour of the function). */
3373 tree
3375 {
3376 tree decl;
3382 tf_warning_or_error));
3385 }
3387 /* Subroutine of build_vec_init. Returns true if assigning to an array of
3388 INNER_ELT_TYPE from INIT is trivial. */
3390 static bool
3392 {
3397 }
3399 /* `build_vec_init' returns tree structure that performs
3400 initialization of a vector of aggregate types.
3402 BASE is a reference to the vector, of ARRAY_TYPE, or a pointer
3403 to the first element, of POINTER_TYPE.
3404 MAXINDEX is the maximum index of the array (one less than the
3405 number of elements). It is only used if BASE is a pointer or
3406 TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
3408 INIT is the (possibly NULL) initializer.
3410 If EXPLICIT_VALUE_INIT_P is true, then INIT must be NULL. All
3411 elements in the array are value-initialized.
3413 FROM_ARRAY is 0 if we should init everything with INIT
3414 (i.e., every element initialized from INIT).
3415 FROM_ARRAY is 1 if we should index into INIT in parallel
3416 with initialization of DECL.
3417 FROM_ARRAY is 2 if we should index into INIT in parallel,
3418 but use assignment instead of initialization. */
3420 tree
3424 {
3425 tree rval;
3428 tree iterator;
3429 /* The type of BASE. */
3431 /* The type of an element in the array. */
3433 /* The element type reached after removing all outer array
3434 types. */
3435 tree inner_elt_type;
3436 /* The type of a pointer to an element in the array. */
3437 tree ptype;
3438 tree stmt_expr;
3439 tree compound_stmt;
3459 /* Look through the TARGET_EXPR around a compound literal. */
3465 /* If we have a braced-init-list, make sure that the array
3466 is big enough for all the initializers. */
3478 /* Don't do this if the CONSTRUCTOR might contain something
3479 that might throw and require us to clean up. */
3483 {
3484 /* Do non-default initialization of trivial arrays resulting from
3485 brace-enclosed initializers. In this case, digest_init and
3486 store_constructor will handle the semantics for us. */
3492 }
3496 {
3502 }
3503 else
3506 /* The code we are generating looks like:
3507 ({
3508 T* t1 = (T*) base;
3509 T* rval = t1;
3510 ptrdiff_t iterator = maxindex;
3511 try {
3512 for (; iterator != -1; --iterator) {
3513 ... initialize *t1 ...
3514 ++t1;
3515 }
3516 } catch (...) {
3517 ... destroy elements that were constructed ...
3518 }
3519 rval;
3520 })
3522 We can omit the try and catch blocks if we know that the
3523 initialization will never throw an exception, or if the array
3524 elements do not have destructors. We can omit the loop completely if
3525 the elements of the array do not have constructors.
3527 We actually wrap the entire body of the above in a STMT_EXPR, for
3528 tidiness.
3530 When copying from array to another, when the array elements have
3531 only trivial copy constructors, we should use __builtin_memcpy
3532 rather than generating a loop. That way, we could take advantage
3533 of whatever cleverness the back end has for dealing with copies
3534 of blocks of memory. */
3543 /* If initializing one array from another, initialize element by
3544 element. We rely upon the below calls to do the argument
3545 checking. Evaluate the initializer before entering the try block. */
3547 {
3556 }
3558 /* Protect the entire array initialization so that we can destroy
3559 the partially constructed array if an exception is thrown.
3560 But don't do this if we're assigning. */
3563 {
3565 }
3567 /* Should we try to create a constant initializer? */
3571 : (type_has_constexpr_default_constructor
3577 /* If we're initializing a static array, we want to do static
3578 initialization of any elements with constant initializers even if
3579 some are non-constant. */
3585 /* Skip over the handling of non-empty init lists. */
3588 /* Maybe pull out constant value when from_array? */
3591 {
3592 /* Do non-default initialization of non-trivial arrays resulting from
3593 brace-enclosed initializers. */
3596 /* If the constructor already has the array type, it's been through
3597 digest_init, so we shouldn't try to do anything more. */
3602 {
3605 {
3607 {
3609 nelts);
3613 }
3614 /* Don't check an array new when -fno-exceptions. */
3615 }
3618 {
3619 /* Make sure the last element of the initializer is in bounds. */
3620 finish_expr_stmt
3621 (ubsan_instrument_bounds
3623 }
3624 }
3630 {
3632 tree one_init;
3634 num_initialized_elts++;
3641 else
3647 {
3650 {
3654 else
3656 }
3657 else
3658 {
3660 {
3665 }
3667 }
3668 }
3677 else
3681 complain);
3684 else
3686 }
3688 /* Any elements without explicit initializers get T{}. */
3690 }
3692 {
3697 {
3701 }
3702 }
3704 /* Now, default-initialize any remaining elements. We don't need to
3705 do that if a) the type does not need constructing, or b) we've
3706 already initialized all the elements.
3708 We do need to keep going if we're copying an array. */
3711 /* With a constexpr default constructor, which we checked for when
3712 setting try_const above, default-initialization is equivalent to
3713 value-initialization, and build_value_init gives us something more
3714 friendly to maybe_constant_init. */
3719 && (num_initialized_elts
3721 {
3722 /* If the ITERATOR is equal to -1, then we don't have to loop;
3723 we've already initialized all the elements. */
3724 tree for_stmt;
3725 tree elt_init;
3726 tree to;
3734 complain);
3741 /* If the initializer is {}, then all elements are initialized from T{}.
3742 But for non-classes, that's the same as value-initialization. */
3744 {
3746 {
3748 }
3749 else
3750 {
3753 }
3754 }
3757 {
3758 tree from;
3761 {
3765 }
3766 else
3771 complain);
3776 complain);
3777 else
3779 }
3781 {
3783 sorry
3787 explicit_value_init_p,
3789 }
3791 {
3795 }
3796 else
3797 {
3801 else
3802 {
3805 complain);
3807 }
3808 }
3814 {
3815 /* FIXME refs to earlier elts */
3818 {
3820 /* Don't fill the CONSTRUCTOR with zeros. */
3824 }
3825 else
3826 {
3830 else
3832 }
3835 {
3838 {
3841 }
3842 }
3843 }
3851 complain));
3854 complain));
3857 }
3859 /* Make sure to cleanup any partially constructed elements. */
3862 {
3863 tree e;
3866 complain);
3868 /* Flatten multi-dimensional array since build_vec_delete only
3869 expects one-dimensional array. */
3873 /* Avoid mixing signed and unsigned. */
3876 complain);
3885 }
3887 /* The value of the array initialization is the array itself, RVAL
3888 is a pointer to the first element. */
3899 {
3901 {
3904 }
3907 else
3909 }
3911 /* Now make the result have the correct type. */
3913 {
3918 }
3921 }
3923 /* Call the DTOR_KIND destructor for EXP. FLAGS are as for
3924 build_delete. */
3926 static tree
3928 tsubst_flags_t complain)
3929 {
3930 tree name;
3931 tree fn;
3933 {
3948 }
3953 flags,
3955 complain);
3956 }
3958 /* Generate a call to a destructor. TYPE is the type to cast ADDR to.
3959 ADDR is an expression which yields the store to be destroyed.
3960 AUTO_DELETE is the name of the destructor to call, i.e., either
3961 sfk_complete_destructor, sfk_base_destructor, or
3962 sfk_deleting_destructor.
3964 FLAGS is the logical disjunction of zero or more LOOKUP_
3965 flags. See cp-tree.h for more info. */
3967 tree
3970 {
3971 tree expr;
3978 /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3979 set to `error_mark_node' before it gets properly cleaned up. */
3987 {
3989 {
3993 }
3996 }
3999 {
4002 /* We don't want to warn about delete of void*, only other
4003 incomplete types. Deleting other incomplete types
4004 invokes undefined behavior, but it is not ill-formed, so
4005 compile to something that would even do The Right Thing
4006 (TM) should the type have a trivial dtor and no delete
4007 operator. */
4009 {
4012 {
4015 "possible problem detected in invocation of "
4017 {
4020 "neither the destructor nor the class-specific "
4021 "operator delete will be called, even if they are "
4023 }
4024 }
4028 {
4029 tree dtor;
4032 {
4035 "deleting object of abstract class type %qT"
4036 " which has non-virtual destructor"
4038 else
4040 "deleting object of polymorphic class type %qT"
4041 " which has non-virtual destructor"
4043 }
4044 }
4045 }
4049 /* Throw away const and volatile on target type of addr. */
4051 }
4052 else
4053 {
4054 /* Don't check PROTECT here; leave that decision to the
4055 destructor. If the destructor is accessible, call it,
4056 else report error. */
4064 }
4067 {
4068 /* Make sure the destructor is callable. */
4070 {
4072 complain),
4076 }
4083 use_global_delete,
4086 complain);
4087 }
4088 else
4089 {
4092 tree ifexp;
4097 /* For `::delete x', we must not use the deleting destructor
4098 since then we would not be sure to get the global `operator
4099 delete'. */
4101 {
4102 /* We will use ADDR multiple times so we must save it. */
4105 /* Delete the object. */
4107 head,
4112 complain);
4113 /* Otherwise, treat this like a complete object destructor
4114 call. */
4116 }
4117 /* If the destructor is non-virtual, there is no deleting
4118 variant. Instead, we must explicitly call the appropriate
4119 `operator delete' here. */
4122 {
4123 /* We will use ADDR multiple times so we must save it. */
4125 /* Build the call. */
4127 addr,
4132 complain);
4133 /* Call the complete object destructor. */
4135 }
4138 {
4139 /* Make sure we have access to the member op delete, even though
4140 we'll actually be calling it from the destructor. */
4145 complain);
4146 }
4155 /* We need to calculate this before the dtor changes the vptr. */
4160 /* Explicit destructor call; don't check for null pointer. */
4162 else
4163 {
4164 /* Handle deleting a null pointer. */
4167 complain));
4170 }
4176 }
4177 }
4179 /* At the beginning of a destructor, push cleanups that will call the
4180 destructors for our base classes and members.
4182 Called from begin_destructor_body. */
4184 void
4186 {
4189 tree member;
4190 tree expr;
4193 /* Run destructors for all virtual baseclasses. */
4195 {
4196 tree cond = (condition_conversion
4198 current_in_charge_parm,
4199 integer_two_node)));
4201 /* The CLASSTYPE_VBASECLASSES vector is in initialization
4202 order, which is also the right order for pushing cleanups. */
4205 {
4207 {
4209 base_dtor_identifier,
4210 NULL,
4211 base_binfo,
4212 (LOOKUP_NORMAL
4214 tf_warning_or_error);
4216 {
4220 }
4221 }
4222 }
4223 }
4225 /* Take care of the remaining baseclasses. */
4228 {
4234 base_dtor_identifier,
4237 tf_warning_or_error);
4240 }
4242 /* Don't automatically destroy union members. */
4248 {
4257 {
4258 tree this_member = (build_class_member_access_expr
4262 tf_warning_or_error));
4264 sfk_complete_destructor,
4269 }
4270 }
4271 }
4273 /* Build a C++ vector delete expression.
4274 MAXINDEX is the number of elements to be deleted.
4275 ELT_SIZE is the nominal size of each element in the vector.
4276 BASE is the expression that should yield the store to be deleted.
4277 This function expands (or synthesizes) these calls itself.
4278 AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
4280 This also calls delete for virtual baseclasses of elements of the vector.
4282 Update: MAXINDEX is no longer needed. The size can be extracted from the
4283 start of the vector for pointers, and from the type for arrays. We still
4284 use MAXINDEX for arrays because it happens to already have one of the
4285 values we'd have to extract. (We could use MAXINDEX with pointers to
4286 confirm the size, and trap if the numbers differ; not clear that it'd
4287 be worth bothering.) */
4289 tree
4291 special_function_kind auto_delete_vec,
4293 {
4294 tree type;
4295 tree rval;
4301 {
4302 /* Step back one from start of vector, and read dimension. */
4303 tree cookie_addr;
4308 {
4311 }
4316 cookie_addr);
4318 }
4320 {
4321 /* Get the total number of things in the array, maxindex is a
4322 bad name. */
4329 {
4332 }
4333 }
4334 else
4335 {
4339 }
4347 }