| blob | 2ec3448d6365ce717613496143f17e14218664d6 |
1 /* Functions related to building classes and their related objects.
2 Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 /* High-level class interface. */
38 #define obstack_chunk_alloc xmalloc
39 #define obstack_chunk_free free
41 /* The number of nested classes being processed. If we are not in the
42 scope of any class, this is zero. */
46 /* In order to deal with nested classes, we keep a stack of classes.
47 The topmost entry is the innermost class, and is the entry at index
48 CURRENT_CLASS_DEPTH */
51 /* The name of the class. */
52 tree name;
54 /* The _TYPE node for the class. */
55 tree type;
57 /* The access specifier pending for new declarations in the scope of
58 this class. */
59 tree access;
61 /* If were defining TYPE, the names used in this class. */
62 splay_tree names_used;
66 {
67 /* The base for which we're building initializers. */
68 tree binfo;
69 /* The type of the most-derived type. */
70 tree derived;
71 /* The binfo for the dynamic type. This will be TYPE_BINFO (derived),
72 unless ctor_vtbl_p is true. */
73 tree rtti_binfo;
74 /* The negative-index vtable initializers built up so far. These
75 are in order from least negative index to most negative index. */
76 tree inits;
77 /* The last (i.e., most negative) entry in INITS. */
79 /* The binfo for the virtual base for which we're building
80 vcall offset initializers. */
81 tree vbase;
82 /* The functions in vbase for which we have already provided vcall
83 offsets. */
84 varray_type fns;
85 /* The vtable index of the next vcall or vbase offset. */
86 tree index;
87 /* Nonzero if we are building the initializer for the primary
88 vtable. */
90 /* Nonzero if we are building the initializer for a construction
91 vtable. */
95 /* The type of a function passed to walk_subobject_offsets. */
98 /* The stack itself. This is an dynamically resized array. The
99 number of elements allocated is CURRENT_CLASS_STACK_SIZE. */
103 /* An array of all local classes present in this translation unit, in
104 declaration order. */
105 varray_type local_classes;
189 tree));
193 vtbl_init_data *));
219 splay_tree_key k2));
222 /* Macros for dfs walking during vtt construction. See
223 dfs_ctor_vtable_bases_queue_p, dfs_build_secondary_vptr_vtt_inits
224 and dfs_fixup_binfo_vtbls. */
225 #define VTT_TOP_LEVEL_P(node) TREE_UNSIGNED(node)
226 #define VTT_MARKED_BINFO_P(node) TREE_USED(node)
228 /* Variables shared between class.c and call.c. */
230 #ifdef GATHER_STATISTICS
239 #endif
241 /* Virtual base class layout. */
243 /* Returns a list of virtual base class pointers as a chain of
244 FIELD_DECLS. */
246 static tree
248 record_layout_info rli;
250 {
251 /* Chain to hold all the new FIELD_DECLs which point at virtual
252 base classes. */
257 tree decl;
260 /* Under the new ABI, there are no vbase pointers in the object.
261 Instead, the offsets are stored in the vtable. */
265 /* Loop over the baseclasses, adding vbase pointers as needed. */
267 {
272 /* This error is now reported in xref_tag, thus giving better
273 location information. */
276 /* All basetypes are recorded in the association list of the
277 derived type. */
280 {
284 /* The offset for a virtual base class is only used in computing
285 virtual function tables and for initializing virtual base
286 pointers. It is built once `get_vbase_types' is called. */
288 /* If this basetype can come from another vbase pointer
289 without an additional indirection, we will share
290 that pointer. If an indirection is involved, we
291 make our own pointer. */
293 {
298 }
303 rec,
304 basetype,
305 empty_p);
312 got_it:
313 /* The space this decl occupies has already been accounted for. */
314 ;
315 }
316 }
319 }
321 /* Returns a pointer to the virtual base class of EXP that has the
322 indicated TYPE. EXP is of class type, not a pointer type. */
324 static tree
327 {
329 {
330 tree vbase;
331 tree vbase_ptr;
333 /* Find the shared copy of TYPE; that's where the vtable offset
334 is recorded. */
336 /* Find the virtual function table pointer. */
338 /* Compute the location where the offset will lie. */
341 vbase_ptr,
345 vbase_ptr);
346 /* Add the contents of this location to EXP. */
351 }
352 else
353 {
357 }
358 }
360 /* Build multi-level access to EXPR using hierarchy path PATH.
361 CODE is PLUS_EXPR if we are going with the grain,
362 and MINUS_EXPR if we are not (in which case, we cannot traverse
363 virtual baseclass links).
365 TYPE is the type we want this path to have on exit.
367 NONNULL is non-zero if we know (for any reason) that EXPR is
368 not, in fact, zero. */
370 tree
375 {
380 tree basetype;
386 /* We could do better if we had additional logic to convert back to the
387 unconverted type (the static type of the complete object), and then
388 convert back to the type we want. Until that is done, we only optimize
389 if the complete type is the same type as expr has. */
392 /* Virtual base layout is not fixed, even in ctors and dtors. */
404 {
406 {
409 {
413 {
414 tree ind;
416 /* We already check for ambiguous things in the caller, just
417 find a path. */
419 {
422 }
428 {
432 integer_zero_node),
434 }
435 }
436 /* else we'll figure out the offset below. */
438 /* Happens in the case of parse errors. */
441 }
442 else
443 {
445 last_virtual);
447 }
448 }
451 }
452 /* LAST is now the last basetype assoc on the path. */
454 /* A pointer to a virtual base member of a non-null object
455 is non-null. Therefore, we only need to test for zeroness once.
456 Make EXPR the canonical expression to deal with here. */
458 {
462 }
463 else
466 /* If we go through any virtual base pointers, make sure that
467 casts to BASETYPE from the last virtual base class use
468 the right value for BASETYPE. */
470 {
474 offset
476 }
477 else
481 {
482 /* Bash types to make the backend happy. */
485 /* If expr might be 0, we need to preserve that zeroness. */
487 {
490 else
497 null_expr,
499 }
501 }
503 /* Cannot change the TREE_TYPE of a NOP_EXPR here, since it may
504 be used multiple times in initialization of multiple inheritance. */
506 {
509 }
510 else
512 }
514 \f
515 /* Virtual function things. */
517 /* We want to give the assembler the vtable identifier as well as
518 the offset to the function pointer. So we generate
520 __asm__ __volatile__ (".vtable_entry %c0, %c1"
521 : : "s"(&class_vtable),
522 "i"((long)&vtbl[idx].pfn - (long)&vtbl[0])); */
524 static void
527 {
546 }
548 /* Given an object INSTANCE, return an expression which yields the
549 virtual function vtable element corresponding to INDEX. There are
550 many special cases for INSTANCE which we take care of here, mainly
551 to avoid creating extra tree nodes when we don't have to. */
553 tree
556 {
565 else
566 {
568 {
569 /* Try to figure out what a reference refers to, and
570 access its virtual function table directly. */
581 {
588 {
594 }
595 }
596 }
602 {
604 /* Knowing the dynamic type of INSTANCE we can easily obtain
605 the correct vtable entry. In the new ABI, we resolve
606 this back to be in terms of the primary vtable. */
608 {
611 idx,
617 }
618 }
619 else
621 }
631 }
633 /* Given an object INSTANCE, return an expression which yields the
634 virtual function corresponding to INDEX. There are many special
635 cases for INSTANCE which we take care of here, mainly to avoid
636 creating extra tree nodes when we don't have to. */
638 tree
641 tree idx;
642 {
645 /* When using thunks, there is no extra delta, and we get the pfn
646 directly. */
651 {
652 /* Save the intermediate result in a SAVE_EXPR so we don't have to
653 compute each component of the virtual function pointer twice. */
657 *ptr_to_instptr
662 }
665 }
667 /* Return the name of the virtual function table (as an IDENTIFIER_NODE)
668 for the given TYPE. */
670 static tree
672 tree type;
673 {
675 }
677 /* Return an IDENTIFIER_NODE for the name of the virtual table table
678 for TYPE. */
680 tree
682 tree type;
683 {
685 }
687 /* Create a VAR_DECL for a primary or secondary vtable for CLASS_TYPE.
688 (For a secondary vtable for B-in-D, CLASS_TYPE should be D, not B.)
689 Use NAME for the name of the vtable, and VTABLE_TYPE for its type. */
691 static tree
693 tree class_type;
694 tree name;
695 tree vtable_type;
696 {
697 tree decl;
700 /* vtable names are already mangled; give them their DECL_ASSEMBLER_NAME
701 now to avoid confusion in mangle_decl. */
711 }
713 /* Get the VAR_DECL of the vtable for TYPE. TYPE need not be polymorphic,
714 or even complete. If this does not exist, create it. If COMPLETE is
715 non-zero, then complete the definition of it -- that will render it
716 impossible to actually build the vtable, but is useful to get at those
717 which are known to exist in the runtime. */
719 tree
721 tree type;
723 {
728 {
732 }
739 /* At one time the vtable info was grabbed 2 words at a time. This
740 fails on sparc unless you have 8-byte alignment. (tiemann) */
745 {
748 }
751 }
753 /* Returns a copy of the BINFO_VIRTUALS list in BINFO. The
754 BV_VCALL_INDEX for each entry is cleared. */
756 static tree
758 tree binfo;
759 {
760 tree copies;
761 tree t;
765 {
768 }
771 }
773 /* Build the primary virtual function table for TYPE. If BINFO is
774 non-NULL, build the vtable starting with the initial approximation
775 that it is the same as the one which is the head of the association
776 list. Returns a non-zero value if a new vtable is actually
777 created. */
779 static int
782 {
783 tree decl;
784 tree virtuals;
789 {
791 /* We have already created a vtable for this base, so there's
792 no need to do it again. */
799 }
800 else
801 {
805 }
807 #ifdef GATHER_STATISTICS
810 #endif
812 /* Initialize the association list for this type, based
813 on our first approximation. */
818 }
820 /* Give TYPE a new virtual function table which is initialized
821 with a skeleton-copy of its original initialization. The only
822 entry that changes is the `delta' entry, so we can really
823 share a lot of structure.
825 FOR_TYPE is the derived type which caused this table to
826 be needed.
828 BINFO is the type association which provided TYPE for FOR_TYPE.
830 The order in which vtables are built (by calling this function) for
831 an object must remain the same, otherwise a binary incompatibility
832 can result. */
834 static int
837 {
838 tree basetype;
840 tree name;
841 tree new_decl;
842 tree offset;
849 #ifdef JOINER
851 #endif
855 current_class_type),
859 /* We already created a vtable for this base. There's no need to
860 do it again. */
863 /* Remember that we've created a vtable for this BINFO, so that we
864 don't try to do so again. */
867 /* Make fresh virtual list, so we can smash it later. */
873 /* In the new ABI, secondary vtables are laid out as part of the
874 same structure as the primary vtable. */
876 {
879 }
881 /* Create the declaration for the secondary vtable. */
886 /* We know that the vtable that we are going to create doesn't exist
887 yet in the global namespace, and when we finish, it will be
888 pushed into the global namespace. In complex MI hierarchies, we
889 have to loop while the name we are thinking of adding is globally
890 defined, adding more name components to the vtable name as we
891 loop, until the name is unique. This is because in complex MI
892 cases, we might have the same base more than once. This means
893 that the order in which this function is called for vtables must
894 remain the same, otherwise binary compatibility can be
895 compromised. */
898 {
904 buf2);
909 /* If this name doesn't clash, then we can use it, otherwise
910 we add more to the name until it is unique. */
915 /* Set values for next loop through, if the name isn't unique. */
919 /* We better not run out of stuff to make it unique. */
925 {
926 /* If we run out of basetypes in the path, we have already
927 found created a vtable with that name before, we now
928 resort to tacking on _%d to distinguish them. */
941 /* If this name doesn't clash, then we can use it,
942 otherwise we add something different to the name until
943 it is unique. */
946 /* Hey, they really like MI don't they? Increase the 3
947 above to 6, and the 999 to 999999. :-) */
951 }
958 }
965 #ifdef GATHER_STATISTICS
968 #endif
971 }
973 /* Create a new vtable for BINFO which is the hierarchy dominated by
974 T. */
976 static int
978 tree t;
979 tree binfo;
980 {
982 /* In this case, it is *type*'s vtable we are modifying. We start
983 with the approximation that its vtable is that of the
984 immediate base class. */
985 /* ??? This actually passes TYPE_BINFO (t), not the primary base binfo,
986 since we've updated DECL_CONTEXT (TYPE_VFIELD (t)) by now. */
988 t);
989 else
990 /* This is our very own copy of `basetype' to play with. Later,
991 we will fill in all the virtual functions that override the
992 virtual functions in these base classes which are not defined
993 by the current type. */
995 }
997 /* Make *VIRTUALS, an entry on the BINFO_VIRTUALS list for BINFO
998 (which is in the hierarchy dominated by T) list FNDECL as its
999 BV_FN. DELTA is the required constant adjustment from the `this'
1000 pointer where the vtable entry appears to the `this' required when
1001 the function is actually called. */
1003 static void
1005 tree t;
1006 tree binfo;
1007 tree fndecl;
1008 tree delta;
1010 {
1011 tree v;
1017 {
1018 tree base_fndecl;
1020 /* We need a new vtable for BINFO. */
1022 {
1023 /* If we really did make a new vtable, we also made a copy
1024 of the BINFO_VIRTUALS list. Now, we have to find the
1025 corresponding entry in that list. */
1030 }
1037 /* Now assign virtual dispatch information, if unset. We can
1038 dispatch this through any overridden base function.
1040 FIXME this can choose a secondary vtable if the primary is not
1041 also lexically first, leading to useless conversions.
1042 In the V3 ABI, there's no reason for DECL_VIRTUAL_CONTEXT to
1043 ever be different from DECL_CONTEXT. */
1045 {
1048 }
1049 }
1050 }
1052 /* Set DECL_VINDEX for DECL. VINDEX_P is the number of virtual
1053 functions present in the vtable so far. */
1055 static void
1057 tree decl;
1059 {
1064 }
1066 /* Add a virtual function to all the appropriate vtables for the class
1067 T. DECL_VINDEX(X) should be error_mark_node, if we want to
1068 allocate a new slot in our table. If it is error_mark_node, we
1069 know that no other function from another vtable is overridden by X.
1070 VFUNS_P keeps track of how many virtuals there are in our
1071 main vtable for the type, and we build upon the NEW_VIRTUALS list
1072 and return it. */
1074 static void
1080 tree fndecl;
1082 {
1083 tree new_virtual;
1085 /* If this function doesn't override anything from a base class, we
1086 can just assign it a new DECL_VINDEX now. Otherwise, if it does
1087 override something, we keep it around and assign its DECL_VINDEX
1088 later, in modify_all_vtables. */
1090 /* We've already dealt with this function. */
1098 {
1099 /* FNDECL is a new virtual function; it doesn't override any
1100 virtual function in a base class. */
1102 /* We remember that this was the base sub-object for rtti. */
1105 /* Now assign virtual dispatch information. */
1109 /* Save the state we've computed on the NEW_VIRTUALS list. */
1112 }
1113 else
1114 {
1115 /* FNDECL overrides a function from a base class. */
1118 }
1119 }
1120 \f
1121 /* Add method METHOD to class TYPE. If ERROR_P is true, we are adding
1122 the method after the class has already been defined because a
1123 declaration for it was seen. (Even though that is erroneous, we
1124 add the method for improved error recovery.) */
1126 void
1128 tree type;
1129 tree method;
1131 {
1135 tree method_vec;
1138 /* Make a new method vector. We start with 8 entries. We must
1139 allocate at least two (for constructors and destructors), and
1140 we're going to end up with an assignment operator at some point
1141 as well.
1143 We could use a TREE_LIST for now, and convert it to a TREE_VEC
1144 in finish_struct, but we would probably waste more memory
1145 making the links in the list than we would by over-allocating
1146 the size of the vector here. Furthermore, we would complicate
1147 all the code that expects this to be a vector. */
1153 /* Constructors and destructors go in special slots. */
1158 else
1159 {
1160 /* See if we already have an entry with this name. */
1164 slot)))
1169 {
1170 /* We need a bigger method vector. */
1172 tree new_vec;
1174 /* In the non-error case, we are processing a class
1175 definition. Double the size of the vector to give room
1176 for new methods. */
1179 /* In the error case, the vector is already complete. We
1180 don't expect many errors, and the rest of the front-end
1181 will get confused if there are empty slots in the vector. */
1182 else
1190 }
1193 {
1194 /* Type conversion operators have to come before ordinary
1195 methods; add_conversions depends on this to speed up
1196 looking for conversion operators. So, if necessary, we
1197 slide some of the vector elements up. In theory, this
1198 makes this algorithm O(N^2) but we don't expect many
1199 conversion operators. */
1201 {
1205 /* There are no more entries in the vector, so we
1206 can insert the new conversion operator here. */
1210 /* We can insert the new function right at the
1211 SLOTth position. */
1213 }
1216 /* There is nothing in the Ith slot, so we can avoid
1217 moving anything. */
1218 ;
1219 else
1220 {
1221 /* We know the last slot in the vector is empty
1222 because we know that at this point there's room
1223 for a new function. */
1228 }
1229 }
1230 }
1233 /* TYPE is a template class. Don't issue any errors now; wait
1234 until instantiation time to complain. */
1235 ;
1236 else
1237 {
1238 tree fns;
1240 /* Check to see if we've already got this method. */
1242 fns;
1244 {
1251 {
1252 /* [over.load] Member function declarations with the
1253 same name and the same parameter types cannot be
1254 overloaded if any of them is a static member
1255 function declaration. */
1259 {
1269 {
1271 /* Defer to the local function. */
1273 else
1276 }
1277 }
1278 }
1283 /* There has already been a declaration of this method
1284 or member template. */
1288 /* We don't call duplicate_decls here to merge the
1289 declarations because that will confuse things if the
1290 methods have inline definitions. In particular, we
1291 will crash while processing the definitions. */
1293 }
1294 }
1296 /* Actually insert the new method. */
1300 /* Add the new binding. */
1305 }
1307 /* Subroutines of finish_struct. */
1309 /* Look through the list of fields for this struct, deleting
1310 duplicates as we go. This must be recursive to handle
1311 anonymous unions.
1313 FIELD is the field which may not appear anywhere in FIELDS.
1314 FIELD_PTR, if non-null, is the starting point at which
1315 chained deletions may take place.
1316 The value returned is the first acceptable entry found
1317 in FIELDS.
1319 Note that anonymous fields which are not of UNION_TYPE are
1320 not duplicates, they are just anonymous fields. This happens
1321 when we have unnamed bitfields, for example. */
1323 static tree
1326 {
1327 tree x;
1330 {
1337 }
1338 else
1339 {
1341 {
1343 {
1349 {
1352 else
1354 }
1355 }
1357 /* A using declaration may is allowed to appear more than
1358 once. We'll prune these from the field list later, and
1359 handle_using_decl will complain about invalid multiple
1360 uses. */
1361 ;
1363 {
1370 x);
1373 {
1377 }
1380 {
1381 /* Hide tag decls. */
1388 x);
1389 }
1390 else
1394 else
1396 }
1397 }
1398 }
1400 }
1402 static void
1404 tree fields;
1405 {
1406 tree x;
1409 }
1411 /* Change the access of FDECL to ACCESS in T. Return 1 if change was
1412 legit, otherwise return 0. */
1414 static int
1416 tree t;
1417 tree fdecl;
1418 tree access;
1419 {
1420 tree elem;
1430 {
1432 {
1435 else
1438 }
1439 else
1440 {
1441 /* They're changing the access to the same thing they changed
1442 it to before. That's OK. */
1443 ;
1444 }
1445 }
1446 else
1447 {
1451 }
1453 }
1455 /* Process the USING_DECL, which is a member of T. */
1457 static void
1459 tree using_decl;
1460 tree t;
1461 {
1464 tree access
1470 tree old_value;
1478 {
1481 }
1484 {
1487 }
1492 {
1495 }
1498 /* Ignore base type this came from. */
1503 {
1509 else
1511 }
1517 ;
1519 {
1521 /* It's OK to use functions from a base when there are functions with
1523 else
1524 {
1529 }
1530 }
1532 {
1536 }
1538 /* Make type T see field decl FDECL with access ACCESS.*/
1541 {
1544 }
1545 else
1547 }
1548 \f
1549 /* Run through the base clases of T, updating
1550 CANT_HAVE_DEFAULT_CTOR_P, CANT_HAVE_CONST_CTOR_P, and
1551 NO_CONST_ASN_REF_P. Also set flag bits in T based on properties of
1552 the bases. */
1554 static void
1556 no_const_asn_ref_p)
1557 tree t;
1561 {
1565 tree binfos;
1571 /* An aggregate cannot have baseclasses. */
1575 {
1576 tree base_binfo;
1577 tree basetype;
1579 /* Figure out what base we're looking at. */
1583 /* If the type of basetype is incomplete, then we already
1584 complained about that fact (and we should have fixed it up as
1585 well). */
1587 {
1589 /* The base type is of incomplete type. It is
1590 probably best to pretend that it does not
1591 exist. */
1599 }
1601 /* Effective C++ rule 14. We only need to check TYPE_POLYMORPHIC_P
1602 here because the case of virtual functions but non-virtual
1603 dtor is handled in finish_struct_1. */
1607 basetype);
1609 /* If the base class doesn't have copy constructors or
1610 assignment operators that take const references, then the
1611 derived class cannot have such a member automatically
1612 generated. */
1618 /* Similarly, if the base class doesn't have a default
1619 constructor, then the derived class won't have an
1620 automatically generated default constructor. */
1623 {
1627 basetype);
1628 }
1631 /* A virtual base does not effect nearly emptiness. */
1632 ;
1634 {
1636 /* And if there is more than one nearly empty base, then the
1637 derived class is not nearly empty either. */
1639 else
1640 /* Remember we've seen one. */
1642 }
1644 /* If the base class is not empty or nearly empty, then this
1645 class cannot be nearly empty. */
1648 /* A lot of properties from the bases also apply to the derived
1649 class. */
1660 }
1661 }
1663 /* Binfo FROM is within a virtual heirarchy which is being reseated to
1664 TO. Move primary information from FROM to TO, and recursively traverse
1665 into FROM's bases. The heirarchy is dominated by TYPE. MAPPINGS is an
1666 assoc list of binfos that have already been reseated. */
1668 static void
1670 tree to;
1671 tree from;
1672 tree type;
1673 tree mappings;
1674 {
1685 {
1687 tree assoc;
1689 /* We might have just moved the primary base too, see if it's on our
1690 mappings. */
1696 }
1701 {
1706 {
1709 /* This base is a primary of some binfo we have already
1710 reseated. We must reseat this one too. */
1712 }
1713 else
1715 }
1716 }
1718 /* FROM is the canonical binfo for a virtual base. It is being reseated to
1719 make TO the canonical binfo, within the heirarchy dominated by TYPE.
1720 MAPPINGS is an assoc list of binfos that have already been reseated.
1721 Adjust any non-virtual bases within FROM, and also move any virtual bases
1722 which are canonical. This complication arises because selecting primary
1723 bases walks in inheritance graph order, but we don't share binfos for
1724 virtual bases, hence we can fill in the primaries for a virtual base,
1725 and then discover that a later base requires the virtual as its
1726 primary. */
1728 static void
1730 tree to;
1731 tree from;
1732 tree type;
1733 tree mappings;
1734 {
1739 }
1741 /* Make BASE_BINFO the primary virtual base of BINFO within the hierarchy
1742 dominated by TYPE. Returns BASE_BINFO, if it can be made so, NULL
1743 otherwise (because something else has already made it primary). */
1745 static tree
1747 tree binfo;
1748 tree base_binfo;
1749 tree type;
1750 {
1752 tree delta;
1755 {
1756 /* It's already allocated in the hierarchy. BINFO won't have a
1757 primary base in this hierachy, even though the complete object
1758 BINFO is for, would do. */
1762 }
1764 /* We need to make sure that the assoc list
1765 CLASSTYPE_VBASECLASSES of TYPE, indicates this particular
1766 primary BINFO for the virtual base, as this is the one
1767 that'll really exist. */
1773 {
1776 }
1778 }
1780 /* If BINFO is an unmarked virtual binfo for a class with a primary virtual
1781 base, then BINFO has no primary base in this graph. Called from
1782 mark_primary_bases. DATA is the most derived type. */
1785 tree binfo;
1787 {
1792 {
1793 /* This morally virtual base has a primary base when it
1794 is a complete object. We need to locate the shared instance
1795 of this binfo in the type dominated by T. We duplicate the
1796 primary base information from there to here. */
1797 tree vbase;
1798 tree unshared_base;
1805 t));
1810 }
1813 /* The vtable fields will have been copied when duplicating the
1814 base binfos. That information is bogus, make sure we don't try
1815 and use it. */
1820 }
1822 /* Set BINFO_PRIMARY_BASE_OF for all binfos in the hierarchy
1823 dominated by TYPE that are primary bases. */
1825 static void
1827 tree type;
1828 {
1829 tree binfo;
1831 /* Walk the bases in inheritance graph order. */
1833 {
1834 tree base_binfo;
1837 /* Not a dynamic base. */
1849 }
1850 /* There could remain unshared morally virtual bases which were not visited
1851 in the inheritance graph walk. These bases will have lost their
1852 virtual primary base (should they have one). We must now find them. */
1854 }
1856 /* Make the BINFO the primary base of T. */
1858 static void
1860 tree t;
1861 tree binfo;
1863 {
1864 tree basetype;
1873 }
1875 /* Determine the primary class for T. */
1877 static void
1879 tree t;
1881 {
1883 tree vbases;
1884 tree type_binfo;
1886 /* If there are no baseclasses, there is certainly no primary base. */
1893 {
1898 {
1899 /* Even a virtual baseclass can contain our RTTI
1900 information. But, we prefer a non-virtual polymorphic
1901 baseclass. */
1905 /* A virtual baseclass can't be the primary base under the
1906 old ABI. And under the new ABI we still prefer a
1907 non-virtual base. */
1912 {
1915 }
1916 else
1917 {
1918 tree vfields;
1920 /* Only add unique vfields, and flatten them out as we go. */
1922 vfields;
1930 }
1931 }
1932 }
1937 /* Find the indirect primary bases - those virtual bases which are primary
1938 bases of something else in this hierarchy. */
1940 vbases;
1942 {
1945 /* See if this virtual base is an indirect primary base. To be so,
1946 it must be a primary base within the hierarchy of one of our
1947 direct bases. */
1949 {
1951 tree v;
1954 v;
1956 {
1962 {
1965 }
1966 }
1968 /* If we've discovered that this virtual base is an indirect
1969 primary base, then we can move on to the next virtual
1970 base. */
1973 }
1974 }
1976 /* The new ABI allows for the use of a "nearly-empty" virtual base
1977 class as the primary base class if no non-virtual polymorphic
1978 base can be found. */
1980 {
1981 /* If not NULL, this is the best primary base candidate we have
1982 found so far. */
1984 tree base_binfo;
1986 /* Loop over the baseclasses. */
1988 base_binfo;
1990 {
1995 {
1996 /* If this is not an indirect primary base, then it's
1997 definitely our primary base. */
1999 {
2002 }
2004 /* If this is an indirect primary base, it still could be
2005 our primary base -- unless we later find there's another
2006 nearly-empty virtual base that isn't an indirect
2007 primary base. */
2010 }
2011 }
2013 /* If we've got a primary base, use it. */
2015 {
2019 }
2020 }
2022 /* Mark the primary base classes at this point. */
2024 }
2025 \f
2026 /* Set memoizing fields and bits of T (and its variants) for later
2027 use. */
2029 static void
2031 tree t;
2032 {
2035 /* Fix up variants (if any). */
2038 {
2039 /* These fields are in the _TYPE part of the node, not in
2040 the TYPE_LANG_SPECIFIC component, so they are not shared. */
2051 /* Copy whatever these are holding today. */
2058 }
2061 /* For a class w/o baseclasses, `finish_struct' has set
2062 CLASS_TYPE_ABSTRACT_VIRTUALS correctly (by
2063 definition). Similarly for a class whose base classes do not
2064 have vtables. When neither of these is true, we might have
2065 removed abstract virtuals (by providing a definition), added
2066 some (by declaring new ones), or redeclared ones from a base
2067 class. We need to recalculate what's really an abstract virtual
2068 at this point (by looking in the vtables). */
2072 {
2073 /* Notice whether this class has type conversion functions defined. */
2076 tree basetype;
2079 {
2083 }
2084 }
2086 /* If this type has a copy constructor, force its mode to be BLKmode, and
2087 force its TREE_ADDRESSABLE bit to be nonzero. This will cause it to
2088 be passed by invisible reference and prevent it from being returned in
2089 a register.
2091 Also do this if the class has BLKmode but can still be returned in
2092 registers, since function_cannot_inline_p won't let us inline
2093 functions returning such a type. This affects the HP-PA. */
2097 {
2098 tree variants;
2101 {
2104 }
2105 }
2106 }
2108 /* Issue warnings about T having private constructors, but no friends,
2109 and so forth.
2111 HAS_NONPRIVATE_METHOD is nonzero if T has any non-private methods or
2112 static members. HAS_NONPRIVATE_STATIC_FN is nonzero if T has any
2113 non-private static member functions. */
2115 static void
2117 tree t;
2118 {
2121 tree fn;
2124 /* If the class has friends, those entities might create and
2125 access instances, so we should not warn. */
2128 /* We will have warned when the template was declared; there's
2129 no need to warn on every instantiation. */
2131 /* There's no reason to even consider warning about this
2132 class. */
2135 /* We only issue one warning, if more than one applies, because
2136 otherwise, on code like:
2138 class A {
2139 // Oops - forgot `public:'
2140 A();
2141 A(const A&);
2142 ~A();
2143 };
2145 we warn several times about essentially the same problem. */
2147 /* Check to see if all (non-constructor, non-destructor) member
2148 functions are private. (Since there are no friends or
2149 non-private statics, we can't ever call any of the private member
2150 functions.) */
2152 /* We're not interested in compiler-generated methods; they don't
2153 provide any way to call private members. */
2155 {
2157 {
2159 /* A non-private static member function is just like a
2160 friend; it can create and invoke private member
2161 functions, and be accessed without a class
2162 instance. */
2167 }
2170 }
2173 {
2174 /* There are no non-private methods, and there's at least one
2175 private member function that isn't a constructor or
2176 destructor. (If all the private members are
2177 constructors/destructors we want to use the code below that
2178 issues error messages specifically referring to
2179 constructors/destructors.) */
2185 {
2188 }
2190 {
2193 }
2194 }
2196 /* Even if some of the member functions are non-private, the class
2197 won't be useful for much if all the constructors or destructors
2198 are private: such an object can never be created or destroyed. */
2200 {
2204 {
2206 t);
2208 }
2209 }
2212 {
2215 /* If a non-template class does not define a copy
2216 constructor, one is defined for it, enabling it to avoid
2217 this warning. For a template class, this does not
2218 happen, and so we would normally get a warning on:
2220 template <class T> class C { private: C(); };
2222 To avoid this asymmetry, we check TYPE_HAS_INIT_REF. All
2223 complete non-template or fully instantiated classes have this
2224 flag set. */
2227 else
2229 fn;
2231 {
2233 /* Ideally, we wouldn't count copy constructors (or, in
2234 fact, any constructor that takes an argument of the
2235 class type as a parameter) because such things cannot
2236 be used to construct an instance of the class unless
2237 you already have one. But, for now at least, we're
2238 more generous. */
2240 {
2243 }
2244 }
2247 {
2249 t);
2251 }
2252 }
2253 }
2255 /* Function to help qsort sort FIELD_DECLs by name order. */
2257 static int
2260 {
2262 /* A nontype is "greater" than a type. */
2271 }
2273 /* Comparison function to compare two TYPE_METHOD_VEC entries by name. */
2275 static int
2278 {
2288 }
2290 /* Warn about duplicate methods in fn_fields. Also compact method
2291 lists so that lookup can be made faster.
2293 Data Structure: List of method lists. The outer list is a
2294 TREE_LIST, whose TREE_PURPOSE field is the field name and the
2295 TREE_VALUE is the DECL_CHAIN of the FUNCTION_DECLs. TREE_CHAIN
2296 links the entire list of methods for TYPE_METHODS. Friends are
2297 chained in the same way as member functions (? TREE_CHAIN or
2298 DECL_CHAIN), but they live in the TREE_TYPE field of the outer
2299 list. That allows them to be quickly deleted, and requires no
2300 extra storage.
2302 Sort methods that are not special (i.e., constructors, destructors,
2303 and type conversion operators) so that we can find them faster in
2304 search. */
2306 static void
2308 tree t;
2309 {
2310 tree fn_fields;
2311 tree method_vec;
2315 {
2316 /* Clear these for safety; perhaps some parsing error could set
2317 these incorrectly. */
2322 }
2328 /* First fill in entry 0 with the constructors, entry 1 with destructors,
2329 and the next few with type conversion operators (if any). */
2332 /* Clear out this flag. */
2336 /* We thought there was a destructor, but there wasn't. Some
2337 parse errors cause this anomalous situation. */
2340 /* Issue warnings about private constructors and such. If there are
2341 no methods, then some public defaults are generated. */
2344 /* Now sort the methods. */
2346 len--;
2349 /* The type conversion ops have to live at the front of the vec, so we
2350 can't sort them. */
2352 {
2357 }
2361 }
2363 /* Emit error when a duplicate definition of a type is seen. Patch up. */
2365 void
2367 tree t;
2368 {
2372 /* Pretend we haven't defined this type. */
2374 /* All of the component_decl's were TREE_CHAINed together in the parser.
2375 finish_struct_methods walks these chains and assembles all methods with
2376 the same base name into DECL_CHAINs. Now we don't need the parser chains
2377 anymore, so we unravel them. */
2379 /* This used to be in finish_struct, but it turns out that the
2380 TREE_CHAIN is used by dbxout_type_methods and perhaps some other
2381 things... */
2383 {
2387 {
2390 {
2393 }
2394 }
2395 }
2398 {
2414 }
2423 /* Clear TYPE_LANG_FLAGS -- those in TYPE_LANG_SPECIFIC are cleared above. */
2431 /* But not this one. */
2433 }
2435 /* Make BINFO's vtable have N entries, including RTTI entries,
2436 vbase and vcall offsets, etc. Set its type and call the backend
2437 to lay it out. */
2439 static void
2441 tree binfo;
2443 {
2444 tree atype;
2445 tree vtable;
2451 /* We may have to grow the vtable. */
2454 {
2459 /* At one time the vtable info was grabbed 2 words at a time. This
2460 fails on Sparc unless you have 8-byte alignment. */
2463 }
2464 }
2466 /* True iff FNDECL and BASE_FNDECL (both non-static member functions)
2467 have the same signature. */
2469 int
2472 {
2473 /* One destructor overrides another if they are the same kind of
2474 destructor. */
2478 /* But a non-destructor never overrides a destructor, nor vice
2479 versa, nor do different kinds of destructors override
2480 one-another. For example, a complete object destructor does not
2481 override a deleting destructor. */
2486 {
2494 }
2496 }
2499 /* The function for which we are trying to find a final overrider. */
2500 tree fn;
2501 /* The base class in which the function was declared. */
2502 tree declaring_base;
2503 /* The most derived class in the hierarchy. */
2504 tree most_derived_type;
2505 /* The final overriding function. */
2506 tree overriding_fn;
2507 /* The functions that we thought might be final overriders, but
2508 aren't. */
2509 tree candidates;
2510 /* The BINFO for the class in which the final overriding function
2511 appears. */
2512 tree overriding_base;
2515 /* Called from find_final_overrider via dfs_walk. */
2517 static tree
2519 tree binfo;
2521 {
2528 {
2529 tree path;
2530 tree method;
2532 /* We haven't found an overrider yet. */
2534 /* We've found a path to the declaring base. Walk down the path
2535 looking for an overrider for FN. */
2537 path;
2539 {
2544 }
2546 /* If we found an overrider, record the overriding function, and
2547 the base from which it came. */
2549 {
2550 tree base;
2552 /* Assume the path is non-virtual. See if there are any
2553 virtual bases from (but not including) the overrider up
2554 to and including the base where the function is
2555 defined. */
2558 {
2561 }
2563 /* If we didn't already have an overrider, or any
2564 candidates, then this function is the best candidate so
2565 far. */
2567 {
2570 }
2572 {
2573 /* We had a best overrider; let's see how this compares. */
2576 && (tree_int_cst_equal
2579 /* We found the same overrider we already have, and in the
2582 /* The old function overrides this function; it's still the
2585 {
2586 /* The new function overrides the old; it's now the
2587 best. */
2590 }
2591 else
2592 {
2593 /* Ambiguous. */
2594 ffod->candidates
2598 ffod->candidates
2602 }
2603 }
2604 else
2605 {
2606 /* We had a list of ambiguous overrides; let's see how this
2607 new one compares. */
2609 tree candidates;
2612 /* If there were previous candidates, and this function
2613 overrides all of them, then it is the new best
2614 candidate. */
2616 candidates;
2618 {
2619 /* If the candidate overrides the METHOD, then we
2620 needn't worry about it any further. */
2622 method))
2623 {
2626 }
2628 /* If the METHOD doesn't override the candidate,
2629 then it is incomporable. */
2633 }
2635 /* If METHOD overrode all the candidates, then it is the
2636 new best candidate. */
2638 {
2642 }
2643 /* If METHOD didn't override all the candidates, then it
2644 is another candidate. */
2646 ffod->candidates
2648 }
2649 }
2650 }
2653 }
2655 /* Returns a TREE_LIST whose TREE_PURPOSE is the final overrider for
2656 FN and whose TREE_VALUE is the binfo for the base where the
2657 overriding occurs. BINFO (in the hierarchy dominated by T) is the
2658 base object in which FN is declared. */
2660 static tree
2662 tree t;
2663 tree binfo;
2664 tree fn;
2665 {
2666 find_final_overrider_data ffod;
2668 /* Getting this right is a little tricky. This is legal:
2670 struct S { virtual void f (); };
2671 struct T { virtual void f (); };
2672 struct U : public S, public T { };
2674 even though calling `f' in `U' is ambiguous. But,
2676 struct R { virtual void f(); };
2677 struct S : virtual public R { virtual void f (); };
2678 struct T : virtual public R { virtual void f (); };
2679 struct U : public S, public T { };
2681 is not -- there's no way to decide whether to put `S::f' or
2682 `T::f' in the vtable for `R'.
2684 The solution is to look at all paths to BINFO. If we find
2685 different overriders along any two, then there is a problem. */
2694 dfs_find_final_overrider,
2695 NULL,
2698 /* If there was no winner, issue an error message. */
2700 {
2703 }
2706 }
2708 /* Returns the function from the BINFO_VIRTUALS entry in T which matches
2709 the signature of FUNCTION_DECL FN, or NULL_TREE if none. In other words,
2710 the function that the slot in T's primary vtable points to. */
2713 static tree
2716 {
2717 tree f;
2723 }
2725 /* Update an entry in the vtable for BINFO, which is in the hierarchy
2726 dominated by T. FN has been overriden in BINFO; VIRTUALS points to the
2727 corresponding position in the BINFO_VIRTUALS list. */
2729 static void
2731 tree t;
2732 tree binfo;
2733 tree fn;
2735 {
2736 tree b;
2737 tree overrider;
2738 tree delta;
2739 tree virtual_base;
2740 tree first_defn;
2742 /* Find the nearest primary base (possibly binfo itself) which defines
2743 this function; this is the class the caller will convert to when
2744 calling FN through BINFO. */
2746 {
2749 }
2752 /* Find the final overrider. */
2757 /* Assume that we will produce a thunk that convert all the way to
2758 the final overrider, and not to an intermediate virtual base. */
2761 /* Under the new ABI, we will convert to an intermediate virtual
2762 base first, and then use the vcall offset located there to finish
2763 the conversion. */
2765 {
2766 /* If we find the final overrider, then we can stop
2767 walking. */
2772 /* If we find a virtual base, and we haven't yet found the
2773 overrider, then there is a virtual base between the
2774 declaring base (first_defn) and the final overrider. */
2779 }
2781 /* Compute the constant adjustment to the `this' pointer. The
2782 `this' pointer, when this function is called, will point at BINFO
2783 (or one of its primary bases, which are at the same offset). */
2786 /* The `this' pointer needs to be adjusted to the nearest virtual
2787 base. */
2790 else
2791 {
2792 /* The `this' pointer needs to be adjusted from pointing to
2793 BINFO to pointing at the base where the final overrider
2794 appears. */
2799 {
2800 /* We'll need a thunk. But if we have a (perhaps formerly)
2801 primary virtual base, we have a vcall slot for this function,
2802 so we can use it rather than create a non-virtual thunk. */
2806 {
2809 /* b doesn't have this function; no suitable vbase. */
2812 {
2813 /* Found one; we can treat ourselves as a virtual base. */
2817 }
2818 }
2819 }
2820 }
2823 binfo,
2825 delta,
2826 virtuals);
2830 }
2832 /* Called from modify_all_vtables via dfs_walk. */
2834 static tree
2836 tree binfo;
2838 {
2840 primary base; we're not going to use that vtable anyhow.
2841 We do still need to do this for virtual primary bases, as they
2842 could become non-primary in a construction vtable. */
2844 /* Similarly, a base without a vtable needs no modification. */
2846 {
2847 tree t;
2848 tree virtuals;
2849 tree old_virtuals;
2853 /* If we're supporting RTTI then we always need a new vtable to
2854 point to the RTTI information. Under the new ABI we may need
2855 a new vtable to contain vcall and vbase offsets. */
2858 /* Now, go through each of the virtual functions in the virtual
2859 function table for BINFO. Find the final overrider, and
2860 update the BINFO_VIRTUALS list appropriately. */
2863 virtuals;
2867 binfo,
2870 }
2875 }
2877 /* Update all of the primary and secondary vtables for T. Create new
2878 vtables as required, and initialize their RTTI information. Each
2879 of the functions in OVERRIDDEN_VIRTUALS overrides a virtual
2880 function from a base class; find and modify the appropriate entries
2881 to point to the overriding functions. Returns a list, in
2882 declaration order, of the functions that are overridden in this
2883 class, but do not appear in the primary base class vtable, and
2884 which should therefore be appended to the end of the vtable for T. */
2886 static tree
2888 tree t;
2890 tree overridden_virtuals;
2891 {
2892 tree binfo;
2896 /* Update all of the vtables. */
2898 dfs_modify_vtables,
2899 dfs_unmarked_real_bases_queue_p,
2900 t);
2903 /* If we should include overriding functions for secondary vtables
2904 in our primary vtable, add them now. */
2906 {
2910 {
2915 {
2916 /* Set the vtable index. */
2918 /* We don't need to convert to a base class when calling
2919 this function. */
2922 /* We don't need to adjust the `this' pointer when
2923 calling this function. */
2927 /* This is an overridden function not already in our
2928 vtable. Keep it. */
2930 }
2931 else
2932 /* We've already got an entry for this function. Skip
2933 it. */
2935 }
2936 }
2937 else
2941 }
2943 /* Here, we already know that they match in every respect.
2944 All we have to check is where they had their declarations. */
2946 static int
2949 {
2956 }
2958 /* Get the base virtual function declarations in T that are either
2959 overridden or hidden by FNDECL as a list. We set TREE_PURPOSE with
2960 the overrider/hider. */
2962 static tree
2965 {
2972 {
2979 }
2985 {
2990 base_fndecls);
2991 }
2994 }
2996 /* Mark the functions that have been hidden with their overriders.
2997 Since we start out with all functions already marked with a hider,
2998 no need to mark functions that are just hidden.
3000 Subroutine of warn_hidden. */
3002 static void
3005 {
3009 }
3011 /* If this declaration supersedes the declaration of
3012 a method declared virtual in the base class, then
3013 mark this field as being virtual as well. */
3015 static void
3018 {
3020 /* In [temp.mem] we have:
3022 A specialization of a member function template does not
3023 override a virtual function from a base class. */
3029 {
3030 /* Set DECL_VINDEX to a value that is neither an
3031 INTEGER_CST nor the error_mark_node so that
3032 add_virtual_function will realize this is an
3033 overriding function. */
3035 }
3037 {
3041 }
3042 }
3044 /* Warn about hidden virtual functions that are not overridden in t.
3045 We know that constructors and destructors don't apply. */
3047 void
3049 tree t;
3050 {
3055 /* We go through each separately named virtual function. */
3057 {
3065 /* First see if we have any virtual functions in this batch. */
3067 {
3071 }
3076 /* First we get a list of all possible functions that might be
3077 hidden from each base class. */
3079 {
3084 base_fndecls);
3085 }
3089 /* ...then mark up all the base functions with overriders, preferring
3090 overriders to hiders. */
3093 {
3097 }
3099 /* Now give a warning for all base functions without overriders,
3100 as they are hidden. */
3104 {
3105 /* Here we know it is a hider, and no overrider exists. */
3108 }
3109 }
3110 }
3112 /* Check for things that are invalid. There are probably plenty of other
3113 things we should check for also. */
3115 static void
3117 tree t;
3118 {
3119 tree field;
3122 {
3130 {
3133 {
3139 elt);
3142 {
3144 elt);
3146 }
3150 elt);
3153 elt);
3157 }
3158 }
3159 }
3160 }
3162 /* Create default constructors, assignment operators, and so forth for
3163 the type indicated by T, if they are needed.
3164 CANT_HAVE_DEFAULT_CTOR, CANT_HAVE_CONST_CTOR, and
3165 CANT_HAVE_CONST_ASSIGNMENT are nonzero if, for whatever reason, the
3166 class cannot have a default constructor, copy constructor taking a
3167 const reference argument, or an assignment operator taking a const
3168 reference, respectively. If a virtual destructor is created, its
3169 DECL is returned; otherwise the return value is NULL_TREE. */
3171 static tree
3173 cant_have_const_cctor,
3174 cant_have_const_assignment)
3175 tree t;
3179 {
3180 tree default_fn;
3185 /* Destructor. */
3187 {
3191 /* If we couldn't make it work, then pretend we didn't need it. */
3194 else
3195 {
3201 }
3202 }
3203 else
3204 /* Any non-implicit destructor is non-trivial. */
3207 /* Default constructor. */
3209 {
3213 }
3215 /* Copy constructor. */
3217 {
3218 /* ARM 12.18: You get either X(X&) or X(const X&), but
3219 not both. --Chip */
3220 default_fn
3225 }
3227 /* Assignment operator. */
3229 {
3230 default_fn
3235 }
3237 /* Now, hook all of the new functions on to TYPE_METHODS,
3238 and add them to the CLASSTYPE_METHOD_VEC. */
3245 }
3247 /* Subroutine of finish_struct_1. Recursively count the number of fields
3248 in TYPE, including anonymous union members. */
3250 static int
3252 tree fields;
3253 {
3254 tree x;
3257 {
3260 else
3262 }
3264 }
3266 /* Subroutine of finish_struct_1. Recursively add all the fields in the
3267 TREE_LIST FIELDS to the TREE_VEC FIELD_VEC, starting at offset IDX. */
3269 static int
3273 {
3274 tree x;
3276 {
3279 else
3281 }
3283 }
3285 /* FIELD is a bit-field. We are finishing the processing for its
3286 enclosing type. Issue any appropriate messages and set appropriate
3287 flags. */
3289 static void
3291 tree field;
3292 {
3296 /* Detect invalid bit-field type. */
3299 {
3302 }
3304 /* Detect and ignore out of range field width. */
3306 {
3309 /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs. */
3312 /* detect invalid field size. */
3315 else
3319 {
3321 field);
3323 }
3325 {
3328 }
3330 {
3333 }
3343 min_precision
3348 }
3350 /* Remove the bit-field width indicator so that the rest of the
3351 compiler does not treat that value as an initializer. */
3355 {
3360 {
3361 #ifdef EMPTY_FIELD_BOUNDARY
3363 EMPTY_FIELD_BOUNDARY);
3364 #endif
3365 #ifdef PCC_BITFIELD_TYPE_MATTERS
3367 {
3371 }
3372 #endif
3373 }
3374 }
3375 else
3376 {
3377 /* Non-bit-fields are aligned for their type. */
3382 }
3383 }
3385 /* FIELD is a non bit-field. We are finishing the processing for its
3386 enclosing type T. Issue any appropriate messages and set appropriate
3387 flags. */
3389 static void
3392 any_default_members)
3393 tree field;
3394 tree t;
3399 {
3402 /* An anonymous union cannot contain any fields which would change
3403 the settings of CANT_HAVE_CONST_CTOR and friends. */
3405 ;
3406 /* And, we don't set TYPE_HAS_CONST_INIT_REF, etc., for anonymous
3407 structs. So, we recurse through their fields here. */
3409 {
3410 tree fields;
3416 any_default_members);
3417 }
3418 /* Check members with class type for constructors, destructors,
3419 etc. */
3421 {
3422 /* Never let anything with uninheritable virtuals
3423 make it through without complaint. */
3427 {
3430 field);
3433 field);
3436 field);
3437 }
3438 else
3439 {
3445 }
3456 }
3458 {
3459 /* `build_class_init_list' does not recognize
3460 non-FIELD_DECLs. */
3464 }
3466 /* Non-bit-fields are aligned for their type, except packed fields
3467 which require only BITS_PER_UNIT alignment. */
3470 ? BITS_PER_UNIT
3474 }
3476 /* Check the data members (both static and non-static), class-scoped
3477 typedefs, etc., appearing in the declaration of T. Issue
3478 appropriate diagnostics. Sets ACCESS_DECLS to a list (in
3479 declaration order) of access declarations; each TREE_VALUE in this
3480 list is a USING_DECL.
3482 In addition, set the following flags:
3484 EMPTY_P
3485 The class is empty, i.e., contains no non-static data members.
3487 CANT_HAVE_DEFAULT_CTOR_P
3488 This class cannot have an implicitly generated default
3489 constructor.
3491 CANT_HAVE_CONST_CTOR_P
3492 This class cannot have an implicitly generated copy constructor
3493 taking a const reference.
3495 CANT_HAVE_CONST_ASN_REF
3496 This class cannot have an implicitly generated assignment
3497 operator taking a const reference.
3499 All of these flags should be initialized before calling this
3500 function.
3502 Returns a pointer to the end of the TYPE_FIELDs chain; additional
3503 fields can be added by adding to this chain. */
3505 static void
3508 no_const_asn_ref_p)
3509 tree t;
3515 {
3521 /* First, delete any duplicate fields. */
3524 /* Assume there are no access declarations. */
3526 /* Assume this class has no pointer members. */
3528 /* Assume none of the members of this class have default
3529 initializations. */
3533 {
3542 {
3546 /* We don't treat zero-width bitfields as making a class
3547 non-empty. */
3548 ;
3549 else
3550 {
3551 /* The class is non-empty. */
3553 /* The class is not even nearly empty. */
3555 }
3556 }
3559 {
3560 /* Prune the access declaration from the list of fields. */
3563 /* Save the access declarations for our caller. */
3566 /* Since we've reset *FIELD there's no reason to skip to the
3567 next field. */
3570 }
3576 /* If we've gotten this far, it's a data member, possibly static,
3577 or an enumerator. */
3581 /* ``A local class cannot have static data members.'' ARM 9.4 */
3585 /* Perform error checking that did not get done in
3586 grokdeclarator. */
3588 {
3590 x);
3593 }
3595 {
3599 }
3601 {
3605 }
3610 /* When this goes into scope, it will be a non-local reference. */
3617 {
3619 /* Unions cannot have static members. */
3623 }
3625 /* Now it can only be a FIELD_DECL. */
3630 /* If this is of reference type, check if it needs an init.
3631 Also do a little ANSI jig if necessary. */
3633 {
3638 /* ARM $12.6.2: [A member initializer list] (or, for an
3639 aggregate, initialization by a brace-enclosed list) is the
3640 only way to initialize nonstatic const and reference
3641 members. */
3647 }
3658 /* DR 148 now allows pointers to members (which are POD themselves),
3659 to be allowed in POD structs. */
3662 /* If any field is const, the structure type is pseudo-const. */
3664 {
3669 /* ARM $12.6.2: [A member initializer list] (or, for an
3670 aggregate, initialization by a brace-enclosed list) is the
3671 only way to initialize nonstatic const and reference
3672 members. */
3678 }
3679 /* A field that is pseudo-const makes the structure likewise. */
3681 {
3685 }
3687 /* Core issue 80: A nonstatic data member is required to have a
3688 different name from the class iff the class has a
3689 user-defined constructor. */
3694 /* We set DECL_C_BIT_FIELD in grokbitfield.
3695 If the type and width are valid, we'll also set DECL_BIT_FIELD. */
3698 else
3700 cant_have_const_ctor_p,
3701 cant_have_default_ctor_p,
3702 no_const_asn_ref_p,
3704 }
3706 /* Effective C++ rule 11. */
3709 {
3713 {
3717 }
3720 }
3723 /* Check anonymous struct/anonymous union fields. */
3726 /* We've built up the list of access declarations in reverse order.
3727 Fix that now. */
3729 }
3731 /* Return a FIELD_DECL for a pointer-to-virtual-table or
3732 pointer-to-virtual-base. The NAME, ASSEMBLER_NAME, and TYPE of the
3733 field are as indicated. The CLASS_TYPE in which this field occurs
3734 is also indicated. FCONTEXT is the type that is needed for the debug
3735 info output routines. *EMPTY_P is set to a non-zero value by this
3736 function to indicate that a class containing this field is
3737 non-empty. */
3739 static tree
3741 empty_p)
3742 tree name;
3743 tree assembler_name;
3744 tree type;
3745 tree class_type;
3746 tree fcontext;
3748 {
3749 tree field;
3751 /* This class is non-empty. */
3754 /* Build the FIELD_DECL. */
3764 /* Return it. */
3766 }
3768 /* If TYPE is an empty class type, records its OFFSET in the table of
3769 OFFSETS. */
3771 static int
3773 tree type;
3774 tree offset;
3775 splay_tree offsets;
3776 {
3777 splay_tree_node n;
3782 /* Record the location of this empty object in OFFSETS. */
3790 type,
3794 }
3796 /* Returns non-zero if TYPE is an empty class type and there is
3797 already an entry in OFFSETS for the same TYPE as the same OFFSET. */
3799 static int
3801 tree type;
3802 tree offset;
3803 splay_tree offsets;
3804 {
3805 splay_tree_node n;
3806 tree t;
3811 /* Record the location of this empty object in OFFSETS. */
3821 }
3823 /* Walk through all the subobjects of TYPE (located at OFFSET). Call
3824 F for every subobject, passing it the type, offset, and table of
3825 OFFSETS. If VBASES_P is non-zero, then even virtual non-primary
3826 bases should be traversed; otherwise, they are ignored.
3828 If MAX_OFFSET is non-NULL, then subobjects with an offset greater
3829 than MAX_OFFSET will not be walked.
3831 If F returns a non-zero value, the traversal ceases, and that value
3832 is returned. Otherwise, returns zero. */
3834 static int
3836 tree type;
3837 subobject_offset_fn f;
3838 tree offset;
3839 splay_tree offsets;
3840 tree max_offset;
3842 {
3845 /* If this OFFSET is bigger than the MAX_OFFSET, then we should
3846 stop. */
3851 {
3852 tree field;
3855 /* Record the location of TYPE. */
3860 /* Iterate through the direct base classes of TYPE. */
3862 {
3871 f,
3873 offset,
3875 offsets,
3876 max_offset,
3877 vbases_p);
3880 }
3882 /* Iterate through the fields of TYPE. */
3885 {
3887 f,
3889 offset,
3891 offsets,
3892 max_offset,
3896 }
3897 }
3899 {
3901 tree index;
3903 /* Step through each of the elements in the array. */
3907 {
3909 f,
3910 offset,
3911 offsets,
3912 max_offset,
3918 /* If this new OFFSET is bigger than the MAX_OFFSET, then
3919 there's no point in iterating through the remaining
3920 elements of the array. */
3923 }
3924 }
3927 }
3929 /* Record all of the empty subobjects of TYPE (located at OFFSET) in
3930 OFFSETS. If VBASES_P is non-zero, virtual bases of TYPE are
3931 examined. */
3933 static void
3935 tree type;
3936 tree offset;
3937 splay_tree offsets;
3939 {
3942 }
3944 /* Returns non-zero if any of the empty subobjects of TYPE (located at
3945 OFFSET) conflict with entries in OFFSETS. If VBASES_P is non-zero,
3946 virtual bases of TYPE are examined. */
3948 static int
3950 tree type;
3951 tree offset;
3952 splay_tree offsets;
3954 {
3955 splay_tree_node max_node;
3957 /* Get the node in OFFSETS that indicates the maximum offset where
3958 an empty subobject is located. */
3960 /* If there aren't any empty subobjects, then there's no point in
3961 performing this check. */
3967 vbases_p);
3968 }
3970 /* DECL is a FIELD_DECL corresponding either to a base subobject of a
3971 non-static data member of the type indicated by RLI. BINFO is the
3972 binfo corresponding to the base subobject, OFFSETS maps offsets to
3973 types already located at those offsets. T is the most derived
3974 type. This function determines the position of the DECL. */
3976 static void
3978 record_layout_info rli;
3979 tree decl;
3980 tree binfo;
3981 splay_tree offsets;
3982 tree t;
3983 {
3986 /* If we are laying out a base class, rather than a field, then
3987 DECL_ARTIFICIAL will be set on the FIELD_DECL. */
3990 /* Try to place the field. It may take more than one try if we have
3991 a hard time placing the field without putting two objects of the
3992 same type at the same address. */
3994 {
3997 /* Place this field. */
4001 /* We have to check to see whether or not there is already
4002 something of the same type at the offset we're about to use.
4003 For example:
4005 struct S {};
4006 struct T : public S { int i; };
4007 struct U : public S, public T {};
4009 Here, we put S at offset zero in U. Then, we can't put T at
4010 offset zero -- its S component would be at the same address
4011 as the S we already allocated. So, we have to skip ahead.
4012 Since all data members, including those whose type is an
4013 empty class, have non-zero size, any overlap can happen only
4014 with a direct or indirect base-class -- it can't happen with
4015 a data member. */
4017 offset,
4018 offsets,
4019 field_p))
4020 {
4021 /* Strip off the size allocated to this field. That puts us
4022 at the first place we could have put the field with
4023 proper alignment. */
4026 /* Bump up by the alignment required for the type. */
4027 rli->bitpos
4033 }
4034 else
4035 /* There was no conflict. We're done laying out this field. */
4037 }
4039 /* Now that we know where it will be placed, update its
4040 BINFO_OFFSET. */
4044 }
4046 /* Layout the empty base BINFO. EOC indicates the byte currently just
4047 past the end of the class, and should be correctly aligned for a
4048 class of the type indicated by BINFO; OFFSETS gives the offsets of
4049 the empty bases allocated so far. T is the most derived
4050 type. Return non-zero iff we added it at the end. */
4052 static bool
4054 tree binfo;
4055 tree eoc;
4056 splay_tree offsets;
4057 tree t;
4058 {
4059 tree alignment;
4063 /* This routine should only be used for empty classes. */
4067 /* This is an empty base class. We first try to put it at offset
4068 zero. */
4071 offsets,
4073 {
4074 /* That didn't work. Now, we move forward from the next
4075 available spot in the class. */
4079 {
4082 offsets,
4084 /* We finally found a spot where there's no overlap. */
4087 /* There's overlap here, too. Bump along to the next spot. */
4089 }
4090 }
4092 }
4094 /* Build a FIELD_DECL for the base given by BINFO in the class
4095 indicated by RLI. If the new object is non-empty, clear *EMPTY_P.
4096 *BASE_ALIGN is a running maximum of the alignments of any base
4097 class. OFFSETS gives the location of empty base subobjects. T is
4098 the most derived type. Return non-zero if the new object cannot be
4099 nearly-empty. */
4101 static bool
4103 record_layout_info rli;
4104 tree binfo;
4106 splay_tree offsets;
4107 tree t;
4108 {
4110 tree decl;
4114 /* This error is now reported in xref_tag, thus giving better
4115 location information. */
4127 {
4128 /* The containing class is non-empty because it has a non-empty
4129 base class. */
4132 /* Try to place the field. It may take more than one try if we
4133 have a hard time placing the field without putting two
4134 objects of the same type at the same address. */
4136 }
4137 else
4138 {
4141 /* On some platforms (ARM), even empty classes will not be
4142 byte-aligned. */
4146 }
4148 /* Record the offsets of BINFO and its base subobjects. */
4151 offsets,
4154 }
4156 /* Layout all of the non-virtual base classes. Record empty
4157 subobjects in OFFSETS. T is the most derived type. Return
4158 non-zero if the type cannot be nearly empty. */
4160 static bool
4162 record_layout_info rli;
4164 splay_tree offsets;
4165 tree t;
4166 {
4167 /* Chain to hold all the new FIELD_DECLs which stand in for base class
4168 subobjects. */
4174 /* Under the new ABI, the primary base class is always allocated
4175 first. */
4180 /* Now allocate the rest of the bases. */
4182 {
4183 tree base_binfo;
4187 /* Under the new ABI, the primary base was already allocated
4188 above, so we don't need to allocate it again here. */
4192 /* A primary virtual base class is allocated just like any other
4193 base class, but a non-primary virtual base is allocated
4194 later, in layout_virtual_bases. */
4200 }
4202 }
4204 /* Go through the TYPE_METHODS of T issuing any appropriate
4205 diagnostics, figuring out which methods override which other
4206 methods, and so forth. */
4208 static void
4210 tree t;
4211 {
4212 tree x;
4216 {
4219 /* If this was an evil function, don't keep it in class. */
4228 /* The name of the field is the original field name
4229 Save this in auxiliary field for later overloading. */
4231 {
4236 }
4239 {
4240 tree second_parm;
4242 /* When dynamically allocating an array of this type, we
4243 need a "cookie" to record how many elements we allocated,
4244 even if the array elements have no non-trivial
4245 destructor, if the usual array deallocation function
4246 takes a second argument of type size_t. The standard (in
4247 [class.free]) requires that the second argument be set
4248 correctly. */
4250 /* Under the new ABI, we choose only those function that are
4251 explicitly declared as `operator delete[] (void *,
4252 size_t)'. */
4254 && second_parm
4258 /* If there's no second parameter, then this is the usual
4259 deallocation function. */
4262 }
4263 }
4264 }
4266 /* FN is a constructor or destructor. Clone the declaration to create
4267 a specialized in-charge or not-in-charge version, as indicated by
4268 NAME. */
4270 static tree
4272 tree fn;
4273 tree name;
4274 {
4275 tree parms;
4276 tree clone;
4278 /* Copy the function. */
4280 /* Remember where this function came from. */
4283 /* Reset the function name. */
4286 /* There's no pending inline data for this function. */
4289 /* And it hasn't yet been deferred. */
4292 /* The base-class destructor is not virtual. */
4294 {
4298 }
4300 /* If there was an in-charge parameter, drop it from the function
4301 type. */
4303 {
4304 tree basetype;
4305 tree parmtypes;
4306 tree exceptions;
4311 /* Skip the `this' parameter. */
4313 /* Skip the in-charge parameter. */
4315 /* And the VTT parm, in a complete [cd]tor. */
4319 /* If this is subobject constructor or destructor, add the vtt
4320 parameter. */
4324 parmtypes);
4327 exceptions);
4328 }
4330 /* Copy the function parameters. But, DECL_ARGUMENTS on a TEMPLATE_DECL
4331 aren't function parameters; those are the template parameters. */
4333 {
4335 /* Remove the in-charge parameter. */
4337 {
4341 }
4342 /* And the VTT parm, in a complete [cd]tor. */
4344 {
4347 else
4348 {
4352 }
4353 }
4356 {
4359 }
4360 }
4362 /* Create the RTL for this function. */
4366 /* Make it easy to find the CLONE given the FN. */
4370 /* If this is a template, handle the DECL_TEMPLATE_RESULT as well. */
4372 {
4373 tree result;
4380 }
4385 }
4387 /* Produce declarations for all appropriate clones of FN. If
4388 UPDATE_METHOD_VEC_P is non-zero, the clones are added to the
4389 CLASTYPE_METHOD_VEC as well. */
4391 void
4393 tree fn;
4395 {
4396 tree clone;
4398 /* Avoid inappropriate cloning. */
4404 {
4405 /* For each constructor, we need two variants: an in-charge version
4406 and a not-in-charge version. */
4413 }
4414 else
4415 {
4418 /* For each destructor, we need three variants: an in-charge
4419 version, a not-in-charge version, and an in-charge deleting
4420 version. We clone the deleting version first because that
4421 means it will go second on the TYPE_METHODS list -- and that
4422 corresponds to the correct layout order in the virtual
4423 function table.
4425 For a non-virtual destructor, we do not build a deleting
4426 destructor. */
4428 {
4432 }
4439 }
4441 /* Note that this is an abstract function that is never emitted. */
4443 }
4445 /* DECL is an in charge constructor, which is being defined. This will
4446 have had an in class declaration, from whence clones were
4447 declared. An out-of-class definition can specify additional default
4448 arguments. As it is the clones that are involved in overload
4449 resolution, we must propagate the information from the DECL to its
4450 clones. */
4452 void
4454 tree decl;
4455 {
4456 tree clone;
4460 {
4467 /* Skip the 'this' parameter. */
4483 {
4488 {
4489 /* A default parameter has been added. Adjust the
4490 clone's parameters. */
4493 tree type;
4498 {
4501 clone_parms);
4503 }
4506 clone_parms);
4513 }
4514 }
4516 }
4517 }
4519 /* For each of the constructors and destructors in T, create an
4520 in-charge and not-in-charge variant. */
4522 static void
4524 tree t;
4525 {
4526 tree fns;
4528 /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail
4529 out now. */
4537 }
4539 /* Remove all zero-width bit-fields from T. */
4541 static void
4543 tree t;
4544 {
4549 {
4554 else
4556 }
4557 }
4559 /* Check the validity of the bases and members declared in T. Add any
4560 implicitly-generated functions (like copy-constructors and
4561 assignment operators). Compute various flag bits (like
4562 CLASSTYPE_NON_POD_T) for T. This routine works purely at the C++
4563 level: i.e., independently of the ABI in use. */
4565 static void
4567 tree t;
4569 {
4570 /* Nonzero if we are not allowed to generate a default constructor
4571 for this case. */
4573 /* Nonzero if the implicitly generated copy constructor should take
4574 a non-const reference argument. */
4576 /* Nonzero if the the implicitly generated assignment operator
4577 should take a non-const reference argument. */
4579 tree access_decls;
4581 /* By default, we use const reference arguments and generate default
4582 constructors. */
4587 /* Assume that the class is nearly empty; we'll clear this flag if
4588 it turns out not to be nearly empty. */
4591 /* Check all the base-classes. */
4595 /* Check all the data member declarations. */
4601 /* Check all the method declarations. */
4604 /* A nearly-empty class has to be vptr-containing; a nearly empty
4605 class contains just a vptr. */
4609 /* Do some bookkeeping that will guide the generation of implicitly
4610 declared member functions. */
4628 /* Synthesize any needed methods. Note that methods will be synthesized
4629 for anonymous unions; grok_x_components undoes that. */
4631 cant_have_const_ctor,
4632 no_const_asn_ref);
4634 /* Create the in-charge and not-in-charge variants of constructors
4635 and destructors. */
4638 /* Process the using-declarations. */
4642 /* Build and sort the CLASSTYPE_METHOD_VEC. */
4644 }
4646 /* If T needs a pointer to its virtual function table, set TYPE_VFIELD
4647 accordingly. If a new vfield was created (because T doesn't have a
4648 primary base class), then the newly created field is returned. It
4649 is not added to the TYPE_FIELDS list; it is the caller's
4650 responsibility to do that. */
4652 static tree
4655 tree t;
4660 {
4661 tree fn;
4663 /* Loop over the virtual functions, adding them to our various
4664 vtables. */
4670 /* If we couldn't find an appropriate base class, create a new field
4671 here. Even if there weren't any new virtual functions, we might need a
4672 new virtual function table if we're supposed to include vptrs in
4673 all classes that need them. */
4675 && (*vfuns_p
4677 {
4678 /* We build this decl with vtbl_ptr_type_node, which is a
4679 `vtable_entry_type*'. It might seem more precise to use
4680 `vtable_entry_type (*)[N]' where N is the number of firtual
4681 functions. However, that would require the vtable pointer in
4682 base classes to have a different type than the vtable pointer
4683 in derived classes. We could make that happen, but that
4684 still wouldn't solve all the problems. In particular, the
4685 type-based alias analysis code would decide that assignments
4686 to the base class vtable pointer can't alias assignments to
4687 the derived class vtable pointer, since they have different
4688 types. Thus, in an derived class destructor, where the base
4689 class constructor was inlined, we could generate bad code for
4690 setting up the vtable pointer.
4692 Therefore, we use one type for all vtable pointers. We still
4693 use a type-correct type; it's just doesn't indicate the array
4694 bounds. That's better than using `void*' or some such; it's
4695 cleaner, and it let's the alias analysis code know that these
4696 stores cannot alias stores to void*! */
4700 vtbl_ptr_type_node,
4701 t,
4702 t,
4703 empty_p);
4706 /* If there were any baseclasses, they can't possibly be at
4707 offset zero any more, because that's where the vtable
4708 pointer is. So, converting to a base class is going to
4709 take work. */
4713 }
4716 }
4718 /* Fixup the inline function given by INFO now that the class is
4719 complete. */
4721 static void
4723 tree fn;
4724 {
4726 {
4729 {
4732 }
4733 }
4734 }
4736 /* Fixup the inline methods and friends in TYPE now that TYPE is
4737 complete. */
4739 static void
4741 tree type;
4742 {
4746 {
4751 else
4753 }
4755 /* Do inline member functions. */
4759 /* Do friends. */
4761 method;
4765 }
4767 /* Add OFFSET to all base types of BINFO which is a base in the
4768 hierarchy dominated by T.
4770 OFFSET, which is a type offset, is number of bytes. */
4772 static void
4774 tree binfo;
4775 tree offset;
4776 tree t;
4777 {
4779 tree primary_binfo;
4781 /* Update BINFO's offset. */
4786 offset));
4788 /* Find the primary base class. */
4791 /* Scan all of the bases, pushing the BINFO_OFFSET adjust
4792 downwards. */
4794 {
4795 tree base_binfo;
4797 /* On the first time through the loop, do the primary base.
4798 Because the primary base need not be an immediate base, we
4799 must handle the primary base specially. */
4801 {
4806 }
4807 else
4808 {
4810 /* Don't do the primary base twice. */
4813 }
4815 /* Skip virtual bases that aren't our canonical primary base. */
4822 }
4823 }
4825 /* Called via dfs_walk from layout_virtual bases. */
4827 static tree
4829 tree binfo;
4831 {
4832 /* If this is a virtual base, make sure it has the same offset as
4833 the shared copy. If it's a primary base, then we know it's
4834 correct. */
4836 {
4838 tree vbase;
4839 tree offset;
4843 {
4846 }
4847 }
4850 }
4852 /* Set BINFO_OFFSET for all of the virtual bases for T. Update
4853 TYPE_ALIGN and TYPE_SIZE for T. OFFSETS gives the location of
4854 empty subobjects of T. */
4856 static void
4858 tree t;
4859 splay_tree offsets;
4860 {
4861 tree vbases;
4868 #ifdef STRUCTURE_SIZE_BOUNDARY
4869 /* Packed structures don't need to have minimum size. */
4872 #endif
4874 /* DSIZE is the size of the class without the virtual bases. */
4877 /* Make every class have alignment of at least one. */
4880 /* Go through the virtual bases, allocating space for each virtual
4881 base that is not already a primary base class. Under the old
4882 ABI, these are allocated according to a depth-first left-to-right
4883 postorder traversal; in the new ABI, inheritance graph order is
4884 used instead. */
4886 vbases;
4888 {
4889 tree vbase;
4896 {
4897 /* This virtual base is not a primary base of any class in the
4898 hierarchy, so we have to add space for it. */
4899 tree basetype;
4907 /* Add padding so that we can put the virtual base class at an
4908 appropriately aligned offset. */
4911 /* Under the new ABI, we try to squish empty virtual bases in
4912 just like ordinary empty bases. */
4917 else
4918 {
4919 tree offset;
4926 /* And compute the offset of the virtual base. */
4928 /* Every virtual baseclass takes a least a UNIT, so that
4929 we can take it's address and get something different
4930 for each base. */
4933 }
4935 /* Keep track of the offsets assigned to this virtual base. */
4938 offsets,
4940 }
4941 }
4943 /* Now, go through the TYPE_BINFO hierarchy, setting the
4944 BINFO_OFFSETs correctly for all non-primary copies of the virtual
4945 bases and their direct and indirect bases. The ambiguity checks
4946 in get_base_distance depend on the BINFO_OFFSETs being set
4947 correctly. */
4950 /* If we had empty base classes that protruded beyond the end of the
4951 class, we didn't update DSIZE above; we were hoping to overlay
4952 multiple such bases at the same location. */
4957 /* Now, make sure that the total size of the type is a multiple of
4958 its alignment. */
4963 bitsize_unit_node));
4965 /* Check for ambiguous virtual bases. */
4968 vbases;
4970 {
4975 }
4976 }
4978 /* Returns the offset of the byte just past the end of the base class
4979 with the highest offset in T. If INCLUDE_VIRTUALS_P is zero, then
4980 only non-virtual bases are included. */
4982 static unsigned HOST_WIDE_INT
4984 tree t;
4986 {
4991 {
4992 tree base_binfo;
4993 tree offset;
4994 tree size;
5005 /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to
5006 allocate some space for it. It cannot have virtual bases,
5007 so TYPE_SIZE_UNIT is fine. */
5009 else
5013 size);
5017 }
5020 }
5022 /* Warn about direct bases of T that are inaccessible because they are
5023 ambiguous. For example:
5025 struct S {};
5026 struct T : public S {};
5027 struct U : public S, public T {};
5029 Here, `(S*) new U' is not allowed because there are two `S'
5030 subobjects of U. */
5032 static void
5034 tree t;
5035 {
5039 {
5045 }
5046 }
5048 /* Compare two INTEGER_CSTs K1 and K2. */
5050 static int
5052 splay_tree_key k1;
5053 splay_tree_key k2;
5054 {
5056 }
5058 /* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T. Calculate
5059 BINFO_OFFSETs for all of the base-classes. Position the vtable
5060 pointer. */
5062 static void
5065 tree t;
5070 {
5071 tree non_static_data_members;
5072 tree field;
5073 tree vptr;
5074 record_layout_info rli;
5076 /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of
5077 types that appear at that offset. */
5078 splay_tree empty_base_offsets;
5080 /* Keep track of the first non-static data member. */
5083 /* Start laying out the record. */
5086 /* If possible, we reuse the virtual function table pointer from one
5087 of our base classes. */
5090 /* Create a pointer to our virtual function table. */
5094 /* Under the new ABI, the vptr is always the first thing in the
5095 class. */
5097 {
5100 }
5102 /* Build FIELD_DECLs for all of the non-virtual base-types. */
5108 /* Add pointers to all of our virtual base-classes. */
5112 /* CLASSTYPE_INLINE_FRIENDS is really TYPE_NONCOPIED_PARTS. Thus,
5113 we have to save this before we start modifying
5114 TYPE_NONCOPIED_PARTS. */
5117 /* Layout the non-static data members. */
5119 {
5120 tree type;
5121 tree padding;
5123 /* We still pass things that aren't non-static data members to
5124 the back-end, in case it wants to do something with them. */
5126 {
5129 }
5133 /* If this field is a bit-field whose width is greater than its
5134 type, then there are some special rules for allocating it
5135 under the new ABI. Under the old ABI, there were no special
5136 rules, but the back-end can't handle bitfields longer than a
5137 `long long', so we use the same mechanism. */
5140 {
5141 integer_type_kind itk;
5142 tree integer_type;
5144 /* We must allocate the bits as if suitably aligned for the
5145 longest integer type that fits in this many bits. type
5146 of the field. Then, we are supposed to use the left over
5147 bits as additional padding. */
5153 /* ITK now indicates a type that is too large for the
5154 field. We have to back up by one to find the largest
5155 type that fits. */
5162 }
5163 else
5169 /* If we needed additional padding after this field, add it
5170 now. */
5172 {
5173 tree padding_field;
5176 NULL_TREE,
5177 char_type_node);
5183 NULL_TREE,
5185 }
5186 }
5188 /* It might be the case that we grew the class to allocate a
5189 zero-sized base class. That won't be reflected in RLI, yet,
5190 because we are willing to overlay multiple bases at the same
5191 offset. However, now we need to make sure that RLI is big enough
5192 to reflect the entire class. */
5196 {
5199 }
5201 /* We make all structures have at least one element, so that they
5202 have non-zero size. In the new ABI, the class may be empty even
5203 if it has basetypes. Therefore, we add the fake field after all
5204 the other fields; if there are already FIELD_DECLs on the list,
5205 their offsets will not be disturbed. */
5207 {
5208 tree padding;
5215 }
5217 /* Let the back-end lay out the type. Note that at this point we
5218 have only included non-virtual base-classes; we will lay out the
5219 virtual base classes later. So, the TYPE_SIZE/TYPE_ALIGN after
5220 this call are not necessarily correct; they are just the size and
5221 alignment when no virtual base clases are used. */
5224 /* Delete all zero-width bit-fields from the list of fields. Now
5225 that the type is laid out they are no longer important. */
5228 /* Remember the size and alignment of the class before adding
5229 the virtual bases. */
5231 {
5234 }
5235 else
5236 {
5239 }
5244 /* Set the TYPE_DECL for this type to contain the right
5245 value for DECL_OFFSET, so that we can use it as part
5246 of a COMPONENT_REF for multiple inheritance. */
5249 /* Now fix up any virtual base class types that we left lying
5250 around. We must get these done before we try to lay out the
5251 virtual function table. As a side-effect, this will remove the
5252 base subobject fields. */
5255 /* Warn about direct bases that can't be talked about due to
5256 ambiguity. */
5259 /* Clean up. */
5261 }
5263 /* Create a RECORD_TYPE or UNION_TYPE node for a C struct or union declaration
5264 (or C++ class declaration).
5266 For C++, we must handle the building of derived classes.
5267 Also, C++ allows static class members. The way that this is
5268 handled is to keep the field name where it is (as the DECL_NAME
5269 of the field), and place the overloaded decl in the bit position
5270 of the field. layout_record and layout_union will know about this.
5272 More C++ hair: inline functions have text in their
5273 DECL_PENDING_INLINE_INFO nodes which must somehow be parsed into
5274 meaningful tree structure. After the struct has been laid out, set
5275 things up so that this can happen.
5277 And still more: virtual functions. In the case of single inheritance,
5278 when a new virtual function is seen which redefines a virtual function
5279 from the base class, the new virtual function is placed into
5280 the virtual function table at exactly the same address that
5281 it had in the base class. When this is extended to multiple
5282 inheritance, the same thing happens, except that multiple virtual
5283 function tables must be maintained. The first virtual function
5284 table is treated in exactly the same way as in the case of single
5285 inheritance. Additional virtual function tables have different
5286 DELTAs, which tell how to adjust `this' to point to the right thing.
5288 ATTRIBUTES is the set of decl attributes to be applied, if any. */
5290 void
5292 tree t;
5293 {
5294 tree x;
5296 /* The NEW_VIRTUALS is a TREE_LIST. The TREE_VALUE of each node is
5297 a FUNCTION_DECL. Each of these functions is a virtual function
5298 declared in T that does not override any virtual function from a
5299 base class. */
5301 /* The OVERRIDDEN_VIRTUALS list is like the NEW_VIRTUALS list,
5302 except that each declaration here overrides the declaration from
5303 a base class. */
5306 tree vfield;
5310 {
5313 else
5317 }
5321 /* If this type was previously laid out as a forward reference,
5322 make sure we lay it out again. */
5329 /* Do end-of-class semantic processing: checking the validity of the
5330 bases and members and add implicitly generated methods. */
5333 /* Layout the class itself. */
5337 /* Make sure that we get our own copy of the vfield FIELD_DECL. */
5341 {
5352 }
5354 overridden_virtuals
5357 /* If we created a new vtbl pointer for this class, add it to the
5358 list. */
5363 /* If necessary, create the primary vtable for this class. */
5365 || overridden_virtuals
5367 {
5369 /* We must enter these virtuals into the table. */
5373 /* Here we know enough to change the type of our virtual
5374 function table, but we will wait until later this function. */
5377 /* If this type has basetypes with constructors, then those
5378 constructors might clobber the virtual function table. But
5379 they don't if the derived class shares the exact vtable of the base
5380 class. */
5383 }
5384 /* If we didn't need a new vtable, see if we should copy one from
5385 the base. */
5387 {
5390 /* If this class uses a different vtable than its primary base
5391 then when we will need to initialize our vptr after the base
5392 class constructor runs. */
5395 }
5398 {
5407 /* Entries for virtual functions defined in the primary base are
5408 followed by entries for new functions unique to this class. */
5411 /* Finally, add entries for functions that override virtuals
5412 from non-primary bases. */
5415 }
5419 /* Complete the rtl for any static member objects of the type we're
5420 working on. */
5426 /* Done with FIELDS...now decide whether to sort these for
5427 faster lookups later.
5429 The C front-end only does this when n_fields > 15. We use
5430 a smaller number because most searches fail (succeeding
5431 ultimately as the search bores through the inheritance
5432 hierarchy), and we want this failure to occur quickly. */
5436 {
5444 }
5447 {
5451 {
5452 /* Mark the fact that constructor for T
5453 could affect anybody inheriting from T
5454 who wants to initialize vtables for VFIELDS's type. */
5458 }
5459 }
5461 /* Make the rtl for any new vtables we have created, and unmark
5462 the base types we marked. */
5465 /* Build the VTT for T. */
5469 {
5470 /* In addition to this one, all the other vfields should be listed. */
5471 /* Before that can be done, we have to have FIELD_DECLs for them, and
5472 a place to find them. */
5480 t);
5481 }
5492 /* Finish debugging output for this type. */
5494 }
5496 /* When T was built up, the member declarations were added in reverse
5497 order. Rearrange them to declaration order. */
5499 void
5501 tree t;
5502 {
5503 tree next;
5504 tree prev;
5505 tree x;
5507 /* The TYPE_FIELDS, TYPE_METHODS, and CLASSTYPE_TAGS are all in
5508 reverse order. Put them in declaration order now. */
5512 /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
5513 reverse order, so we can't just use nreverse. */
5518 {
5522 }
5524 {
5528 }
5529 }
5531 tree
5534 {
5538 /* Now that we've got all the field declarations, reverse everything
5539 as necessary. */
5544 /* Nadger the current location so that diagnostics point to the start of
5545 the struct, not the end. */
5550 {
5553 }
5554 else
5564 else
5568 {
5572 }
5575 }
5576 \f
5577 /* Return the dynamic type of INSTANCE, if known.
5578 Used to determine whether the virtual function table is needed
5579 or not.
5581 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5582 of our knowledge of its type. *NONNULL should be initialized
5583 before this function is called. */
5585 static tree
5587 tree instance;
5590 {
5592 {
5594 /* Check that we are not going through a cast of some sort. */
5598 /* fall through... */
5600 /* This is a call to a constructor, hence it's never zero. */
5602 {
5606 }
5610 /* This is a call to a constructor, hence it's never zero. */
5612 {
5616 }
5627 /* Propagate nonnull. */
5647 {
5651 }
5652 /* fall through... */
5656 {
5660 }
5662 {
5666 /* if we're in a ctor or dtor, we know our type. */
5670 {
5674 }
5675 }
5677 {
5678 /* Reference variables should be references to objects. */
5681 }
5686 }
5687 }
5689 /* Return non-zero if the dynamic type of INSTANCE is known, and equivalent
5690 to the static type. We also handle the case where INSTANCE is really
5691 a pointer. Return negative if this is a ctor/dtor. There the dynamic type
5692 is known, but this might not be the most derived base of the original object,
5693 and hence virtual bases may not be layed out according to this type.
5695 Used to determine whether the virtual function table is needed
5696 or not.
5698 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5699 of our knowledge of its type. *NONNULL should be initialized
5700 before this function is called. */
5702 int
5704 tree instance;
5706 {
5718 }
5720 \f
5721 void
5723 {
5726 current_class_stack
5744 }
5746 /* Set current scope to NAME. CODE tells us if this is a
5747 STRUCT, UNION, or ENUM environment.
5749 NAME may end up being NULL_TREE if this is an anonymous or
5750 late-bound struct (as in "struct { ... } foo;") */
5752 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE to
5753 appropriate values, found by looking up the type definition of
5754 NAME (as a CODE).
5756 If MODIFY is 1, we set IDENTIFIER_CLASS_VALUE's of names
5757 which can be seen locally to the class. They are shadowed by
5758 any subsequent local declaration (including parameter names).
5760 If MODIFY is 2, we set IDENTIFIER_CLASS_VALUE's of names
5761 which have static meaning (i.e., static members, static
5762 member functions, enum declarations, etc).
5764 If MODIFY is 3, we set IDENTIFIER_CLASS_VALUE of names
5765 which can be seen locally to the class (as in 1), but
5766 know that we are doing this for declaration purposes
5767 (i.e. friend foo::bar (int)).
5769 So that we may avoid calls to lookup_name, we cache the _TYPE
5770 nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
5772 For multiple inheritance, we perform a two-pass depth-first search
5773 of the type lattice. The first pass performs a pre-order search,
5774 marking types after the type has had its fields installed in
5775 the appropriate IDENTIFIER_CLASS_VALUE slot. The second pass merely
5776 unmarks the marked types. If a field or member function name
5777 appears in an ambiguous way, the IDENTIFIER_CLASS_VALUE of
5778 that name becomes `error_mark_node'. */
5780 void
5782 tree type;
5784 {
5787 /* Make sure there is enough room for the new entry on the stack. */
5789 {
5791 current_class_stack
5793 current_class_stack_size
5795 }
5797 /* Insert a new entry on the class stack. */
5802 current_class_depth++;
5804 /* Now set up the new type. */
5810 /* By default, things in classes are private, while things in
5811 structures or unions are public. */
5813 ? access_private_node
5820 {
5821 /* Forcibly remove any old class remnants. */
5823 }
5825 /* If we're about to enter a nested class, clear
5826 IDENTIFIER_CLASS_VALUE for the enclosing classes. */
5833 {
5836 else
5837 {
5838 tree item;
5840 /* We are re-entering the same class we just left, so we
5841 don't have to search the whole inheritance matrix to find
5842 all the decls to bind again. Instead, we install the
5843 cached class_shadowed list, and walk through it binding
5844 names and setting up IDENTIFIER_TYPE_VALUEs. */
5847 {
5854 }
5856 }
5859 }
5860 }
5862 /* When we exit a toplevel class scope, we save the
5863 IDENTIFIER_CLASS_VALUEs so that we can restore them quickly if we
5864 reenter the class. Here, we've entered some other class, so we
5865 must invalidate our cache. */
5867 void
5869 {
5870 tree t;
5872 /* The IDENTIFIER_CLASS_VALUEs are no longer valid. */
5878 }
5880 /* Get out of the current class scope. If we were in a class scope
5881 previously, that is the one popped to. */
5883 void
5885 {
5887 /* Since poplevel_class does the popping of class decls nowadays,
5888 this really only frees the obstack used for these decls. */
5891 current_class_depth--;
5897 }
5899 /* Returns 1 if current_class_type is either T or a nested type of T.
5900 We start looking from 1 because entry 0 is from global scope, and has
5901 no type. */
5903 int
5905 tree t;
5906 {
5914 }
5916 /* If either current_class_type or one of its enclosing classes are derived
5917 from T, return the appropriate type. Used to determine how we found
5918 something via unqualified lookup. */
5920 tree
5922 tree t;
5923 {
5934 }
5936 /* When entering a class scope, all enclosing class scopes' names with
5937 static meaning (static variables, static functions, types and enumerators)
5938 have to be visible. This recursive function calls pushclass for all
5939 enclosing class contexts until global or a local scope is reached.
5940 TYPE is the enclosed class and MODIFY is equivalent with the pushclass
5941 formal of the same name. */
5943 void
5945 tree type;
5947 {
5948 tree context;
5950 /* A namespace might be passed in error cases, like A::B:C. */
5964 }
5966 /* Undoes a push_nested_class call. MODIFY is passed on to popclass. */
5968 void
5970 {
5976 }
5978 /* Returns the number of extern "LANG" blocks we are nested within. */
5980 int
5982 {
5984 }
5986 /* Set global variables CURRENT_LANG_NAME to appropriate value
5987 so that behavior of name-mangling machinery is correct. */
5989 void
5991 tree name;
5992 {
5996 {
5998 }
6000 {
6002 /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
6003 (See record_builtin_java_type in decl.c.) However, that causes
6004 incorrect debug entries if these types are actually used.
6005 So we re-enable debug output after extern "Java". */
6014 }
6016 {
6018 }
6019 else
6021 }
6023 /* Get out of the current language scope. */
6025 void
6027 {
6030 }
6031 \f
6032 /* Type instantiation routines. */
6034 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
6035 matches the TARGET_TYPE. If there is no satisfactory match, return
6036 error_mark_node, and issue an error message if COMPLAIN is
6037 non-zero. Permit pointers to member function if PTRMEM is non-zero.
6038 If TEMPLATE_ONLY, the name of the overloaded function
6039 was a template-id, and EXPLICIT_TARGS are the explicitly provided
6040 template arguments. */
6042 static tree
6044 overload,
6045 complain,
6046 ptrmem,
6047 template_only,
6048 explicit_targs)
6049 tree target_type;
6050 tree overload;
6054 tree explicit_targs;
6055 {
6056 /* Here's what the standard says:
6058 [over.over]
6060 If the name is a function template, template argument deduction
6061 is done, and if the argument deduction succeeds, the deduced
6062 arguments are used to generate a single template function, which
6063 is added to the set of overloaded functions considered.
6065 Non-member functions and static member functions match targets of
6066 type "pointer-to-function" or "reference-to-function." Nonstatic
6067 member functions match targets of type "pointer-to-member
6068 function;" the function type of the pointer to member is used to
6069 select the member function from the set of overloaded member
6070 functions. If a nonstatic member function is selected, the
6071 reference to the overloaded function name is required to have the
6072 form of a pointer to member as described in 5.3.1.
6074 If more than one function is selected, any template functions in
6075 the set are eliminated if the set also contains a non-template
6076 function, and any given template function is eliminated if the
6077 set contains a second template function that is more specialized
6078 than the first according to the partial ordering rules 14.5.5.2.
6079 After such eliminations, if any, there shall remain exactly one
6080 selected function. */
6084 /* We store the matches in a TREE_LIST rooted here. The functions
6085 are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
6086 interoperability with most_specialized_instantiation. */
6088 tree fn;
6090 /* By the time we get here, we should be seeing only real
6091 pointer-to-member types, not the internal POINTER_TYPE to
6092 METHOD_TYPE representation. */
6100 /* Check that the TARGET_TYPE is reasonable. */
6104 /* This is OK, too. */
6107 {
6108 /* This is OK, too. This comes from a conversion to reference
6109 type. */
6112 }
6113 else
6114 {
6120 }
6122 /* If we can find a non-template function that matches, we can just
6123 use it. There's no point in generating template instantiations
6124 if we're just going to throw them out anyhow. But, of course, we
6125 can only do this when we don't *need* a template function. */
6127 {
6128 tree fns;
6131 {
6133 tree fntype;
6136 /* We're not looking for templates just yet. */
6141 /* We're looking for a non-static member, and this isn't
6142 one, or vice versa. */
6145 /* See if there's a match. */
6154 }
6155 }
6157 /* Now, if we've already got a match (or matches), there's no need
6158 to proceed to the template functions. But, if we don't have a
6159 match we need to look at them, too. */
6161 {
6162 tree target_fn_type;
6163 tree target_arg_types;
6164 tree target_ret_type;
6165 tree fns;
6168 target_fn_type
6170 else
6175 /* Never do unification on the 'this' parameter. */
6180 {
6182 tree instantiation;
6183 tree instantiation_type;
6184 tree targs;
6187 /* We're only looking for templates. */
6192 /* We're not looking for a non-static member, and this is
6193 one, or vice versa. */
6196 /* Try to do argument deduction. */
6201 /* Argument deduction failed. */
6204 /* Instantiate the template. */
6207 /* Instantiation failed. */
6210 /* See if there's a match. */
6213 instantiation_type =
6219 }
6221 /* Now, remove all but the most specialized of the matches. */
6223 {
6228 }
6229 }
6231 /* Now we should have exactly one function in MATCHES. */
6233 {
6234 /* There were *no* matches. */
6236 {
6239 target_type);
6241 /* print_candidates expects a chain with the functions in
6242 TREE_VALUE slots, so we cons one up here (we're losing anyway,
6243 so why be clever?). */
6246 matches);
6249 }
6251 }
6253 {
6254 /* There were too many matches. */
6257 {
6258 tree match;
6262 target_type);
6264 /* Since print_candidates expects the functions in the
6265 TREE_VALUE slot, we flip them here. */
6270 }
6273 }
6275 /* Good, exactly one match. Now, convert it to the correct type. */
6280 {
6288 {
6291 }
6292 }
6297 else
6298 {
6299 /* The target must be a REFERENCE_TYPE. Above, build_unary_op
6300 will mark the function as addressed, but here we must do it
6301 explicitly. */
6305 }
6306 }
6308 /* This function will instantiate the type of the expression given in
6309 RHS to match the type of LHSTYPE. If errors exist, then return
6310 error_mark_node. FLAGS is a bit mask. If ITF_COMPLAIN is set, then
6311 we complain on errors. If we are not complaining, never modify rhs,
6312 as overload resolution wants to try many possible instantiations, in
6313 the hope that at least one will work.
6315 For non-recursive calls, LHSTYPE should be a function, pointer to
6316 function, or a pointer to member function. */
6318 tree
6322 {
6331 {
6335 }
6338 {
6345 }
6347 /* We don't overwrite rhs if it is an overloaded function.
6348 Copying it would destroy the tree link. */
6352 /* This should really only be used when attempting to distinguish
6353 what sort of a pointer to function we have. For now, any
6354 arithmetic operation which is not supported on pointers
6355 is rejected as an error. */
6358 {
6369 {
6370 tree new_rhs;
6380 }
6396 /* This can happen if we are forming a pointer-to-member for a
6397 member template. */
6400 /* Fall through. */
6403 {
6407 return
6409 fns,
6410 complain,
6411 allow_ptrmem,
6413 args);
6414 }
6417 return
6419 rhs,
6420 complain,
6421 allow_ptrmem,
6426 /* Now we should have a baselink. */
6432 /* This is too hard for now. */
6506 {
6510 }
6533 {
6538 }
6549 }
6550 }
6551 \f
6552 /* Return the name of the virtual function pointer field
6553 (as an IDENTIFIER_NODE) for the given TYPE. Note that
6554 this may have to look back through base types to find the
6555 ultimate field name. (For single inheritance, these could
6556 all be the same name. Who knows for multiple inheritance). */
6558 static tree
6560 tree type;
6561 {
6575 }
6577 void
6579 {
6580 #ifdef GATHER_STATISTICS
6586 {
6591 }
6592 #endif
6593 }
6595 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
6596 according to [class]:
6597 The class-name is also inserted
6598 into the scope of the class itself. For purposes of access checking,
6599 the inserted class name is treated as if it were a public member name. */
6601 void
6603 {
6606 tree saved_cas;
6619 }
6621 /* Returns 1 if TYPE contains only padding bytes. */
6623 int
6625 tree type;
6626 {
6634 }
6636 /* Find the enclosing class of the given NODE. NODE can be a *_DECL or
6637 a *_TYPE node. NODE can also be a local class. */
6639 tree
6641 tree type;
6642 {
6646 {
6648 {
6661 }
6662 }
6664 }
6666 /* Return 1 if TYPE or one of its enclosing classes is derived from BASE. */
6668 int
6671 {
6673 {
6678 }
6680 }
6682 /* Note that NAME was looked up while the current class was being
6683 defined and that the result of that lookup was DECL. */
6685 void
6687 tree name;
6688 tree decl;
6689 {
6690 splay_tree names_used;
6692 /* If we're not defining a class, there's nothing to do. */
6696 /* If there's already a binding for this NAME, then we don't have
6697 anything to worry about. */
6709 }
6711 /* Note that NAME was declared (as DECL) in the current class. Check
6712 to see that the declaration is legal. */
6714 void
6716 tree name;
6717 tree decl;
6718 {
6719 splay_tree names_used;
6720 splay_tree_node n;
6722 /* Look to see if we ever used this name. */
6723 names_used
6730 {
6731 /* [basic.scope.class]
6733 A name N used in a class S shall refer to the same declaration
6734 in its context and when re-evaluated in the completed scope of
6735 S. */
6740 }
6741 }
6743 /* Returns the VAR_DECL for the complete vtable associated with
6744 BINFO. (Under the new ABI, secondary vtables are merged with
6745 primary vtables; this function will return the VAR_DECL for the
6746 primary vtable.) */
6748 tree
6750 tree binfo;
6751 {
6752 tree decl;
6756 {
6760 }
6764 }
6766 /* Called from get_primary_binfo via dfs_walk. DATA is a TREE_LIST
6767 who's TREE_PURPOSE is the TYPE of the required primary base and
6768 who's TREE_VALUE is a list of candidate binfos that we fill in. */
6770 static tree
6772 tree binfo;
6774 {
6780 /* This is the right type of binfo, but it might be an unshared
6781 instance, and the shared instance is later in the dfs walk. We
6782 must keep looking. */
6786 }
6788 /* Returns the unshared binfo for the primary base of BINFO. Note
6789 that in a complex hierarchy the resulting BINFO may not actually
6790 *be* primary. In particular if the resulting BINFO is a virtual
6791 base, and it occurs elsewhere in the hierarchy, then this
6792 occurrence may not actually be a primary base in the complete
6793 object. Check BINFO_PRIMARY_P to be sure. */
6795 tree
6797 tree binfo;
6798 {
6799 tree primary_base;
6801 tree virtuals;
6807 /* A non-virtual primary base is always a direct base, and easy to
6808 find. */
6810 {
6813 /* Scan the direct basetypes until we find a base with the same
6814 type as the primary base. */
6816 {
6822 }
6824 /* We should always find the primary base. */
6826 }
6828 /* For a primary virtual base, we have to scan the entire hierarchy
6829 rooted at BINFO; the virtual base could be an indirect virtual
6830 base. There could be more than one instance of the primary base
6831 in the hierarchy, and if one is the canonical binfo we want that
6832 one. If it exists, it should be the first one we find, but as a
6833 consistency check we find them all and make sure. */
6838 /* We must have found at least one instance. */
6842 {
6843 /* We found more than one instance of the base. We must make
6844 sure that, if one is the canonical one, it is the first one
6845 we found. As the chain is in reverse dfs order, that means
6846 the last on the list. */
6847 tree complete_binfo;
6848 tree canonical;
6858 {
6862 {
6863 /* This is the unshared instance. Make sure it was the
6864 first one found. */
6867 }
6868 }
6869 }
6870 else
6873 }
6875 /* If INDENTED_P is zero, indent to INDENT. Return non-zero. */
6877 static int
6882 {
6886 }
6888 /* Dump the offsets of all the bases rooted at BINFO (in the hierarchy
6889 dominated by T) to stderr. INDENT should be zero when called from
6890 the top level; it is incremented recursively. */
6892 static void
6896 tree t;
6897 tree binfo;
6899 {
6914 {
6920 else
6922 }
6927 {
6931 TFF_PLAIN_IDENTIFIER),
6933 }
6935 {
6938 }
6943 {
6947 {
6951 TFF_PLAIN_IDENTIFIER));
6952 }
6954 {
6958 TFF_PLAIN_IDENTIFIER));
6959 }
6961 {
6965 TFF_PLAIN_IDENTIFIER));
6966 }
6968 {
6972 TFF_PLAIN_IDENTIFIER));
6973 }
6977 }
6984 }
6986 /* Dump the BINFO hierarchy for T. */
6988 static void
6990 tree t;
6991 {
7005 }
7007 static void
7010 tree decl;
7011 {
7012 tree inits;
7014 HOST_WIDE_INT elt;
7022 TFF_PLAIN_IDENTIFIER));
7029 }
7031 static void
7033 tree t;
7034 tree binfo;
7035 tree vtable;
7036 {
7044 {
7051 {
7055 }
7059 }
7062 }
7064 static void
7066 tree t;
7067 tree vtt;
7068 {
7076 {
7081 }
7084 }
7086 /* Virtual function table initialization. */
7088 /* Create all the necessary vtables for T and its base classes. */
7090 static void
7092 tree t;
7093 {
7095 {
7096 tree list;
7097 tree vbase;
7099 /* Under the new ABI, we lay out the primary and secondary
7100 vtables in one contiguous vtable. The primary vtable is
7101 first, followed by the non-virtual secondary vtables in
7102 inheritance graph order. */
7106 /* Then come the virtual bases, also in inheritance graph
7107 order. */
7109 {
7110 tree real_base;
7115 /* Although we walk in inheritance order, that might not get the
7116 canonical base. */
7121 }
7125 }
7126 else
7127 {
7132 }
7133 }
7135 /* Called from finish_vtbls via dfs_walk. */
7137 static tree
7139 tree binfo;
7141 {
7152 }
7154 /* Initialize the vtable for BINFO with the INITS. */
7156 static void
7158 tree binfo;
7159 tree inits;
7160 {
7161 tree decl;
7167 }
7169 /* Initialize DECL (a declaration for a namespace-scope array) with
7170 the INITS. */
7172 static void
7174 tree decl;
7175 tree inits;
7176 {
7177 tree context;
7184 }
7186 /* Build the VTT (virtual table table) for T.
7187 A class requires a VTT if it has virtual bases.
7189 This holds
7190 1 - primary virtual pointer for complete object T
7191 2 - secondary VTTs for each direct non-virtual base of T which requires a
7192 VTT
7193 3 - secondary virtual pointers for each direct or indirect base of T which
7194 has virtual bases or is reachable via a virtual path from T.
7195 4 - secondary VTTs for each direct or indirect virtual base of T.
7197 Secondary VTTs look like complete object VTTs without part 4. */
7199 static void
7201 tree t;
7202 {
7203 tree inits;
7204 tree type;
7205 tree vtt;
7206 tree index;
7208 /* Build up the initializers for the VTT. */
7213 /* If we didn't need a VTT, we're done. */
7217 /* Figure out the type of the VTT. */
7221 /* Now, build the VTT object itself. */
7227 }
7229 /* The type corresponding to BASE_BINFO is a base of the type of BINFO, but
7230 from within some heirarchy which is inherited from the type of BINFO.
7231 Return BASE_BINFO's equivalent binfo from the hierarchy dominated by
7232 BINFO. */
7234 static tree
7236 tree base_binfo;
7237 tree binfo;
7238 {
7239 tree derived;
7254 }
7256 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
7257 PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
7258 and CHAIN the vtable pointer for this binfo after construction is
7259 complete. VALUE can also be another BINFO, in which case we recurse. */
7261 static tree
7263 tree binfo;
7264 {
7265 tree vt;
7268 {
7274 else
7276 }
7279 }
7281 /* Recursively build the VTT-initializer for BINFO (which is in the
7282 hierarchy dominated by T). INITS points to the end of the initializer
7283 list to date. INDEX is the VTT index where the next element will be
7284 replaced. Iff BINFO is the binfo for T, this is the top level VTT (i.e.
7285 not a subvtt for some base of T). When that is so, we emit the sub-VTTs
7286 for virtual bases of T. When it is not so, we build the constructor
7287 vtables for the BINFO-in-T variant. */
7291 tree binfo;
7292 tree t;
7295 {
7297 tree b;
7298 tree init;
7299 tree secondary_vptrs;
7302 /* We only need VTTs for subobjects with virtual bases. */
7306 /* We need to use a construction vtable if this is not the primary
7307 VTT. */
7309 {
7312 /* Record the offset in the VTT where this sub-VTT can be found. */
7314 }
7316 /* Add the address of the primary vtable for the complete object. */
7321 {
7324 }
7327 /* Recursively add the secondary VTTs for non-virtual bases. */
7329 {
7334 }
7336 /* Add secondary virtual pointers for all subobjects of BINFO with
7337 either virtual bases or reachable along a virtual path, except
7338 subobjects that are non-virtual primary bases. */
7345 dfs_build_secondary_vptr_vtt_inits,
7346 NULL,
7347 dfs_ctor_vtable_bases_queue_p,
7348 secondary_vptrs);
7351 secondary_vptrs);
7355 /* The secondary vptrs come back in reverse order. After we reverse
7356 them, and add the INITS, the last init will be the first element
7357 of the chain. */
7360 {
7364 }
7366 /* Add the secondary VTTs for virtual bases. */
7369 {
7370 tree vbase;
7377 }
7380 {
7386 dfs_ctor_vtable_bases_queue_p,
7387 data);
7388 }
7391 }
7393 /* Called from build_vtt_inits via dfs_walk. BINFO is the binfo
7394 for the base in most derived. DATA is a TREE_LIST who's
7395 TREE_CHAIN is the type of the base being
7396 constructed whilst this secondary vptr is live. The TREE_UNSIGNED
7397 flag of DATA indicates that this is a constructor vtable. The
7398 TREE_TOP_LEVEL flag indicates that this is the primary VTT. */
7400 static tree
7402 tree binfo;
7404 {
7405 tree l;
7406 tree t;
7407 tree init;
7408 tree index;
7417 /* We don't care about bases that don't have vtables. */
7421 /* We're only interested in proper subobjects of T. */
7425 /* We're not interested in non-virtual primary bases. */
7429 /* If BINFO has virtual bases or is reachable via a virtual path
7430 from T, it'll have a secondary vptr. */
7435 /* Record the index where this secondary vptr can be found. */
7438 {
7441 }
7445 /* Add the initializer for the secondary vptr itself. */
7447 {
7448 /* It's a primary virtual base, and this is not the construction
7449 vtable. Find the base this is primary of in the inheritance graph,
7450 and use that base's vtable now. */
7453 }
7458 }
7460 /* dfs_walk_real predicate for building vtables. DATA is a TREE_LIST,
7461 TREE_UNSIGNED indicates that a constructor vtable is being built.
7462 TREE_USED indicates whether marked or unmarked bases should be walked.
7463 TREE_PURPOSE is the TREE_TYPE that dominates the hierarchy. */
7465 static tree
7467 tree binfo;
7469 {
7471 {
7474 /* This is a non-primary virtual base, get the shared version. */
7478 }
7482 }
7484 /* Called from build_vtt_inits via dfs_walk. After building constructor
7485 vtables and generating the sub-vtt from them, we need to restore the
7486 BINFO_VTABLES that were scribbled on. DATA is a TREE_LIST whose
7487 TREE_VALUE is the TREE_TYPE of the base whose sub vtt was generated. */
7489 static tree
7491 tree binfo;
7493 {
7496 /* We don't care about bases that don't have vtables. */
7500 /* If we scribbled the construction vtable vptr into BINFO, clear it
7501 out now. */
7509 }
7511 /* Build the construction vtable group for BINFO which is in the
7512 hierarchy dominated by T. */
7514 static void
7516 tree binfo;
7517 tree t;
7518 {
7519 tree list;
7520 tree type;
7521 tree vtbl;
7522 tree inits;
7523 tree id;
7524 tree vbase;
7526 /* See if we've already created this construction vtable group. */
7532 /* Build a version of VTBL (with the wrong type) for use in
7533 constructing the addresses of secondary vtables in the
7534 construction vtable group. */
7540 /* Add the vtables for each of our virtual bases using the vbase in T
7541 binfo. */
7543 vbase;
7545 {
7546 tree b;
7547 tree orig_base;
7555 }
7558 /* Figure out the type of the construction vtable. */
7563 /* Initialize the construction vtable. */
7567 }
7569 /* Add the vtbl initializers for BINFO (and its bases other than
7570 non-virtual primaries) to the list of INITS. BINFO is in the
7571 hierarchy dominated by T. RTTI_BINFO is the binfo within T of
7572 the constructor the vtbl inits should be accumulated for. (If this
7573 is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
7574 ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
7575 BINFO is the active base equivalent of ORIG_BINFO in the inheritance
7576 graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
7577 but are not necessarily the same in terms of layout. */
7579 static void
7581 tree binfo;
7582 tree orig_binfo;
7583 tree rtti_binfo;
7584 tree t;
7585 tree inits;
7586 {
7594 /* If it doesn't have a vptr, we don't do anything. */
7598 /* If we're building a construction vtable, we're not interested in
7599 subobjects that don't require construction vtables. */
7605 /* Build the initializers for the BINFO-in-T vtable. */
7611 /* Walk the BINFO and its bases. We walk in preorder so that as we
7612 initialize each vtable we can figure out at what offset the
7613 secondary vtable lies from the primary vtable. We can't use
7614 dfs_walk here because we need to iterate through bases of BINFO
7615 and RTTI_BINFO simultaneously. */
7617 {
7620 /* Skip virtual bases. */
7626 inits);
7627 }
7628 }
7630 /* Called from accumulate_vtbl_inits when using the new ABI.
7631 Accumulates the vtable initializers for all of the vtables into
7632 TREE_VALUE (DATA). Returns the initializers for the BINFO vtable. */
7634 static tree
7636 tree binfo;
7637 tree orig_binfo;
7638 tree rtti_binfo;
7639 tree t;
7640 tree l;
7641 {
7648 {
7649 /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
7650 primary virtual base. If it is not the same primary in
7651 the hierarchy of T, we'll need to generate a ctor vtable
7652 for it, to place at its location in T. If it is the same
7653 primary, we still need a VTT entry for the vtable, but it
7654 should point to the ctor vtable for the base it is a
7655 primary for within the sub-hierarchy of RTTI_BINFO.
7657 There are three possible cases:
7659 1) We are in the same place.
7660 2) We are a primary base within a lost primary virtual base of
7661 RTTI_BINFO.
7662 3) We are primary to something not a base of RTTI_BINFO. */
7667 /* First, look through the bases we are primary to for RTTI_BINFO
7668 or a virtual base. */
7670 {
7674 }
7675 /* If we run out of primary links, keep looking down our
7676 inheritance chain; we might be an indirect primary. */
7682 /* If we found RTTI_BINFO, this is case 1. If we found a virtual
7683 base B and it is a base of RTTI_BINFO, this is case 2. In
7684 either case, we share our vtable with LAST, i.e. the
7685 derived-most base within B of which we are a primary. */
7689 /* Just set our BINFO_VTABLE to point to LAST, as we may not have
7690 set LAST's BINFO_VTABLE yet. We'll extract the actual vptr in
7691 binfo_ctor_vtable after everything's been set up. */
7694 /* Otherwise, this is case 3 and we get our own. */
7695 }
7700 {
7701 tree index;
7704 /* Compute the initializer for this vtable. */
7708 /* Figure out the position to which the VPTR should point. */
7711 vtbl_ptr_type_node,
7712 vtbl);
7719 index);
7722 }
7725 /* For a construction vtable, we can't overwrite BINFO_VTABLE.
7726 So, we make a TREE_LIST. Later, dfs_fixup_binfo_vtbls will
7727 straighten this out. */
7731 else
7732 /* For an ordinary vtable, set BINFO_VTABLE. */
7736 }
7738 /* Construct the initializer for BINFO's virtual function table. BINFO
7739 is part of the hierarchy dominated by T. If we're building a
7740 construction vtable, the ORIG_BINFO is the binfo we should use to
7741 find the actual function pointers to put in the vtable - but they
7742 can be overridden on the path to most-derived in the graph that
7743 ORIG_BINFO belongs. Otherwise,
7744 ORIG_BINFO should be the same as BINFO. The RTTI_BINFO is the
7745 BINFO that should be indicated by the RTTI information in the
7746 vtable; it will be a base class of T, rather than T itself, if we
7747 are building a construction vtable.
7749 The value returned is a TREE_LIST suitable for wrapping in a
7750 CONSTRUCTOR to use as the DECL_INITIAL for a vtable. If
7751 NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
7752 number of non-function entries in the vtable.
7754 It might seem that this function should never be called with a
7755 BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
7756 base is always subsumed by a derived class vtable. However, when
7757 we are building construction vtables, we do build vtables for
7758 primary bases; we need these while the primary base is being
7759 constructed. */
7761 static tree
7763 tree binfo;
7764 tree orig_binfo;
7765 tree t;
7766 tree rtti_binfo;
7768 {
7770 tree vfun_inits;
7771 tree vbase;
7772 vtbl_init_data vid;
7774 /* Initialize VID. */
7782 /* The first vbase or vcall offset is at index -3 in the vtable. */
7785 /* Add entries to the vtable for RTTI. */
7788 /* Create an array for keeping track of the functions we've
7789 processed. When we see multiple functions with the same
7790 signature, we share the vcall offsets. */
7792 /* Add the vcall and vbase offset entries. */
7794 /* Clean up. */
7796 /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
7797 build_vbase_offset_vtbl_entries. */
7799 vbase;
7806 /* Go through all the ordinary virtual functions, building up
7807 initializers. */
7810 {
7811 tree delta;
7812 tree vcall_index;
7813 tree fn;
7814 tree pfn;
7815 tree init;
7817 /* Pull the offset for `this', and the function to call, out of
7818 the list. */
7822 {
7825 }
7826 else
7833 /* You can't call an abstract virtual function; it's abstract.
7834 So, we replace these functions with __pure_virtual. */
7838 /* Take the address of the function, considering it to be of an
7839 appropriate generic type. */
7841 /* The address of a function can't change. */
7844 /* Enter it in the vtable. */
7847 /* If the only definition of this function signature along our
7848 primary base chain is from a lost primary, this vtable slot will
7849 never be used, so just zero it out. This is important to avoid
7850 requiring extra thunks which cannot be generated with the function.
7852 We could also handle this in update_vtable_entry_for_fn; doing it
7853 here means we zero out unused slots in ctor vtables as well,
7854 rather than filling them with erroneous values (though harmless,
7855 apart from relocation costs). */
7858 {
7859 /* We found a defn before a lost primary; go ahead as normal. */
7863 /* The nearest definition is from a lost primary; clear the
7864 slot. */
7866 {
7869 }
7870 }
7872 /* And add it to the chain of initializers. */
7874 }
7876 /* The initializers for virtual functions were built up in reverse
7877 order; straighten them out now. */
7880 /* The negative offset initializers are also in reverse order. */
7883 /* Chain the two together. */
7885 }
7887 /* Adds to vid->inits the initializers for the vbase and vcall
7888 offsets in BINFO, which is in the hierarchy dominated by T. */
7890 static void
7892 tree binfo;
7894 {
7895 tree b;
7897 /* If this is a derived class, we must first create entries
7898 corresponding to the primary base class. */
7903 /* Add the vbase entries for this base. */
7905 /* Add the vcall entries for this base. */
7907 }
7909 /* Returns the initializers for the vbase offset entries in the vtable
7910 for BINFO (which is part of the class hierarchy dominated by T), in
7911 reverse order. VBASE_OFFSET_INDEX gives the vtable index
7912 where the next vbase offset will go. */
7914 static void
7916 tree binfo;
7918 {
7919 tree vbase;
7920 tree t;
7922 /* Under the old ABI, pointers to virtual bases are stored in each
7923 object. */
7927 /* If there are no virtual baseclasses, then there is nothing to
7928 do. */
7934 /* Go through the virtual bases, adding the offsets. */
7936 vbase;
7938 {
7939 tree b;
7940 tree delta;
7945 /* Find the instance of this virtual base in the complete
7946 object. */
7949 /* If we've already got an offset for this virtual base, we
7950 don't need another one. */
7955 /* Figure out where we can find this vbase offset. */
7964 {
7965 tree orig_vbase;
7967 /* Find the instance of this virtual base in the type of BINFO. */
7971 /* The vbase offset had better be the same. */
7975 }
7977 /* The next vbase will come at a more negative offset. */
7980 /* The initializer is the delta from BINFO to this virtual base.
7981 The vbase offsets go in reverse inheritance-graph order, and
7982 we are walking in inheritance graph order so these end up in
7983 the right order. */
7988 vtable_entry_type,
7989 delta)));
7991 }
7992 }
7994 /* Adds the initializers for the vcall offset entries in the vtable
7995 for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
7996 to VID->INITS. */
7998 static void
8000 tree binfo;
8002 {
8003 /* Under the old ABI, the adjustments to the `this' pointer were made
8004 elsewhere. */
8008 /* We only need these entries if this base is a virtual base. */
8012 /* We need a vcall offset for each of the virtual functions in this
8013 vtable. For example:
8015 class A { virtual void f (); };
8016 class B1 : virtual public A { virtual void f (); };
8017 class B2 : virtual public A { virtual void f (); };
8018 class C: public B1, public B2 { virtual void f (); };
8020 A C object has a primary base of B1, which has a primary base of A. A
8021 C also has a secondary base of B2, which no longer has a primary base
8022 of A. So the B2-in-C construction vtable needs a secondary vtable for
8023 A, which will adjust the A* to a B2* to call f. We have no way of
8024 knowing what (or even whether) this offset will be when we define B2,
8025 so we store this "vcall offset" in the A sub-vtable and look it up in
8026 a "virtual thunk" for B2::f.
8028 We need entries for all the functions in our primary vtable and
8029 in our non-virtual bases' secondary vtables. */
8031 /* Now, walk through the non-virtual bases, adding vcall offsets. */
8033 }
8035 /* Build vcall offsets, starting with those for BINFO. */
8037 static void
8039 tree binfo;
8041 {
8043 tree primary_binfo;
8045 /* Don't walk into virtual bases -- except, of course, for the
8046 virtual base for which we are building vcall offsets. Any
8047 primary virtual base will have already had its offsets generated
8048 through the recursion in build_vcall_and_vbase_vtbl_entries. */
8052 /* If BINFO has a primary base, process it first. */
8057 /* Add BINFO itself to the list. */
8060 /* Scan the non-primary bases of BINFO. */
8062 {
8063 tree base_binfo;
8068 }
8069 }
8071 /* Called from build_vcall_offset_vtbl_entries_r. */
8073 static void
8075 tree binfo;
8077 {
8078 tree derived_virtuals;
8079 tree base_virtuals;
8080 tree orig_virtuals;
8081 tree binfo_inits;
8082 /* If BINFO is a primary base, the most derived class which has BINFO as
8083 a primary base; otherwise, just BINFO. */
8084 tree non_primary_binfo;
8088 /* We might be a primary base class. Go up the inheritance hierarchy
8089 until we find the most derived class of which we are a primary base:
8090 it is the BINFO_VIRTUALS there that we need to consider. */
8093 {
8094 tree b;
8096 /* If we have reached a virtual base, then it must be vid->vbase,
8097 because we ignore other virtual bases in
8098 add_vcall_offset_vtbl_entries_r. In turn, it must be a primary
8099 base (possibly multi-level) of vid->binfo, or we wouldn't
8100 have called build_vcall_and_vbase_vtbl_entries for it. But it
8101 might be a lost primary, so just skip down to vid->binfo. */
8103 {
8108 }
8114 }
8117 /* For a ctor vtable we need the equivalent binfo within the hierarchy
8118 where rtti_binfo is the most derived type. */
8119 non_primary_binfo = get_original_base
8122 /* Make entries for the rest of the virtuals. */
8126 base_virtuals;
8130 {
8131 tree orig_fn;
8132 tree fn;
8133 tree base;
8134 tree base_binfo;
8136 tree vcall_offset;
8138 /* Find the declaration that originally caused this function to
8139 be present in BINFO_TYPE (binfo). */
8142 /* When processing BINFO, we only want to generate vcall slots for
8143 function slots introduced in BINFO. So don't try to generate
8144 one if the function isn't even defined in BINFO. */
8148 /* Find the overriding function. */
8151 /* If there is already an entry for a function with the same
8152 signature as FN, then we do not need a second vcall offset.
8153 Check the list of functions already present in the derived
8154 class vtable. */
8156 {
8157 tree derived_entry;
8161 /* We only use one vcall offset for virtual destructors,
8162 even though there are two virtual table entries. */
8165 {
8170 }
8171 }
8175 /* The FN comes from BASE. So, we must calculate the adjustment from
8176 vid->vbase to BASE. We can just look for BASE in the complete
8177 object because we are converting from a virtual base, so if there
8178 were multiple copies, there would not be a unique final overrider
8179 and vid->derived would be ill-formed. */
8183 /* Compute the vcall offset. */
8184 /* As mentioned above, the vbase we're working on is a primary base of
8185 vid->binfo. But it might be a lost primary, so its BINFO_OFFSET
8186 might be wrong, so we just use the BINFO_OFFSET from vid->binfo. */
8189 vcall_offset);
8191 vcall_offset));
8196 /* Keep track of the vtable index where this vcall offset can be
8197 found. For a construction vtable, we already made this
8198 annotation when we built the original vtable. */
8202 /* The next vcall offset will be found at a more negative
8203 offset. */
8206 /* Keep track of this function. */
8208 }
8209 }
8211 /* Return vtbl initializers for the RTTI entries coresponding to the
8212 BINFO's vtable. The RTTI entries should indicate the object given
8213 by VID->rtti_binfo. */
8215 static void
8217 tree binfo;
8219 {
8220 tree b;
8221 tree t;
8222 tree basetype;
8223 tree offset;
8224 tree decl;
8225 tree init;
8230 /* To find the complete object, we will first convert to our most
8231 primary base, and then add the offset in the vtbl to that value. */
8235 {
8236 tree primary_base;
8241 }
8244 /* The second entry is the address of the typeinfo object. */
8247 else
8250 /* Convert the declaration to a type that can be stored in the
8251 vtable. */
8257 /* Add the offset-to-top entry. It comes earlier in the vtable that
8258 the the typeinfo entry. */
8260 {
8261 /* Convert the offset to look like a function pointer, so that
8262 we can put it in the vtable. */
8267 }
8268 }
8270 /* Build an entry in the virtual function table. DELTA is the offset
8271 for the `this' pointer. VCALL_INDEX is the vtable index containing
8272 the vcall offset; NULL_TREE if none. ENTRY is the virtual function
8273 table entry itself. It's TREE_TYPE must be VFUNC_PTR_TYPE_NODE,
8274 but it may not actually be a virtual function table pointer. (For
8275 example, it might be the address of the RTTI object, under the new
8276 ABI.) */
8278 static tree
8280 tree delta;
8281 tree vcall_index;
8282 tree entry;
8283 {
8285 {
8286 tree fn;
8291 {
8296 }
8297 #ifdef GATHER_STATISTICS
8299 #endif
8301 }
8302 else
8303 {
8309 /* We don't use vcall offsets when not using vtable thunks. */
8312 /* DELTA used to be constructed by `size_int' and/or size_binop,
8313 which caused overflow problems when it was negative. That should
8314 be fixed now. */
8317 {
8320 else
8321 sorry ("object size exceeds normal limit for virtual function table implementation, recompile all source and use -fhuge-objects");
8322 }
8328 #ifdef GATHER_STATISTICS
8330 #endif
8333 }
8334 }