| blob | 21c08aef7683c3bfb15bbd327af2977d783a36cc |
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 {
548 }
550 /* Given an object INSTANCE, return an expression which yields the
551 vtable element corresponding to INDEX. There are many special
552 cases for INSTANCE which we take care of here, mainly to avoid
553 creating extra tree nodes when we don't have to. */
555 tree
558 {
567 else
568 {
570 {
571 /* Try to figure out what a reference refers to, and
572 access its virtual function table directly. */
583 {
590 {
596 }
597 }
598 }
604 {
606 /* Knowing the dynamic type of INSTANCE we can easily obtain
607 the correct vtable entry. In the new ABI, we resolve
608 this back to be in terms of the primary vtable. */
610 {
613 idx,
619 }
620 }
621 else
623 }
633 }
635 /* Given an object INSTANCE, return an expression which yields the
636 virtual function corresponding to INDEX. There are many special
637 cases for INSTANCE which we take care of here, mainly to avoid
638 creating extra tree nodes when we don't have to. */
640 tree
643 tree idx;
644 {
647 /* When using thunks, there is no extra delta, and we get the pfn
648 directly. */
650 {
651 /* When using function descriptors, the address of the
652 vtable entry is treated as a function pointer. */
658 }
661 {
662 /* Save the intermediate result in a SAVE_EXPR so we don't have to
663 compute each component of the virtual function pointer twice. */
667 *ptr_to_instptr
672 }
675 }
677 /* Return the name of the virtual function table (as an IDENTIFIER_NODE)
678 for the given TYPE. */
680 static tree
682 tree type;
683 {
685 }
687 /* Return an IDENTIFIER_NODE for the name of the virtual table table
688 for TYPE. */
690 tree
692 tree type;
693 {
695 }
697 /* Create a VAR_DECL for a primary or secondary vtable for CLASS_TYPE.
698 (For a secondary vtable for B-in-D, CLASS_TYPE should be D, not B.)
699 Use NAME for the name of the vtable, and VTABLE_TYPE for its type. */
701 static tree
703 tree class_type;
704 tree name;
705 tree vtable_type;
706 {
707 tree decl;
710 /* vtable names are already mangled; give them their DECL_ASSEMBLER_NAME
711 now to avoid confusion in mangle_decl. */
721 }
723 /* Get the VAR_DECL of the vtable for TYPE. TYPE need not be polymorphic,
724 or even complete. If this does not exist, create it. If COMPLETE is
725 non-zero, then complete the definition of it -- that will render it
726 impossible to actually build the vtable, but is useful to get at those
727 which are known to exist in the runtime. */
729 tree
731 tree type;
733 {
738 {
742 }
749 /* At one time the vtable info was grabbed 2 words at a time. This
750 fails on sparc unless you have 8-byte alignment. (tiemann) */
755 {
758 }
761 }
763 /* Returns a copy of the BINFO_VIRTUALS list in BINFO. The
764 BV_VCALL_INDEX for each entry is cleared. */
766 static tree
768 tree binfo;
769 {
770 tree copies;
771 tree t;
775 {
778 }
781 }
783 /* Build the primary virtual function table for TYPE. If BINFO is
784 non-NULL, build the vtable starting with the initial approximation
785 that it is the same as the one which is the head of the association
786 list. Returns a non-zero value if a new vtable is actually
787 created. */
789 static int
792 {
793 tree decl;
794 tree virtuals;
799 {
801 /* We have already created a vtable for this base, so there's
802 no need to do it again. */
809 }
810 else
811 {
815 }
817 #ifdef GATHER_STATISTICS
820 #endif
822 /* Initialize the association list for this type, based
823 on our first approximation. */
828 }
830 /* Give TYPE a new virtual function table which is initialized
831 with a skeleton-copy of its original initialization. The only
832 entry that changes is the `delta' entry, so we can really
833 share a lot of structure.
835 FOR_TYPE is the derived type which caused this table to
836 be needed.
838 BINFO is the type association which provided TYPE for FOR_TYPE.
840 The order in which vtables are built (by calling this function) for
841 an object must remain the same, otherwise a binary incompatibility
842 can result. */
844 static int
847 {
848 tree basetype;
850 tree name;
851 tree new_decl;
852 tree offset;
859 #ifdef JOINER
861 #endif
865 current_class_type),
869 /* We already created a vtable for this base. There's no need to
870 do it again. */
873 /* Remember that we've created a vtable for this BINFO, so that we
874 don't try to do so again. */
877 /* Make fresh virtual list, so we can smash it later. */
883 /* In the new ABI, secondary vtables are laid out as part of the
884 same structure as the primary vtable. */
886 {
889 }
891 /* Create the declaration for the secondary vtable. */
896 /* We know that the vtable that we are going to create doesn't exist
897 yet in the global namespace, and when we finish, it will be
898 pushed into the global namespace. In complex MI hierarchies, we
899 have to loop while the name we are thinking of adding is globally
900 defined, adding more name components to the vtable name as we
901 loop, until the name is unique. This is because in complex MI
902 cases, we might have the same base more than once. This means
903 that the order in which this function is called for vtables must
904 remain the same, otherwise binary compatibility can be
905 compromised. */
908 {
914 buf2);
919 /* If this name doesn't clash, then we can use it, otherwise
920 we add more to the name until it is unique. */
925 /* Set values for next loop through, if the name isn't unique. */
929 /* We better not run out of stuff to make it unique. */
935 {
936 /* If we run out of basetypes in the path, we have already
937 found created a vtable with that name before, we now
938 resort to tacking on _%d to distinguish them. */
951 /* If this name doesn't clash, then we can use it,
952 otherwise we add something different to the name until
953 it is unique. */
956 /* Hey, they really like MI don't they? Increase the 3
957 above to 6, and the 999 to 999999. :-) */
961 }
968 }
975 #ifdef GATHER_STATISTICS
978 #endif
981 }
983 /* Create a new vtable for BINFO which is the hierarchy dominated by
984 T. */
986 static int
988 tree t;
989 tree binfo;
990 {
992 /* In this case, it is *type*'s vtable we are modifying. We start
993 with the approximation that its vtable is that of the
994 immediate base class. */
995 /* ??? This actually passes TYPE_BINFO (t), not the primary base binfo,
996 since we've updated DECL_CONTEXT (TYPE_VFIELD (t)) by now. */
998 t);
999 else
1000 /* This is our very own copy of `basetype' to play with. Later,
1001 we will fill in all the virtual functions that override the
1002 virtual functions in these base classes which are not defined
1003 by the current type. */
1005 }
1007 /* Make *VIRTUALS, an entry on the BINFO_VIRTUALS list for BINFO
1008 (which is in the hierarchy dominated by T) list FNDECL as its
1009 BV_FN. DELTA is the required constant adjustment from the `this'
1010 pointer where the vtable entry appears to the `this' required when
1011 the function is actually called. */
1013 static void
1015 tree t;
1016 tree binfo;
1017 tree fndecl;
1018 tree delta;
1020 {
1021 tree v;
1027 {
1028 tree base_fndecl;
1030 /* We need a new vtable for BINFO. */
1032 {
1033 /* If we really did make a new vtable, we also made a copy
1034 of the BINFO_VIRTUALS list. Now, we have to find the
1035 corresponding entry in that list. */
1040 }
1047 /* Now assign virtual dispatch information, if unset. We can
1048 dispatch this through any overridden base function.
1050 FIXME this can choose a secondary vtable if the primary is not
1051 also lexically first, leading to useless conversions.
1052 In the V3 ABI, there's no reason for DECL_VIRTUAL_CONTEXT to
1053 ever be different from DECL_CONTEXT. */
1055 {
1058 }
1059 }
1060 }
1062 /* Set DECL_VINDEX for DECL. VINDEX_P is the number of virtual
1063 functions present in the vtable so far. */
1065 static void
1067 tree decl;
1069 {
1076 }
1078 /* Add a virtual function to all the appropriate vtables for the class
1079 T. DECL_VINDEX(X) should be error_mark_node, if we want to
1080 allocate a new slot in our table. If it is error_mark_node, we
1081 know that no other function from another vtable is overridden by X.
1082 VFUNS_P keeps track of how many virtuals there are in our
1083 main vtable for the type, and we build upon the NEW_VIRTUALS list
1084 and return it. */
1086 static void
1092 tree fndecl;
1094 {
1095 tree new_virtual;
1097 /* If this function doesn't override anything from a base class, we
1098 can just assign it a new DECL_VINDEX now. Otherwise, if it does
1099 override something, we keep it around and assign its DECL_VINDEX
1100 later, in modify_all_vtables. */
1102 /* We've already dealt with this function. */
1110 {
1111 /* FNDECL is a new virtual function; it doesn't override any
1112 virtual function in a base class. */
1114 /* We remember that this was the base sub-object for rtti. */
1117 /* Now assign virtual dispatch information. */
1121 /* Save the state we've computed on the NEW_VIRTUALS list. */
1124 }
1125 else
1126 {
1127 /* FNDECL overrides a function from a base class. */
1130 }
1131 }
1132 \f
1133 /* Add method METHOD to class TYPE. If ERROR_P is true, we are adding
1134 the method after the class has already been defined because a
1135 declaration for it was seen. (Even though that is erroneous, we
1136 add the method for improved error recovery.) */
1138 void
1140 tree type;
1141 tree method;
1143 {
1147 tree method_vec;
1150 /* Make a new method vector. We start with 8 entries. We must
1151 allocate at least two (for constructors and destructors), and
1152 we're going to end up with an assignment operator at some point
1153 as well.
1155 We could use a TREE_LIST for now, and convert it to a TREE_VEC
1156 in finish_struct, but we would probably waste more memory
1157 making the links in the list than we would by over-allocating
1158 the size of the vector here. Furthermore, we would complicate
1159 all the code that expects this to be a vector. */
1165 /* Constructors and destructors go in special slots. */
1170 else
1171 {
1172 /* See if we already have an entry with this name. */
1176 slot)))
1181 {
1182 /* We need a bigger method vector. */
1184 tree new_vec;
1186 /* In the non-error case, we are processing a class
1187 definition. Double the size of the vector to give room
1188 for new methods. */
1191 /* In the error case, the vector is already complete. We
1192 don't expect many errors, and the rest of the front-end
1193 will get confused if there are empty slots in the vector. */
1194 else
1203 }
1206 {
1207 /* Type conversion operators have to come before ordinary
1208 methods; add_conversions depends on this to speed up
1209 looking for conversion operators. So, if necessary, we
1210 slide some of the vector elements up. In theory, this
1211 makes this algorithm O(N^2) but we don't expect many
1212 conversion operators. */
1214 {
1218 /* There are no more entries in the vector, so we
1219 can insert the new conversion operator here. */
1223 /* We can insert the new function right at the
1224 SLOTth position. */
1226 }
1229 /* There is nothing in the Ith slot, so we can avoid
1230 moving anything. */
1231 ;
1232 else
1233 {
1234 /* We know the last slot in the vector is empty
1235 because we know that at this point there's room
1236 for a new function. */
1241 }
1242 }
1243 }
1246 /* TYPE is a template class. Don't issue any errors now; wait
1247 until instantiation time to complain. */
1248 ;
1249 else
1250 {
1251 tree fns;
1253 /* Check to see if we've already got this method. */
1255 fns;
1257 {
1264 {
1265 /* [over.load] Member function declarations with the
1266 same name and the same parameter types cannot be
1267 overloaded if any of them is a static member
1268 function declaration. */
1272 {
1282 {
1284 /* Defer to the local function. */
1286 else
1289 }
1290 }
1291 }
1296 /* There has already been a declaration of this method
1297 or member template. */
1301 /* We don't call duplicate_decls here to merge the
1302 declarations because that will confuse things if the
1303 methods have inline definitions. In particular, we
1304 will crash while processing the definitions. */
1306 }
1307 }
1309 /* Actually insert the new method. */
1313 /* Add the new binding. */
1318 }
1320 /* Subroutines of finish_struct. */
1322 /* Look through the list of fields for this struct, deleting
1323 duplicates as we go. This must be recursive to handle
1324 anonymous unions.
1326 FIELD is the field which may not appear anywhere in FIELDS.
1327 FIELD_PTR, if non-null, is the starting point at which
1328 chained deletions may take place.
1329 The value returned is the first acceptable entry found
1330 in FIELDS.
1332 Note that anonymous fields which are not of UNION_TYPE are
1333 not duplicates, they are just anonymous fields. This happens
1334 when we have unnamed bitfields, for example. */
1336 static tree
1339 {
1340 tree x;
1343 {
1350 }
1351 else
1352 {
1354 {
1356 {
1362 {
1365 else
1367 }
1368 }
1370 /* A using declaration may is allowed to appear more than
1371 once. We'll prune these from the field list later, and
1372 handle_using_decl will complain about invalid multiple
1373 uses. */
1374 ;
1376 {
1383 x);
1386 {
1390 }
1393 {
1394 /* Hide tag decls. */
1401 x);
1402 }
1403 else
1407 else
1409 }
1410 }
1411 }
1413 }
1415 static void
1417 tree fields;
1418 {
1419 tree x;
1422 }
1424 /* Change the access of FDECL to ACCESS in T. Return 1 if change was
1425 legit, otherwise return 0. */
1427 static int
1429 tree t;
1430 tree fdecl;
1431 tree access;
1432 {
1433 tree elem;
1443 {
1445 {
1448 else
1451 }
1452 else
1453 {
1454 /* They're changing the access to the same thing they changed
1455 it to before. That's OK. */
1456 ;
1457 }
1458 }
1459 else
1460 {
1464 }
1466 }
1468 /* Process the USING_DECL, which is a member of T. */
1470 static void
1472 tree using_decl;
1473 tree t;
1474 {
1477 tree access
1483 tree old_value;
1491 {
1494 }
1497 {
1500 }
1505 {
1508 }
1511 /* Ignore base type this came from. */
1516 {
1522 else
1524 }
1530 ;
1532 {
1534 /* It's OK to use functions from a base when there are functions with
1536 else
1537 {
1542 }
1543 }
1545 {
1549 }
1551 /* Make type T see field decl FDECL with access ACCESS.*/
1554 {
1557 }
1558 else
1560 }
1561 \f
1562 /* Run through the base clases of T, updating
1563 CANT_HAVE_DEFAULT_CTOR_P, CANT_HAVE_CONST_CTOR_P, and
1564 NO_CONST_ASN_REF_P. Also set flag bits in T based on properties of
1565 the bases. */
1567 static void
1569 no_const_asn_ref_p)
1570 tree t;
1574 {
1578 tree binfos;
1584 /* An aggregate cannot have baseclasses. */
1588 {
1589 tree base_binfo;
1590 tree basetype;
1592 /* Figure out what base we're looking at. */
1596 /* If the type of basetype is incomplete, then we already
1597 complained about that fact (and we should have fixed it up as
1598 well). */
1600 {
1602 /* The base type is of incomplete type. It is
1603 probably best to pretend that it does not
1604 exist. */
1612 }
1614 /* Effective C++ rule 14. We only need to check TYPE_POLYMORPHIC_P
1615 here because the case of virtual functions but non-virtual
1616 dtor is handled in finish_struct_1. */
1620 basetype);
1622 /* If the base class doesn't have copy constructors or
1623 assignment operators that take const references, then the
1624 derived class cannot have such a member automatically
1625 generated. */
1631 /* Similarly, if the base class doesn't have a default
1632 constructor, then the derived class won't have an
1633 automatically generated default constructor. */
1636 {
1640 basetype);
1641 }
1644 /* A virtual base does not effect nearly emptiness. */
1645 ;
1647 {
1649 /* And if there is more than one nearly empty base, then the
1650 derived class is not nearly empty either. */
1652 else
1653 /* Remember we've seen one. */
1655 }
1657 /* If the base class is not empty or nearly empty, then this
1658 class cannot be nearly empty. */
1661 /* A lot of properties from the bases also apply to the derived
1662 class. */
1674 /* Derived classes can implicitly become COMified if their bases
1675 are COM. */
1679 {
1680 cp_error
1684 }
1685 }
1686 }
1688 /* Binfo FROM is within a virtual heirarchy which is being reseated to
1689 TO. Move primary information from FROM to TO, and recursively traverse
1690 into FROM's bases. The heirarchy is dominated by TYPE. MAPPINGS is an
1691 assoc list of binfos that have already been reseated. */
1693 static void
1695 tree to;
1696 tree from;
1697 tree type;
1698 tree mappings;
1699 {
1711 {
1713 tree assoc;
1715 /* We might have just moved the primary base too, see if it's on our
1716 mappings. */
1722 }
1729 {
1735 }
1738 {
1743 {
1746 /* This base is a primary of some binfo we have already
1747 reseated. We must reseat this one too. */
1749 }
1750 else
1752 }
1753 }
1755 /* FROM is the canonical binfo for a virtual base. It is being reseated to
1756 make TO the canonical binfo, within the heirarchy dominated by TYPE.
1757 MAPPINGS is an assoc list of binfos that have already been reseated.
1758 Adjust any non-virtual bases within FROM, and also move any virtual bases
1759 which are canonical. This complication arises because selecting primary
1760 bases walks in inheritance graph order, but we don't share binfos for
1761 virtual bases, hence we can fill in the primaries for a virtual base,
1762 and then discover that a later base requires the virtual as its
1763 primary. */
1765 static void
1767 tree to;
1768 tree from;
1769 tree type;
1770 tree mappings;
1771 {
1775 {
1778 }
1779 }
1781 /* Make BASE_BINFO the a primary virtual base within the hierarchy
1782 dominated by TYPE. Returns BASE_BINFO, if it is not already one, NULL
1783 otherwise (because something else has already made it primary). */
1785 static tree
1787 tree base_binfo;
1788 tree type;
1789 {
1793 {
1794 /* It's already allocated in the hierarchy. BINFO won't have a
1795 primary base in this hierachy, even though the complete object
1796 BINFO is for, would do. */
1798 }
1800 /* We need to make sure that the assoc list
1801 CLASSTYPE_VBASECLASSES of TYPE, indicates this particular
1802 primary BINFO for the virtual base, as this is the one
1803 that'll really exist. */
1808 }
1810 /* If BINFO is an unmarked virtual binfo for a class with a primary virtual
1811 base, then BINFO has no primary base in this graph. Called from
1812 mark_primary_bases. DATA is the most derived type. */
1815 tree binfo;
1817 {
1822 {
1823 /* This morally virtual base has a primary base when it
1824 is a complete object. We need to locate the shared instance
1825 of this binfo in the type dominated by T. We duplicate the
1826 primary base information from there to here. */
1827 tree vbase;
1828 tree unshared_base;
1835 t));
1840 }
1843 /* The vtable fields will have been copied when duplicating the
1844 base binfos. That information is bogus, make sure we don't try
1845 and use it. */
1848 /* If this is a virtual primary base, make sure its offset matches
1849 that which it is primary for. */
1852 {
1857 }
1861 }
1863 /* Set BINFO_PRIMARY_BASE_OF for all binfos in the hierarchy
1864 dominated by TYPE that are primary bases. */
1866 static void
1868 tree type;
1869 {
1870 tree binfo;
1872 /* Walk the bases in inheritance graph order. */
1874 {
1875 tree base_binfo;
1878 /* Not a dynamic base. */
1888 else
1892 }
1893 /* There could remain unshared morally virtual bases which were not
1894 visited in the inheritance graph walk. These bases will have lost
1895 their virtual primary base (should they have one). We must now
1896 find them. Also we must fix up the BINFO_OFFSETs of primary
1897 virtual bases. We could not do that as we went along, as they
1898 were originally copied from the bases we inherited from by
1899 unshare_base_binfos. That may have decided differently about
1900 where a virtual primary base went. */
1902 }
1904 /* Make the BINFO the primary base of T. */
1906 static void
1908 tree t;
1909 tree binfo;
1911 {
1912 tree basetype;
1921 }
1923 /* Determine the primary class for T. */
1925 static void
1927 tree t;
1929 {
1931 tree vbases;
1932 tree type_binfo;
1934 /* If there are no baseclasses, there is certainly no primary base. */
1941 {
1946 {
1947 /* Even a virtual baseclass can contain our RTTI
1948 information. But, we prefer a non-virtual polymorphic
1949 baseclass. */
1953 /* A virtual baseclass can't be the primary base under the
1954 old ABI. And under the new ABI we still prefer a
1955 non-virtual base. */
1960 {
1963 }
1964 else
1965 {
1966 tree vfields;
1968 /* Only add unique vfields, and flatten them out as we go. */
1970 vfields;
1978 }
1979 }
1980 }
1985 /* Find the indirect primary bases - those virtual bases which are primary
1986 bases of something else in this hierarchy. */
1988 vbases;
1990 {
1993 /* See if this virtual base is an indirect primary base. To be so,
1994 it must be a primary base within the hierarchy of one of our
1995 direct bases. */
1997 {
1999 tree v;
2002 v;
2004 {
2010 {
2013 }
2014 }
2016 /* If we've discovered that this virtual base is an indirect
2017 primary base, then we can move on to the next virtual
2018 base. */
2021 }
2022 }
2024 /* The new ABI allows for the use of a "nearly-empty" virtual base
2025 class as the primary base class if no non-virtual polymorphic
2026 base can be found. */
2028 {
2029 /* If not NULL, this is the best primary base candidate we have
2030 found so far. */
2032 tree base_binfo;
2034 /* Loop over the baseclasses. */
2036 base_binfo;
2038 {
2043 {
2044 /* If this is not an indirect primary base, then it's
2045 definitely our primary base. */
2047 {
2050 }
2052 /* If this is an indirect primary base, it still could be
2053 our primary base -- unless we later find there's another
2054 nearly-empty virtual base that isn't an indirect
2055 primary base. */
2058 }
2059 }
2061 /* If we've got a primary base, use it. */
2063 {
2067 }
2068 }
2070 /* Mark the primary base classes at this point. */
2072 }
2073 \f
2074 /* Set memoizing fields and bits of T (and its variants) for later
2075 use. */
2077 static void
2079 tree t;
2080 {
2083 /* Fix up variants (if any). */
2086 {
2087 /* These fields are in the _TYPE part of the node, not in
2088 the TYPE_LANG_SPECIFIC component, so they are not shared. */
2099 /* Copy whatever these are holding today. */
2106 }
2109 /* For a class w/o baseclasses, `finish_struct' has set
2110 CLASS_TYPE_ABSTRACT_VIRTUALS correctly (by
2111 definition). Similarly for a class whose base classes do not
2112 have vtables. When neither of these is true, we might have
2113 removed abstract virtuals (by providing a definition), added
2114 some (by declaring new ones), or redeclared ones from a base
2115 class. We need to recalculate what's really an abstract virtual
2116 at this point (by looking in the vtables). */
2120 {
2121 /* Notice whether this class has type conversion functions defined. */
2124 tree basetype;
2127 {
2131 }
2132 }
2134 /* If this type has a copy constructor, force its mode to be BLKmode, and
2135 force its TREE_ADDRESSABLE bit to be nonzero. This will cause it to
2136 be passed by invisible reference and prevent it from being returned in
2137 a register.
2139 Also do this if the class has BLKmode but can still be returned in
2140 registers, since function_cannot_inline_p won't let us inline
2141 functions returning such a type. This affects the HP-PA. */
2145 {
2146 tree variants;
2149 {
2152 }
2153 }
2154 }
2156 /* Issue warnings about T having private constructors, but no friends,
2157 and so forth.
2159 HAS_NONPRIVATE_METHOD is nonzero if T has any non-private methods or
2160 static members. HAS_NONPRIVATE_STATIC_FN is nonzero if T has any
2161 non-private static member functions. */
2163 static void
2165 tree t;
2166 {
2169 tree fn;
2172 /* If the class has friends, those entities might create and
2173 access instances, so we should not warn. */
2176 /* We will have warned when the template was declared; there's
2177 no need to warn on every instantiation. */
2179 /* There's no reason to even consider warning about this
2180 class. */
2183 /* We only issue one warning, if more than one applies, because
2184 otherwise, on code like:
2186 class A {
2187 // Oops - forgot `public:'
2188 A();
2189 A(const A&);
2190 ~A();
2191 };
2193 we warn several times about essentially the same problem. */
2195 /* Check to see if all (non-constructor, non-destructor) member
2196 functions are private. (Since there are no friends or
2197 non-private statics, we can't ever call any of the private member
2198 functions.) */
2200 /* We're not interested in compiler-generated methods; they don't
2201 provide any way to call private members. */
2203 {
2205 {
2207 /* A non-private static member function is just like a
2208 friend; it can create and invoke private member
2209 functions, and be accessed without a class
2210 instance. */
2215 }
2218 }
2221 {
2222 /* There are no non-private methods, and there's at least one
2223 private member function that isn't a constructor or
2224 destructor. (If all the private members are
2225 constructors/destructors we want to use the code below that
2226 issues error messages specifically referring to
2227 constructors/destructors.) */
2233 {
2236 }
2238 {
2241 }
2242 }
2244 /* Even if some of the member functions are non-private, the class
2245 won't be useful for much if all the constructors or destructors
2246 are private: such an object can never be created or destroyed. */
2248 {
2252 {
2254 t);
2256 }
2257 }
2260 {
2263 /* If a non-template class does not define a copy
2264 constructor, one is defined for it, enabling it to avoid
2265 this warning. For a template class, this does not
2266 happen, and so we would normally get a warning on:
2268 template <class T> class C { private: C(); };
2270 To avoid this asymmetry, we check TYPE_HAS_INIT_REF. All
2271 complete non-template or fully instantiated classes have this
2272 flag set. */
2275 else
2277 fn;
2279 {
2281 /* Ideally, we wouldn't count copy constructors (or, in
2282 fact, any constructor that takes an argument of the
2283 class type as a parameter) because such things cannot
2284 be used to construct an instance of the class unless
2285 you already have one. But, for now at least, we're
2286 more generous. */
2288 {
2291 }
2292 }
2295 {
2297 t);
2299 }
2300 }
2301 }
2303 /* Function to help qsort sort FIELD_DECLs by name order. */
2305 static int
2308 {
2310 /* A nontype is "greater" than a type. */
2319 }
2321 /* Comparison function to compare two TYPE_METHOD_VEC entries by name. */
2323 static int
2326 {
2336 }
2338 /* Warn about duplicate methods in fn_fields. Also compact method
2339 lists so that lookup can be made faster.
2341 Data Structure: List of method lists. The outer list is a
2342 TREE_LIST, whose TREE_PURPOSE field is the field name and the
2343 TREE_VALUE is the DECL_CHAIN of the FUNCTION_DECLs. TREE_CHAIN
2344 links the entire list of methods for TYPE_METHODS. Friends are
2345 chained in the same way as member functions (? TREE_CHAIN or
2346 DECL_CHAIN), but they live in the TREE_TYPE field of the outer
2347 list. That allows them to be quickly deleted, and requires no
2348 extra storage.
2350 Sort methods that are not special (i.e., constructors, destructors,
2351 and type conversion operators) so that we can find them faster in
2352 search. */
2354 static void
2356 tree t;
2357 {
2358 tree fn_fields;
2359 tree method_vec;
2363 {
2364 /* Clear these for safety; perhaps some parsing error could set
2365 these incorrectly. */
2370 }
2376 /* First fill in entry 0 with the constructors, entry 1 with destructors,
2377 and the next few with type conversion operators (if any). */
2380 /* Clear out this flag. */
2384 /* We thought there was a destructor, but there wasn't. Some
2385 parse errors cause this anomalous situation. */
2388 /* Issue warnings about private constructors and such. If there are
2389 no methods, then some public defaults are generated. */
2392 /* Now sort the methods. */
2394 len--;
2397 /* The type conversion ops have to live at the front of the vec, so we
2398 can't sort them. */
2400 {
2405 }
2409 }
2411 /* Emit error when a duplicate definition of a type is seen. Patch up. */
2413 void
2415 tree t;
2416 {
2420 /* Pretend we haven't defined this type. */
2422 /* All of the component_decl's were TREE_CHAINed together in the parser.
2423 finish_struct_methods walks these chains and assembles all methods with
2424 the same base name into DECL_CHAINs. Now we don't need the parser chains
2425 anymore, so we unravel them. */
2427 /* This used to be in finish_struct, but it turns out that the
2428 TREE_CHAIN is used by dbxout_type_methods and perhaps some other
2429 things... */
2431 {
2435 {
2438 {
2441 }
2442 }
2443 }
2446 {
2462 }
2471 /* Clear TYPE_LANG_FLAGS -- those in TYPE_LANG_SPECIFIC are cleared above. */
2479 /* But not this one. */
2481 }
2483 /* Make the BINFO's vtablehave N entries, including RTTI entries,
2484 vbase and vcall offsets, etc. Set its type and call the backend
2485 to lay it out. */
2487 static void
2489 tree binfo;
2491 {
2492 tree atype;
2493 tree vtable;
2499 /* We may have to grow the vtable. */
2502 {
2507 /* At one time the vtable info was grabbed 2 words at a time. This
2508 fails on Sparc unless you have 8-byte alignment. */
2511 }
2512 }
2514 /* True iff FNDECL and BASE_FNDECL (both non-static member functions)
2515 have the same signature. */
2517 int
2520 {
2521 /* One destructor overrides another if they are the same kind of
2522 destructor. */
2526 /* But a non-destructor never overrides a destructor, nor vice
2527 versa, nor do different kinds of destructors override
2528 one-another. For example, a complete object destructor does not
2529 override a deleting destructor. */
2534 {
2542 }
2544 }
2547 /* The function for which we are trying to find a final overrider. */
2548 tree fn;
2549 /* The base class in which the function was declared. */
2550 tree declaring_base;
2551 /* The most derived class in the hierarchy. */
2552 tree most_derived_type;
2553 /* The final overriding function. */
2554 tree overriding_fn;
2555 /* The functions that we thought might be final overriders, but
2556 aren't. */
2557 tree candidates;
2558 /* The BINFO for the class in which the final overriding function
2559 appears. */
2560 tree overriding_base;
2563 /* Called from find_final_overrider via dfs_walk. */
2565 static tree
2567 tree binfo;
2569 {
2576 {
2577 tree path;
2578 tree method;
2580 /* We haven't found an overrider yet. */
2582 /* We've found a path to the declaring base. Walk down the path
2583 looking for an overrider for FN. */
2585 path;
2587 {
2592 }
2594 /* If we found an overrider, record the overriding function, and
2595 the base from which it came. */
2597 {
2598 tree base;
2600 /* Assume the path is non-virtual. See if there are any
2601 virtual bases from (but not including) the overrider up
2602 to and including the base where the function is
2603 defined. */
2606 {
2609 }
2611 /* If we didn't already have an overrider, or any
2612 candidates, then this function is the best candidate so
2613 far. */
2615 {
2618 }
2620 {
2621 /* We had a best overrider; let's see how this compares. */
2624 && (tree_int_cst_equal
2627 /* We found the same overrider we already have, and in the
2630 /* The old function overrides this function; it's still the
2633 {
2634 /* The new function overrides the old; it's now the
2635 best. */
2638 }
2639 else
2640 {
2641 /* Ambiguous. */
2642 ffod->candidates
2646 ffod->candidates
2650 }
2651 }
2652 else
2653 {
2654 /* We had a list of ambiguous overrides; let's see how this
2655 new one compares. */
2657 tree candidates;
2660 /* If there were previous candidates, and this function
2661 overrides all of them, then it is the new best
2662 candidate. */
2664 candidates;
2666 {
2667 /* If the candidate overrides the METHOD, then we
2668 needn't worry about it any further. */
2670 method))
2671 {
2674 }
2676 /* If the METHOD doesn't override the candidate,
2677 then it is incomporable. */
2681 }
2683 /* If METHOD overrode all the candidates, then it is the
2684 new best candidate. */
2686 {
2690 }
2691 /* If METHOD didn't override all the candidates, then it
2692 is another candidate. */
2694 ffod->candidates
2696 }
2697 }
2698 }
2701 }
2703 /* Returns a TREE_LIST whose TREE_PURPOSE is the final overrider for
2704 FN and whose TREE_VALUE is the binfo for the base where the
2705 overriding occurs. BINFO (in the hierarchy dominated by T) is the
2706 base object in which FN is declared. */
2708 static tree
2710 tree t;
2711 tree binfo;
2712 tree fn;
2713 {
2714 find_final_overrider_data ffod;
2716 /* Getting this right is a little tricky. This is legal:
2718 struct S { virtual void f (); };
2719 struct T { virtual void f (); };
2720 struct U : public S, public T { };
2722 even though calling `f' in `U' is ambiguous. But,
2724 struct R { virtual void f(); };
2725 struct S : virtual public R { virtual void f (); };
2726 struct T : virtual public R { virtual void f (); };
2727 struct U : public S, public T { };
2729 is not -- there's no way to decide whether to put `S::f' or
2730 `T::f' in the vtable for `R'.
2732 The solution is to look at all paths to BINFO. If we find
2733 different overriders along any two, then there is a problem. */
2742 dfs_find_final_overrider,
2743 NULL,
2746 /* If there was no winner, issue an error message. */
2748 {
2751 }
2754 }
2756 /* Returns the function from the BINFO_VIRTUALS entry in T which matches
2757 the signature of FUNCTION_DECL FN, or NULL_TREE if none. In other words,
2758 the function that the slot in T's primary vtable points to. */
2761 static tree
2764 {
2765 tree f;
2771 }
2773 /* Update an entry in the vtable for BINFO, which is in the hierarchy
2774 dominated by T. FN has been overriden in BINFO; VIRTUALS points to the
2775 corresponding position in the BINFO_VIRTUALS list. */
2777 static void
2779 tree t;
2780 tree binfo;
2781 tree fn;
2783 {
2784 tree b;
2785 tree overrider;
2786 tree delta;
2787 tree virtual_base;
2788 tree first_defn;
2790 /* Find the nearest primary base (possibly binfo itself) which defines
2791 this function; this is the class the caller will convert to when
2792 calling FN through BINFO. */
2794 {
2797 }
2800 /* Find the final overrider. */
2805 /* Assume that we will produce a thunk that convert all the way to
2806 the final overrider, and not to an intermediate virtual base. */
2809 /* Under the new ABI, we will convert to an intermediate virtual
2810 base first, and then use the vcall offset located there to finish
2811 the conversion. */
2813 {
2814 /* If we find the final overrider, then we can stop
2815 walking. */
2820 /* If we find a virtual base, and we haven't yet found the
2821 overrider, then there is a virtual base between the
2822 declaring base (first_defn) and the final overrider. */
2827 }
2829 /* Compute the constant adjustment to the `this' pointer. The
2830 `this' pointer, when this function is called, will point at BINFO
2831 (or one of its primary bases, which are at the same offset). */
2834 /* The `this' pointer needs to be adjusted from the declaration to
2835 the nearest virtual base. */
2838 else
2839 {
2840 /* The `this' pointer needs to be adjusted from pointing to
2841 BINFO to pointing at the base where the final overrider
2842 appears. */
2847 {
2848 /* We'll need a thunk. But if we have a (perhaps formerly)
2849 primary virtual base, we have a vcall slot for this function,
2850 so we can use it rather than create a non-virtual thunk. */
2854 {
2857 /* b doesn't have this function; no suitable vbase. */
2860 {
2861 /* Found one; we can treat ourselves as a virtual base. */
2865 }
2866 }
2867 }
2868 }
2871 binfo,
2873 delta,
2874 virtuals);
2878 }
2880 /* Called from modify_all_vtables via dfs_walk. */
2882 static tree
2884 tree binfo;
2886 {
2888 primary base; we're not going to use that vtable anyhow.
2889 We do still need to do this for virtual primary bases, as they
2890 could become non-primary in a construction vtable. */
2892 /* Similarly, a base without a vtable needs no modification. */
2894 {
2895 tree t;
2896 tree virtuals;
2897 tree old_virtuals;
2901 /* If we're supporting RTTI then we always need a new vtable to
2902 point to the RTTI information. Under the new ABI we may need
2903 a new vtable to contain vcall and vbase offsets. */
2906 /* Now, go through each of the virtual functions in the virtual
2907 function table for BINFO. Find the final overrider, and
2908 update the BINFO_VIRTUALS list appropriately. */
2911 virtuals;
2915 binfo,
2918 }
2923 }
2925 /* Update all of the primary and secondary vtables for T. Create new
2926 vtables as required, and initialize their RTTI information. Each
2927 of the functions in OVERRIDDEN_VIRTUALS overrides a virtual
2928 function from a base class; find and modify the appropriate entries
2929 to point to the overriding functions. Returns a list, in
2930 declaration order, of the functions that are overridden in this
2931 class, but do not appear in the primary base class vtable, and
2932 which should therefore be appended to the end of the vtable for T. */
2934 static tree
2936 tree t;
2938 tree overridden_virtuals;
2939 {
2940 tree binfo;
2944 /* Update all of the vtables. */
2946 dfs_modify_vtables,
2947 dfs_unmarked_real_bases_queue_p,
2948 t);
2951 /* If we should include overriding functions for secondary vtables
2952 in our primary vtable, add them now. */
2954 {
2958 {
2963 {
2964 /* Set the vtable index. */
2966 /* We don't need to convert to a base class when calling
2967 this function. */
2970 /* We don't need to adjust the `this' pointer when
2971 calling this function. */
2975 /* This is an overridden function not already in our
2976 vtable. Keep it. */
2978 }
2979 else
2980 /* We've already got an entry for this function. Skip
2981 it. */
2983 }
2984 }
2985 else
2989 }
2991 /* Here, we already know that they match in every respect.
2992 All we have to check is where they had their declarations. */
2994 static int
2997 {
3004 }
3006 /* Get the base virtual function declarations in T that are either
3007 overridden or hidden by FNDECL as a list. We set TREE_PURPOSE with
3008 the overrider/hider. */
3010 static tree
3013 {
3020 {
3027 }
3033 {
3038 base_fndecls);
3039 }
3042 }
3044 /* Mark the functions that have been hidden with their overriders.
3045 Since we start out with all functions already marked with a hider,
3046 no need to mark functions that are just hidden.
3048 Subroutine of warn_hidden. */
3050 static void
3053 {
3057 }
3059 /* If this declaration supersedes the declaration of
3060 a method declared virtual in the base class, then
3061 mark this field as being virtual as well. */
3063 static void
3066 {
3068 /* In [temp.mem] we have:
3070 A specialization of a member function template does not
3071 override a virtual function from a base class. */
3077 {
3078 /* Set DECL_VINDEX to a value that is neither an
3079 INTEGER_CST nor the error_mark_node so that
3080 add_virtual_function will realize this is an
3081 overriding function. */
3083 }
3085 {
3089 }
3090 }
3092 /* Warn about hidden virtual functions that are not overridden in t.
3093 We know that constructors and destructors don't apply. */
3095 void
3097 tree t;
3098 {
3103 /* We go through each separately named virtual function. */
3105 {
3113 /* First see if we have any virtual functions in this batch. */
3115 {
3119 }
3124 /* First we get a list of all possible functions that might be
3125 hidden from each base class. */
3127 {
3132 base_fndecls);
3133 }
3137 /* ...then mark up all the base functions with overriders, preferring
3138 overriders to hiders. */
3141 {
3145 }
3147 /* Now give a warning for all base functions without overriders,
3148 as they are hidden. */
3152 {
3153 /* Here we know it is a hider, and no overrider exists. */
3156 }
3157 }
3158 }
3160 /* Check for things that are invalid. There are probably plenty of other
3161 things we should check for also. */
3163 static void
3165 tree t;
3166 {
3167 tree field;
3170 {
3178 {
3181 {
3187 elt);
3190 {
3192 elt);
3194 }
3198 elt);
3201 elt);
3205 }
3206 }
3207 }
3208 }
3210 /* Create default constructors, assignment operators, and so forth for
3211 the type indicated by T, if they are needed.
3212 CANT_HAVE_DEFAULT_CTOR, CANT_HAVE_CONST_CTOR, and
3213 CANT_HAVE_CONST_ASSIGNMENT are nonzero if, for whatever reason, the
3214 class cannot have a default constructor, copy constructor taking a
3215 const reference argument, or an assignment operator taking a const
3216 reference, respectively. If a virtual destructor is created, its
3217 DECL is returned; otherwise the return value is NULL_TREE. */
3219 static tree
3221 cant_have_const_cctor,
3222 cant_have_const_assignment)
3223 tree t;
3227 {
3228 tree default_fn;
3233 /* Destructor. */
3235 {
3239 /* If we couldn't make it work, then pretend we didn't need it. */
3242 else
3243 {
3249 }
3250 }
3251 else
3252 /* Any non-implicit destructor is non-trivial. */
3255 /* Default constructor. */
3257 {
3261 }
3263 /* Copy constructor. */
3265 {
3266 /* ARM 12.18: You get either X(X&) or X(const X&), but
3267 not both. --Chip */
3268 default_fn
3273 }
3275 /* Assignment operator. */
3277 {
3278 default_fn
3283 }
3285 /* Now, hook all of the new functions on to TYPE_METHODS,
3286 and add them to the CLASSTYPE_METHOD_VEC. */
3293 }
3295 /* Subroutine of finish_struct_1. Recursively count the number of fields
3296 in TYPE, including anonymous union members. */
3298 static int
3300 tree fields;
3301 {
3302 tree x;
3305 {
3308 else
3310 }
3312 }
3314 /* Subroutine of finish_struct_1. Recursively add all the fields in the
3315 TREE_LIST FIELDS to the TREE_VEC FIELD_VEC, starting at offset IDX. */
3317 static int
3321 {
3322 tree x;
3324 {
3327 else
3329 }
3331 }
3333 /* FIELD is a bit-field. We are finishing the processing for its
3334 enclosing type. Issue any appropriate messages and set appropriate
3335 flags. */
3337 static void
3339 tree field;
3340 {
3344 /* Detect invalid bit-field type. */
3347 {
3350 }
3352 /* Detect and ignore out of range field width. */
3354 {
3357 /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs. */
3360 /* detect invalid field size. */
3363 else
3367 {
3369 field);
3371 }
3373 {
3376 }
3378 {
3381 }
3391 min_precision
3396 }
3398 /* Remove the bit-field width indicator so that the rest of the
3399 compiler does not treat that value as an initializer. */
3403 {
3408 {
3409 #ifdef EMPTY_FIELD_BOUNDARY
3411 EMPTY_FIELD_BOUNDARY);
3412 #endif
3413 #ifdef PCC_BITFIELD_TYPE_MATTERS
3415 {
3419 }
3420 #endif
3421 }
3422 }
3423 else
3424 {
3425 /* Non-bit-fields are aligned for their type. */
3430 }
3431 }
3433 /* FIELD is a non bit-field. We are finishing the processing for its
3434 enclosing type T. Issue any appropriate messages and set appropriate
3435 flags. */
3437 static void
3440 any_default_members)
3441 tree field;
3442 tree t;
3447 {
3450 /* An anonymous union cannot contain any fields which would change
3451 the settings of CANT_HAVE_CONST_CTOR and friends. */
3453 ;
3454 /* And, we don't set TYPE_HAS_CONST_INIT_REF, etc., for anonymous
3455 structs. So, we recurse through their fields here. */
3457 {
3458 tree fields;
3464 any_default_members);
3465 }
3466 /* Check members with class type for constructors, destructors,
3467 etc. */
3469 {
3470 /* Never let anything with uninheritable virtuals
3471 make it through without complaint. */
3475 {
3478 field);
3481 field);
3484 field);
3485 }
3486 else
3487 {
3493 }
3504 }
3506 {
3507 /* `build_class_init_list' does not recognize
3508 non-FIELD_DECLs. */
3512 }
3514 /* Non-bit-fields are aligned for their type, except packed fields
3515 which require only BITS_PER_UNIT alignment. */
3518 ? BITS_PER_UNIT
3522 }
3524 /* Check the data members (both static and non-static), class-scoped
3525 typedefs, etc., appearing in the declaration of T. Issue
3526 appropriate diagnostics. Sets ACCESS_DECLS to a list (in
3527 declaration order) of access declarations; each TREE_VALUE in this
3528 list is a USING_DECL.
3530 In addition, set the following flags:
3532 EMPTY_P
3533 The class is empty, i.e., contains no non-static data members.
3535 CANT_HAVE_DEFAULT_CTOR_P
3536 This class cannot have an implicitly generated default
3537 constructor.
3539 CANT_HAVE_CONST_CTOR_P
3540 This class cannot have an implicitly generated copy constructor
3541 taking a const reference.
3543 CANT_HAVE_CONST_ASN_REF
3544 This class cannot have an implicitly generated assignment
3545 operator taking a const reference.
3547 All of these flags should be initialized before calling this
3548 function.
3550 Returns a pointer to the end of the TYPE_FIELDs chain; additional
3551 fields can be added by adding to this chain. */
3553 static void
3556 no_const_asn_ref_p)
3557 tree t;
3563 {
3569 /* First, delete any duplicate fields. */
3572 /* Assume there are no access declarations. */
3574 /* Assume this class has no pointer members. */
3576 /* Assume none of the members of this class have default
3577 initializations. */
3581 {
3590 {
3594 /* We don't treat zero-width bitfields as making a class
3595 non-empty. */
3596 ;
3597 else
3598 {
3599 /* The class is non-empty. */
3601 /* The class is not even nearly empty. */
3603 }
3604 }
3607 {
3608 /* Prune the access declaration from the list of fields. */
3611 /* Save the access declarations for our caller. */
3614 /* Since we've reset *FIELD there's no reason to skip to the
3615 next field. */
3618 }
3624 /* If we've gotten this far, it's a data member, possibly static,
3625 or an enumerator. */
3629 /* ``A local class cannot have static data members.'' ARM 9.4 */
3633 /* Perform error checking that did not get done in
3634 grokdeclarator. */
3636 {
3638 x);
3641 }
3643 {
3647 }
3649 {
3653 }
3658 /* When this goes into scope, it will be a non-local reference. */
3665 {
3667 /* Unions cannot have static members. */
3671 }
3673 /* Now it can only be a FIELD_DECL. */
3678 /* If this is of reference type, check if it needs an init.
3679 Also do a little ANSI jig if necessary. */
3681 {
3686 /* ARM $12.6.2: [A member initializer list] (or, for an
3687 aggregate, initialization by a brace-enclosed list) is the
3688 only way to initialize nonstatic const and reference
3689 members. */
3695 }
3706 /* DR 148 now allows pointers to members (which are POD themselves),
3707 to be allowed in POD structs. */
3710 /* If any field is const, the structure type is pseudo-const. */
3712 {
3717 /* ARM $12.6.2: [A member initializer list] (or, for an
3718 aggregate, initialization by a brace-enclosed list) is the
3719 only way to initialize nonstatic const and reference
3720 members. */
3726 }
3727 /* A field that is pseudo-const makes the structure likewise. */
3729 {
3733 }
3735 /* Core issue 80: A nonstatic data member is required to have a
3736 different name from the class iff the class has a
3737 user-defined constructor. */
3742 /* We set DECL_C_BIT_FIELD in grokbitfield.
3743 If the type and width are valid, we'll also set DECL_BIT_FIELD. */
3746 else
3748 cant_have_const_ctor_p,
3749 cant_have_default_ctor_p,
3750 no_const_asn_ref_p,
3752 }
3754 /* Effective C++ rule 11. */
3757 {
3761 {
3765 }
3768 }
3771 /* Check anonymous struct/anonymous union fields. */
3774 /* We've built up the list of access declarations in reverse order.
3775 Fix that now. */
3777 }
3779 /* Return a FIELD_DECL for a pointer-to-virtual-table or
3780 pointer-to-virtual-base. The NAME, ASSEMBLER_NAME, and TYPE of the
3781 field are as indicated. The CLASS_TYPE in which this field occurs
3782 is also indicated. FCONTEXT is the type that is needed for the debug
3783 info output routines. *EMPTY_P is set to a non-zero value by this
3784 function to indicate that a class containing this field is
3785 non-empty. */
3787 static tree
3789 empty_p)
3790 tree name;
3791 tree assembler_name;
3792 tree type;
3793 tree class_type;
3794 tree fcontext;
3796 {
3797 tree field;
3799 /* This class is non-empty. */
3802 /* Build the FIELD_DECL. */
3812 /* Return it. */
3814 }
3816 /* If TYPE is an empty class type, records its OFFSET in the table of
3817 OFFSETS. */
3819 static int
3821 tree type;
3822 tree offset;
3823 splay_tree offsets;
3824 {
3825 splay_tree_node n;
3830 /* Record the location of this empty object in OFFSETS. */
3838 type,
3842 }
3844 /* Returns non-zero if TYPE is an empty class type and there is
3845 already an entry in OFFSETS for the same TYPE as the same OFFSET. */
3847 static int
3849 tree type;
3850 tree offset;
3851 splay_tree offsets;
3852 {
3853 splay_tree_node n;
3854 tree t;
3859 /* Record the location of this empty object in OFFSETS. */
3869 }
3871 /* Walk through all the subobjects of TYPE (located at OFFSET). Call
3872 F for every subobject, passing it the type, offset, and table of
3873 OFFSETS. If VBASES_P is non-zero, then even virtual non-primary
3874 bases should be traversed; otherwise, they are ignored.
3876 If MAX_OFFSET is non-NULL, then subobjects with an offset greater
3877 than MAX_OFFSET will not be walked.
3879 If F returns a non-zero value, the traversal ceases, and that value
3880 is returned. Otherwise, returns zero. */
3882 static int
3884 tree type;
3885 subobject_offset_fn f;
3886 tree offset;
3887 splay_tree offsets;
3888 tree max_offset;
3890 {
3893 /* If this OFFSET is bigger than the MAX_OFFSET, then we should
3894 stop. */
3899 {
3900 tree field;
3903 /* Record the location of TYPE. */
3908 /* Iterate through the direct base classes of TYPE. */
3910 {
3919 f,
3921 offset,
3923 offsets,
3924 max_offset,
3925 vbases_p);
3928 }
3930 /* Iterate through the fields of TYPE. */
3933 {
3935 f,
3937 offset,
3939 offsets,
3940 max_offset,
3944 }
3945 }
3947 {
3949 tree index;
3951 /* Step through each of the elements in the array. */
3955 {
3957 f,
3958 offset,
3959 offsets,
3960 max_offset,
3966 /* If this new OFFSET is bigger than the MAX_OFFSET, then
3967 there's no point in iterating through the remaining
3968 elements of the array. */
3971 }
3972 }
3975 }
3977 /* Record all of the empty subobjects of TYPE (located at OFFSET) in
3978 OFFSETS. If VBASES_P is non-zero, virtual bases of TYPE are
3979 examined. */
3981 static void
3983 tree type;
3984 tree offset;
3985 splay_tree offsets;
3987 {
3990 }
3992 /* Returns non-zero if any of the empty subobjects of TYPE (located at
3993 OFFSET) conflict with entries in OFFSETS. If VBASES_P is non-zero,
3994 virtual bases of TYPE are examined. */
3996 static int
3998 tree type;
3999 tree offset;
4000 splay_tree offsets;
4002 {
4003 splay_tree_node max_node;
4005 /* Get the node in OFFSETS that indicates the maximum offset where
4006 an empty subobject is located. */
4008 /* If there aren't any empty subobjects, then there's no point in
4009 performing this check. */
4015 vbases_p);
4016 }
4018 /* DECL is a FIELD_DECL corresponding either to a base subobject of a
4019 non-static data member of the type indicated by RLI. BINFO is the
4020 binfo corresponding to the base subobject, OFFSETS maps offsets to
4021 types already located at those offsets. T is the most derived
4022 type. This function determines the position of the DECL. */
4024 static void
4026 record_layout_info rli;
4027 tree decl;
4028 tree binfo;
4029 splay_tree offsets;
4030 tree t;
4031 {
4034 /* If we are laying out a base class, rather than a field, then
4035 DECL_ARTIFICIAL will be set on the FIELD_DECL. */
4038 /* Try to place the field. It may take more than one try if we have
4039 a hard time placing the field without putting two objects of the
4040 same type at the same address. */
4042 {
4045 /* Place this field. */
4049 /* We have to check to see whether or not there is already
4050 something of the same type at the offset we're about to use.
4051 For example:
4053 struct S {};
4054 struct T : public S { int i; };
4055 struct U : public S, public T {};
4057 Here, we put S at offset zero in U. Then, we can't put T at
4058 offset zero -- its S component would be at the same address
4059 as the S we already allocated. So, we have to skip ahead.
4060 Since all data members, including those whose type is an
4061 empty class, have non-zero size, any overlap can happen only
4062 with a direct or indirect base-class -- it can't happen with
4063 a data member. */
4065 offset,
4066 offsets,
4067 field_p))
4068 {
4069 /* Strip off the size allocated to this field. That puts us
4070 at the first place we could have put the field with
4071 proper alignment. */
4074 /* Bump up by the alignment required for the type. */
4075 rli->bitpos
4081 }
4082 else
4083 /* There was no conflict. We're done laying out this field. */
4085 }
4087 /* Now that we know where it will be placed, update its
4088 BINFO_OFFSET. */
4092 }
4094 /* Layout the empty base BINFO. EOC indicates the byte currently just
4095 past the end of the class, and should be correctly aligned for a
4096 class of the type indicated by BINFO; OFFSETS gives the offsets of
4097 the empty bases allocated so far. T is the most derived
4098 type. Return non-zero iff we added it at the end. */
4100 static bool
4102 tree binfo;
4103 tree eoc;
4104 splay_tree offsets;
4105 tree t;
4106 {
4107 tree alignment;
4111 /* This routine should only be used for empty classes. */
4115 /* This is an empty base class. We first try to put it at offset
4116 zero. */
4119 offsets,
4121 {
4122 /* That didn't work. Now, we move forward from the next
4123 available spot in the class. */
4127 {
4130 offsets,
4132 /* We finally found a spot where there's no overlap. */
4135 /* There's overlap here, too. Bump along to the next spot. */
4137 }
4138 }
4140 }
4142 /* Build a FIELD_DECL for the base given by BINFO in the class
4143 indicated by RLI. If the new object is non-empty, clear *EMPTY_P.
4144 *BASE_ALIGN is a running maximum of the alignments of any base
4145 class. OFFSETS gives the location of empty base subobjects. T is
4146 the most derived type. Return non-zero if the new object cannot be
4147 nearly-empty. */
4149 static bool
4151 record_layout_info rli;
4152 tree binfo;
4154 splay_tree offsets;
4155 tree t;
4156 {
4158 tree decl;
4162 /* This error is now reported in xref_tag, thus giving better
4163 location information. */
4175 {
4176 /* The containing class is non-empty because it has a non-empty
4177 base class. */
4180 /* Try to place the field. It may take more than one try if we
4181 have a hard time placing the field without putting two
4182 objects of the same type at the same address. */
4184 }
4185 else
4186 {
4189 /* On some platforms (ARM), even empty classes will not be
4190 byte-aligned. */
4194 }
4196 /* Record the offsets of BINFO and its base subobjects. */
4199 offsets,
4202 }
4204 /* Layout all of the non-virtual base classes. Record empty
4205 subobjects in OFFSETS. T is the most derived type. Return
4206 non-zero if the type cannot be nearly empty. */
4208 static bool
4210 record_layout_info rli;
4212 splay_tree offsets;
4213 tree t;
4214 {
4215 /* Chain to hold all the new FIELD_DECLs which stand in for base class
4216 subobjects. */
4222 /* Under the new ABI, the primary base class is always allocated
4223 first. */
4228 /* Now allocate the rest of the bases. */
4230 {
4231 tree base_binfo;
4235 /* Under the new ABI, the primary base was already allocated
4236 above, so we don't need to allocate it again here. */
4240 /* A primary virtual base class is allocated just like any other
4241 base class, but a non-primary virtual base is allocated
4242 later, in layout_virtual_bases. */
4248 }
4250 }
4252 /* Go through the TYPE_METHODS of T issuing any appropriate
4253 diagnostics, figuring out which methods override which other
4254 methods, and so forth. */
4256 static void
4258 tree t;
4259 {
4260 tree x;
4264 {
4267 /* If this was an evil function, don't keep it in class. */
4276 /* The name of the field is the original field name
4277 Save this in auxiliary field for later overloading. */
4279 {
4284 }
4287 {
4288 tree second_parm;
4290 /* When dynamically allocating an array of this type, we
4291 need a "cookie" to record how many elements we allocated,
4292 even if the array elements have no non-trivial
4293 destructor, if the usual array deallocation function
4294 takes a second argument of type size_t. The standard (in
4295 [class.free]) requires that the second argument be set
4296 correctly. */
4298 /* Under the new ABI, we choose only those function that are
4299 explicitly declared as `operator delete[] (void *,
4300 size_t)'. */
4302 && second_parm
4306 /* If there's no second parameter, then this is the usual
4307 deallocation function. */
4310 }
4311 }
4312 }
4314 /* FN is a constructor or destructor. Clone the declaration to create
4315 a specialized in-charge or not-in-charge version, as indicated by
4316 NAME. */
4318 static tree
4320 tree fn;
4321 tree name;
4322 {
4323 tree parms;
4324 tree clone;
4326 /* Copy the function. */
4328 /* Remember where this function came from. */
4331 /* Reset the function name. */
4334 /* There's no pending inline data for this function. */
4337 /* And it hasn't yet been deferred. */
4340 /* The base-class destructor is not virtual. */
4342 {
4346 }
4348 /* If there was an in-charge parameter, drop it from the function
4349 type. */
4351 {
4352 tree basetype;
4353 tree parmtypes;
4354 tree exceptions;
4359 /* Skip the `this' parameter. */
4361 /* Skip the in-charge parameter. */
4363 /* And the VTT parm, in a complete [cd]tor. */
4367 /* If this is subobject constructor or destructor, add the vtt
4368 parameter. */
4372 parmtypes);
4375 exceptions);
4376 }
4378 /* Copy the function parameters. But, DECL_ARGUMENTS on a TEMPLATE_DECL
4379 aren't function parameters; those are the template parameters. */
4381 {
4383 /* Remove the in-charge parameter. */
4385 {
4389 }
4390 /* And the VTT parm, in a complete [cd]tor. */
4392 {
4395 else
4396 {
4400 }
4401 }
4404 {
4407 }
4408 }
4410 /* Create the RTL for this function. */
4414 /* Make it easy to find the CLONE given the FN. */
4418 /* If this is a template, handle the DECL_TEMPLATE_RESULT as well. */
4420 {
4421 tree result;
4428 }
4433 }
4435 /* Produce declarations for all appropriate clones of FN. If
4436 UPDATE_METHOD_VEC_P is non-zero, the clones are added to the
4437 CLASTYPE_METHOD_VEC as well. */
4439 void
4441 tree fn;
4443 {
4444 tree clone;
4446 /* Avoid inappropriate cloning. */
4452 {
4453 /* For each constructor, we need two variants: an in-charge version
4454 and a not-in-charge version. */
4461 }
4462 else
4463 {
4466 /* For each destructor, we need three variants: an in-charge
4467 version, a not-in-charge version, and an in-charge deleting
4468 version. We clone the deleting version first because that
4469 means it will go second on the TYPE_METHODS list -- and that
4470 corresponds to the correct layout order in the virtual
4471 function table.
4473 For a non-virtual destructor, we do not build a deleting
4474 destructor. */
4476 {
4480 }
4487 }
4489 /* Note that this is an abstract function that is never emitted. */
4491 }
4493 /* DECL is an in charge constructor, which is being defined. This will
4494 have had an in class declaration, from whence clones were
4495 declared. An out-of-class definition can specify additional default
4496 arguments. As it is the clones that are involved in overload
4497 resolution, we must propagate the information from the DECL to its
4498 clones. */
4500 void
4502 tree decl;
4503 {
4504 tree clone;
4508 {
4515 /* Skip the 'this' parameter. */
4531 {
4536 {
4537 /* A default parameter has been added. Adjust the
4538 clone's parameters. */
4541 tree type;
4546 {
4549 clone_parms);
4551 }
4554 clone_parms);
4561 }
4562 }
4564 }
4565 }
4567 /* For each of the constructors and destructors in T, create an
4568 in-charge and not-in-charge variant. */
4570 static void
4572 tree t;
4573 {
4574 tree fns;
4576 /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail
4577 out now. */
4585 }
4587 /* Remove all zero-width bit-fields from T. */
4589 static void
4591 tree t;
4592 {
4597 {
4602 else
4604 }
4605 }
4607 /* Check the validity of the bases and members declared in T. Add any
4608 implicitly-generated functions (like copy-constructors and
4609 assignment operators). Compute various flag bits (like
4610 CLASSTYPE_NON_POD_T) for T. This routine works purely at the C++
4611 level: i.e., independently of the ABI in use. */
4613 static void
4615 tree t;
4617 {
4618 /* Nonzero if we are not allowed to generate a default constructor
4619 for this case. */
4621 /* Nonzero if the implicitly generated copy constructor should take
4622 a non-const reference argument. */
4624 /* Nonzero if the the implicitly generated assignment operator
4625 should take a non-const reference argument. */
4627 tree access_decls;
4629 /* By default, we use const reference arguments and generate default
4630 constructors. */
4635 /* Assume that the class is nearly empty; we'll clear this flag if
4636 it turns out not to be nearly empty. */
4639 /* Check all the base-classes. */
4643 /* Check all the data member declarations. */
4649 /* Check all the method declarations. */
4652 /* A nearly-empty class has to be vptr-containing; a nearly empty
4653 class contains just a vptr. */
4657 /* Do some bookkeeping that will guide the generation of implicitly
4658 declared member functions. */
4676 /* Synthesize any needed methods. Note that methods will be synthesized
4677 for anonymous unions; grok_x_components undoes that. */
4679 cant_have_const_ctor,
4680 no_const_asn_ref);
4682 /* Create the in-charge and not-in-charge variants of constructors
4683 and destructors. */
4686 /* Process the using-declarations. */
4690 /* Build and sort the CLASSTYPE_METHOD_VEC. */
4692 }
4694 /* If T needs a pointer to its virtual function table, set TYPE_VFIELD
4695 accordingly. If a new vfield was created (because T doesn't have a
4696 primary base class), then the newly created field is returned. It
4697 is not added to the TYPE_FIELDS list; it is the caller's
4698 responsibility to do that. */
4700 static tree
4703 tree t;
4708 {
4709 tree fn;
4711 /* Loop over the virtual functions, adding them to our various
4712 vtables. */
4718 /* If we couldn't find an appropriate base class, create a new field
4719 here. Even if there weren't any new virtual functions, we might need a
4720 new virtual function table if we're supposed to include vptrs in
4721 all classes that need them. */
4723 && (*vfuns_p
4725 {
4726 /* We build this decl with vtbl_ptr_type_node, which is a
4727 `vtable_entry_type*'. It might seem more precise to use
4728 `vtable_entry_type (*)[N]' where N is the number of firtual
4729 functions. However, that would require the vtable pointer in
4730 base classes to have a different type than the vtable pointer
4731 in derived classes. We could make that happen, but that
4732 still wouldn't solve all the problems. In particular, the
4733 type-based alias analysis code would decide that assignments
4734 to the base class vtable pointer can't alias assignments to
4735 the derived class vtable pointer, since they have different
4736 types. Thus, in an derived class destructor, where the base
4737 class constructor was inlined, we could generate bad code for
4738 setting up the vtable pointer.
4740 Therefore, we use one type for all vtable pointers. We still
4741 use a type-correct type; it's just doesn't indicate the array
4742 bounds. That's better than using `void*' or some such; it's
4743 cleaner, and it let's the alias analysis code know that these
4744 stores cannot alias stores to void*! */
4748 vtbl_ptr_type_node,
4749 t,
4750 t,
4751 empty_p);
4754 /* If there were any baseclasses, they can't possibly be at
4755 offset zero any more, because that's where the vtable
4756 pointer is. So, converting to a base class is going to
4757 take work. */
4761 }
4764 }
4766 /* Fixup the inline function given by INFO now that the class is
4767 complete. */
4769 static void
4771 tree fn;
4772 {
4774 {
4777 {
4780 }
4781 }
4782 }
4784 /* Fixup the inline methods and friends in TYPE now that TYPE is
4785 complete. */
4787 static void
4789 tree type;
4790 {
4794 {
4799 else
4801 }
4803 /* Do inline member functions. */
4807 /* Do friends. */
4809 method;
4813 }
4815 /* Add OFFSET to all base types of BINFO which is a base in the
4816 hierarchy dominated by T.
4818 OFFSET, which is a type offset, is number of bytes. */
4820 static void
4822 tree binfo;
4823 tree offset;
4824 tree t;
4825 {
4827 tree primary_binfo;
4829 /* Update BINFO's offset. */
4834 offset));
4836 /* Find the primary base class. */
4839 /* Scan all of the bases, pushing the BINFO_OFFSET adjust
4840 downwards. */
4842 {
4843 tree base_binfo;
4845 /* On the first time through the loop, do the primary base.
4846 Because the primary base need not be an immediate base, we
4847 must handle the primary base specially. */
4849 {
4854 }
4855 else
4856 {
4858 /* Don't do the primary base twice. */
4861 }
4863 /* Skip virtual bases that aren't our canonical primary base. */
4870 }
4871 }
4873 /* Called via dfs_walk from layout_virtual bases. */
4875 static tree
4877 tree binfo;
4879 {
4880 /* If this is a virtual base, make sure it has the same offset as
4881 the shared copy. If it's a primary base, then we know it's
4882 correct. */
4884 {
4886 tree vbase;
4887 tree offset;
4891 {
4894 }
4895 }
4898 }
4900 /* Set BINFO_OFFSET for all of the virtual bases for T. Update
4901 TYPE_ALIGN and TYPE_SIZE for T. OFFSETS gives the location of
4902 empty subobjects of T. */
4904 static void
4906 tree t;
4907 splay_tree offsets;
4908 {
4909 tree vbases;
4916 #ifdef STRUCTURE_SIZE_BOUNDARY
4917 /* Packed structures don't need to have minimum size. */
4920 #endif
4922 /* DSIZE is the size of the class without the virtual bases. */
4925 /* Make every class have alignment of at least one. */
4928 /* Go through the virtual bases, allocating space for each virtual
4929 base that is not already a primary base class. Under the old
4930 ABI, these are allocated according to a depth-first left-to-right
4931 postorder traversal; in the new ABI, inheritance graph order is
4932 used instead. */
4934 vbases;
4936 {
4937 tree vbase;
4944 {
4945 /* This virtual base is not a primary base of any class in the
4946 hierarchy, so we have to add space for it. */
4947 tree basetype;
4955 /* Add padding so that we can put the virtual base class at an
4956 appropriately aligned offset. */
4959 /* Under the new ABI, we try to squish empty virtual bases in
4960 just like ordinary empty bases. */
4965 else
4966 {
4967 tree offset;
4974 /* And compute the offset of the virtual base. */
4976 /* Every virtual baseclass takes a least a UNIT, so that
4977 we can take it's address and get something different
4978 for each base. */
4981 }
4983 /* Keep track of the offsets assigned to this virtual base. */
4986 offsets,
4988 }
4989 }
4991 /* Now, go through the TYPE_BINFO hierarchy, setting the
4992 BINFO_OFFSETs correctly for all non-primary copies of the virtual
4993 bases and their direct and indirect bases. The ambiguity checks
4994 in get_base_distance depend on the BINFO_OFFSETs being set
4995 correctly. */
4998 /* If we had empty base classes that protruded beyond the end of the
4999 class, we didn't update DSIZE above; we were hoping to overlay
5000 multiple such bases at the same location. */
5005 /* Now, make sure that the total size of the type is a multiple of
5006 its alignment. */
5011 bitsize_unit_node));
5013 /* Check for ambiguous virtual bases. */
5016 vbases;
5018 {
5023 }
5024 }
5026 /* Returns the offset of the byte just past the end of the base class
5027 with the highest offset in T. If INCLUDE_VIRTUALS_P is zero, then
5028 only non-virtual bases are included. */
5030 static unsigned HOST_WIDE_INT
5032 tree t;
5034 {
5039 {
5040 tree base_binfo;
5041 tree offset;
5042 tree size;
5053 /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to
5054 allocate some space for it. It cannot have virtual bases,
5055 so TYPE_SIZE_UNIT is fine. */
5057 else
5061 size);
5065 }
5068 }
5070 /* Warn about direct bases of T that are inaccessible because they are
5071 ambiguous. For example:
5073 struct S {};
5074 struct T : public S {};
5075 struct U : public S, public T {};
5077 Here, `(S*) new U' is not allowed because there are two `S'
5078 subobjects of U. */
5080 static void
5082 tree t;
5083 {
5087 {
5093 }
5094 }
5096 /* Compare two INTEGER_CSTs K1 and K2. */
5098 static int
5100 splay_tree_key k1;
5101 splay_tree_key k2;
5102 {
5104 }
5106 /* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T. Calculate
5107 BINFO_OFFSETs for all of the base-classes. Position the vtable
5108 pointer. */
5110 static void
5113 tree t;
5118 {
5119 tree non_static_data_members;
5120 tree field;
5121 tree vptr;
5122 record_layout_info rli;
5124 /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of
5125 types that appear at that offset. */
5126 splay_tree empty_base_offsets;
5128 /* Keep track of the first non-static data member. */
5131 /* Start laying out the record. */
5134 /* If possible, we reuse the virtual function table pointer from one
5135 of our base classes. */
5138 /* Create a pointer to our virtual function table. */
5142 /* Under the new ABI, the vptr is always the first thing in the
5143 class. */
5145 {
5148 }
5150 /* Build FIELD_DECLs for all of the non-virtual base-types. */
5156 /* Add pointers to all of our virtual base-classes. */
5160 /* CLASSTYPE_INLINE_FRIENDS is really TYPE_NONCOPIED_PARTS. Thus,
5161 we have to save this before we zap TYPE_NONCOPIED_PARTS. */
5164 /* Layout the non-static data members. */
5166 {
5167 tree type;
5168 tree padding;
5170 /* We still pass things that aren't non-static data members to
5171 the back-end, in case it wants to do something with them. */
5173 {
5176 }
5180 /* If this field is a bit-field whose width is greater than its
5181 type, then there are some special rules for allocating it
5182 under the new ABI. Under the old ABI, there were no special
5183 rules, but the back-end can't handle bitfields longer than a
5184 `long long', so we use the same mechanism. */
5187 {
5188 integer_type_kind itk;
5189 tree integer_type;
5191 /* We must allocate the bits as if suitably aligned for the
5192 longest integer type that fits in this many bits. type
5193 of the field. Then, we are supposed to use the left over
5194 bits as additional padding. */
5200 /* ITK now indicates a type that is too large for the
5201 field. We have to back up by one to find the largest
5202 type that fits. */
5209 }
5210 else
5216 /* If we needed additional padding after this field, add it
5217 now. */
5219 {
5220 tree padding_field;
5223 NULL_TREE,
5224 char_type_node);
5230 NULL_TREE,
5232 }
5233 }
5235 /* It might be the case that we grew the class to allocate a
5236 zero-sized base class. That won't be reflected in RLI, yet,
5237 because we are willing to overlay multiple bases at the same
5238 offset. However, now we need to make sure that RLI is big enough
5239 to reflect the entire class. */
5243 {
5246 }
5248 /* We make all structures have at least one element, so that they
5249 have non-zero size. In the new ABI, the class may be empty even
5250 if it has basetypes. Therefore, we add the fake field after all
5251 the other fields; if there are already FIELD_DECLs on the list,
5252 their offsets will not be disturbed. */
5254 {
5255 tree padding;
5259 }
5261 /* Let the back-end lay out the type. Note that at this point we
5262 have only included non-virtual base-classes; we will lay out the
5263 virtual base classes later. So, the TYPE_SIZE/TYPE_ALIGN after
5264 this call are not necessarily correct; they are just the size and
5265 alignment when no virtual base clases are used. */
5268 /* Delete all zero-width bit-fields from the list of fields. Now
5269 that the type is laid out they are no longer important. */
5272 /* Remember the size and alignment of the class before adding
5273 the virtual bases. */
5275 {
5278 }
5279 else
5280 {
5283 }
5288 /* Set the TYPE_DECL for this type to contain the right
5289 value for DECL_OFFSET, so that we can use it as part
5290 of a COMPONENT_REF for multiple inheritance. */
5293 /* Now fix up any virtual base class types that we left lying
5294 around. We must get these done before we try to lay out the
5295 virtual function table. As a side-effect, this will remove the
5296 base subobject fields. */
5299 /* Warn about direct bases that can't be talked about due to
5300 ambiguity. */
5303 /* Clean up. */
5305 }
5307 /* Create a RECORD_TYPE or UNION_TYPE node for a C struct or union declaration
5308 (or C++ class declaration).
5310 For C++, we must handle the building of derived classes.
5311 Also, C++ allows static class members. The way that this is
5312 handled is to keep the field name where it is (as the DECL_NAME
5313 of the field), and place the overloaded decl in the bit position
5314 of the field. layout_record and layout_union will know about this.
5316 More C++ hair: inline functions have text in their
5317 DECL_PENDING_INLINE_INFO nodes which must somehow be parsed into
5318 meaningful tree structure. After the struct has been laid out, set
5319 things up so that this can happen.
5321 And still more: virtual functions. In the case of single inheritance,
5322 when a new virtual function is seen which redefines a virtual function
5323 from the base class, the new virtual function is placed into
5324 the virtual function table at exactly the same address that
5325 it had in the base class. When this is extended to multiple
5326 inheritance, the same thing happens, except that multiple virtual
5327 function tables must be maintained. The first virtual function
5328 table is treated in exactly the same way as in the case of single
5329 inheritance. Additional virtual function tables have different
5330 DELTAs, which tell how to adjust `this' to point to the right thing.
5332 ATTRIBUTES is the set of decl attributes to be applied, if any. */
5334 void
5336 tree t;
5337 {
5338 tree x;
5340 /* The NEW_VIRTUALS is a TREE_LIST. The TREE_VALUE of each node is
5341 a FUNCTION_DECL. Each of these functions is a virtual function
5342 declared in T that does not override any virtual function from a
5343 base class. */
5345 /* The OVERRIDDEN_VIRTUALS list is like the NEW_VIRTUALS list,
5346 except that each declaration here overrides the declaration from
5347 a base class. */
5350 tree vfield;
5354 {
5357 else
5361 }
5365 /* If this type was previously laid out as a forward reference,
5366 make sure we lay it out again. */
5373 /* Do end-of-class semantic processing: checking the validity of the
5374 bases and members and add implicitly generated methods. */
5377 /* Layout the class itself. */
5381 /* Make sure that we get our own copy of the vfield FIELD_DECL. */
5384 {
5390 /* The vtable better be at the start. */
5399 }
5400 else
5403 overridden_virtuals
5406 /* If we created a new vtbl pointer for this class, add it to the
5407 list. */
5412 /* If necessary, create the primary vtable for this class. */
5414 || overridden_virtuals
5416 {
5418 /* We must enter these virtuals into the table. */
5422 /* Here we know enough to change the type of our virtual
5423 function table, but we will wait until later this function. */
5426 /* If this type has basetypes with constructors, then those
5427 constructors might clobber the virtual function table. But
5428 they don't if the derived class shares the exact vtable of the base
5429 class. */
5432 }
5433 /* If we didn't need a new vtable, see if we should copy one from
5434 the base. */
5436 {
5439 /* If this class uses a different vtable than its primary base
5440 then when we will need to initialize our vptr after the base
5441 class constructor runs. */
5444 }
5447 {
5456 /* Entries for virtual functions defined in the primary base are
5457 followed by entries for new functions unique to this class. */
5460 /* Finally, add entries for functions that override virtuals
5461 from non-primary bases. */
5464 }
5468 /* Complete the rtl for any static member objects of the type we're
5469 working on. */
5475 /* Done with FIELDS...now decide whether to sort these for
5476 faster lookups later.
5478 The C front-end only does this when n_fields > 15. We use
5479 a smaller number because most searches fail (succeeding
5480 ultimately as the search bores through the inheritance
5481 hierarchy), and we want this failure to occur quickly. */
5485 {
5493 }
5496 {
5500 {
5501 /* Mark the fact that constructor for T
5502 could affect anybody inheriting from T
5503 who wants to initialize vtables for VFIELDS's type. */
5507 }
5508 }
5510 /* Make the rtl for any new vtables we have created, and unmark
5511 the base types we marked. */
5514 /* Build the VTT for T. */
5530 /* Finish debugging output for this type. */
5532 }
5534 /* When T was built up, the member declarations were added in reverse
5535 order. Rearrange them to declaration order. */
5537 void
5539 tree t;
5540 {
5541 tree next;
5542 tree prev;
5543 tree x;
5545 /* The TYPE_FIELDS, TYPE_METHODS, and CLASSTYPE_TAGS are all in
5546 reverse order. Put them in declaration order now. */
5550 /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
5551 reverse order, so we can't just use nreverse. */
5556 {
5560 }
5562 {
5566 }
5567 }
5569 tree
5572 {
5576 /* Now that we've got all the field declarations, reverse everything
5577 as necessary. */
5582 /* Nadger the current location so that diagnostics point to the start of
5583 the struct, not the end. */
5588 {
5591 }
5592 else
5602 else
5606 {
5610 }
5613 }
5614 \f
5615 /* Return the dynamic type of INSTANCE, if known.
5616 Used to determine whether the virtual function table is needed
5617 or not.
5619 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5620 of our knowledge of its type. *NONNULL should be initialized
5621 before this function is called. */
5623 static tree
5625 tree instance;
5628 {
5630 {
5632 /* Check that we are not going through a cast of some sort. */
5636 /* fall through... */
5638 /* This is a call to a constructor, hence it's never zero. */
5640 {
5644 }
5648 /* This is a call to a constructor, hence it's never zero. */
5650 {
5654 }
5665 /* Propagate nonnull. */
5685 {
5689 }
5690 /* fall through... */
5694 {
5698 }
5700 {
5704 /* if we're in a ctor or dtor, we know our type. */
5708 {
5712 }
5713 }
5715 {
5716 /* Reference variables should be references to objects. */
5719 }
5724 }
5725 }
5727 /* Return non-zero if the dynamic type of INSTANCE is known, and equivalent
5728 to the static type. We also handle the case where INSTANCE is really
5729 a pointer. Return negative if this is a ctor/dtor. There the dynamic type
5730 is known, but this might not be the most derived base of the original object,
5731 and hence virtual bases may not be layed out according to this type.
5733 Used to determine whether the virtual function table is needed
5734 or not.
5736 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5737 of our knowledge of its type. *NONNULL should be initialized
5738 before this function is called. */
5740 int
5742 tree instance;
5744 {
5756 }
5758 \f
5759 void
5761 {
5764 current_class_stack
5782 }
5784 /* Set current scope to NAME. CODE tells us if this is a
5785 STRUCT, UNION, or ENUM environment.
5787 NAME may end up being NULL_TREE if this is an anonymous or
5788 late-bound struct (as in "struct { ... } foo;") */
5790 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE to
5791 appropriate values, found by looking up the type definition of
5792 NAME (as a CODE).
5794 If MODIFY is 1, we set IDENTIFIER_CLASS_VALUE's of names
5795 which can be seen locally to the class. They are shadowed by
5796 any subsequent local declaration (including parameter names).
5798 If MODIFY is 2, we set IDENTIFIER_CLASS_VALUE's of names
5799 which have static meaning (i.e., static members, static
5800 member functions, enum declarations, etc).
5802 If MODIFY is 3, we set IDENTIFIER_CLASS_VALUE of names
5803 which can be seen locally to the class (as in 1), but
5804 know that we are doing this for declaration purposes
5805 (i.e. friend foo::bar (int)).
5807 So that we may avoid calls to lookup_name, we cache the _TYPE
5808 nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
5810 For multiple inheritance, we perform a two-pass depth-first search
5811 of the type lattice. The first pass performs a pre-order search,
5812 marking types after the type has had its fields installed in
5813 the appropriate IDENTIFIER_CLASS_VALUE slot. The second pass merely
5814 unmarks the marked types. If a field or member function name
5815 appears in an ambiguous way, the IDENTIFIER_CLASS_VALUE of
5816 that name becomes `error_mark_node'. */
5818 void
5820 tree type;
5822 {
5825 /* Make sure there is enough room for the new entry on the stack. */
5827 {
5829 current_class_stack
5831 current_class_stack_size
5833 }
5835 /* Insert a new entry on the class stack. */
5840 current_class_depth++;
5842 /* Now set up the new type. */
5848 /* By default, things in classes are private, while things in
5849 structures or unions are public. */
5851 ? access_private_node
5858 {
5859 /* Forcibly remove any old class remnants. */
5861 }
5863 /* If we're about to enter a nested class, clear
5864 IDENTIFIER_CLASS_VALUE for the enclosing classes. */
5871 {
5874 else
5875 {
5876 tree item;
5878 /* We are re-entering the same class we just left, so we
5879 don't have to search the whole inheritance matrix to find
5880 all the decls to bind again. Instead, we install the
5881 cached class_shadowed list, and walk through it binding
5882 names and setting up IDENTIFIER_TYPE_VALUEs. */
5885 {
5892 }
5894 }
5897 }
5898 }
5900 /* When we exit a toplevel class scope, we save the
5901 IDENTIFIER_CLASS_VALUEs so that we can restore them quickly if we
5902 reenter the class. Here, we've entered some other class, so we
5903 must invalidate our cache. */
5905 void
5907 {
5908 tree t;
5910 /* The IDENTIFIER_CLASS_VALUEs are no longer valid. */
5916 }
5918 /* Get out of the current class scope. If we were in a class scope
5919 previously, that is the one popped to. */
5921 void
5923 {
5925 /* Since poplevel_class does the popping of class decls nowadays,
5926 this really only frees the obstack used for these decls. */
5929 current_class_depth--;
5935 }
5937 /* Returns 1 if current_class_type is either T or a nested type of T.
5938 We start looking from 1 because entry 0 is from global scope, and has
5939 no type. */
5941 int
5943 tree t;
5944 {
5952 }
5954 /* If either current_class_type or one of its enclosing classes are derived
5955 from T, return the appropriate type. Used to determine how we found
5956 something via unqualified lookup. */
5958 tree
5960 tree t;
5961 {
5972 }
5974 /* When entering a class scope, all enclosing class scopes' names with
5975 static meaning (static variables, static functions, types and enumerators)
5976 have to be visible. This recursive function calls pushclass for all
5977 enclosing class contexts until global or a local scope is reached.
5978 TYPE is the enclosed class and MODIFY is equivalent with the pushclass
5979 formal of the same name. */
5981 void
5983 tree type;
5985 {
5986 tree context;
5988 /* A namespace might be passed in error cases, like A::B:C. */
6002 }
6004 /* Undoes a push_nested_class call. MODIFY is passed on to popclass. */
6006 void
6008 {
6014 }
6016 /* Set global variables CURRENT_LANG_NAME to appropriate value
6017 so that behavior of name-mangling machinery is correct. */
6019 void
6021 tree name;
6022 {
6026 {
6031 }
6034 {
6036 }
6038 {
6040 /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
6041 (See record_builtin_java_type in decl.c.) However, that causes
6042 incorrect debug entries if these types are actually used.
6043 So we re-enable debug output after extern "Java". */
6052 }
6054 {
6056 }
6057 else
6059 }
6061 /* Get out of the current language scope. */
6063 void
6065 {
6066 /* Clear the current entry so that garbage collector won't hold on
6067 to it. */
6070 }
6071 \f
6072 /* Type instantiation routines. */
6074 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
6075 matches the TARGET_TYPE. If there is no satisfactory match, return
6076 error_mark_node, and issue an error message if COMPLAIN is
6077 non-zero. Permit pointers to member function if PTRMEM is non-zero.
6078 If TEMPLATE_ONLY, the name of the overloaded function
6079 was a template-id, and EXPLICIT_TARGS are the explicitly provided
6080 template arguments. */
6082 static tree
6084 overload,
6085 complain,
6086 ptrmem,
6087 template_only,
6088 explicit_targs)
6089 tree target_type;
6090 tree overload;
6094 tree explicit_targs;
6095 {
6096 /* Here's what the standard says:
6098 [over.over]
6100 If the name is a function template, template argument deduction
6101 is done, and if the argument deduction succeeds, the deduced
6102 arguments are used to generate a single template function, which
6103 is added to the set of overloaded functions considered.
6105 Non-member functions and static member functions match targets of
6106 type "pointer-to-function" or "reference-to-function." Nonstatic
6107 member functions match targets of type "pointer-to-member
6108 function;" the function type of the pointer to member is used to
6109 select the member function from the set of overloaded member
6110 functions. If a nonstatic member function is selected, the
6111 reference to the overloaded function name is required to have the
6112 form of a pointer to member as described in 5.3.1.
6114 If more than one function is selected, any template functions in
6115 the set are eliminated if the set also contains a non-template
6116 function, and any given template function is eliminated if the
6117 set contains a second template function that is more specialized
6118 than the first according to the partial ordering rules 14.5.5.2.
6119 After such eliminations, if any, there shall remain exactly one
6120 selected function. */
6124 /* We store the matches in a TREE_LIST rooted here. The functions
6125 are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
6126 interoperability with most_specialized_instantiation. */
6128 tree fn;
6130 /* By the time we get here, we should be seeing only real
6131 pointer-to-member types, not the internal POINTER_TYPE to
6132 METHOD_TYPE representation. */
6140 /* Check that the TARGET_TYPE is reasonable. */
6144 /* This is OK, too. */
6147 {
6148 /* This is OK, too. This comes from a conversion to reference
6149 type. */
6152 }
6153 else
6154 {
6160 }
6162 /* If we can find a non-template function that matches, we can just
6163 use it. There's no point in generating template instantiations
6164 if we're just going to throw them out anyhow. But, of course, we
6165 can only do this when we don't *need* a template function. */
6167 {
6168 tree fns;
6171 {
6173 tree fntype;
6176 /* We're not looking for templates just yet. */
6181 /* We're looking for a non-static member, and this isn't
6182 one, or vice versa. */
6185 /* See if there's a match. */
6194 }
6195 }
6197 /* Now, if we've already got a match (or matches), there's no need
6198 to proceed to the template functions. But, if we don't have a
6199 match we need to look at them, too. */
6201 {
6202 tree target_fn_type;
6203 tree target_arg_types;
6204 tree target_ret_type;
6205 tree fns;
6208 target_fn_type
6210 else
6215 /* Never do unification on the 'this' parameter. */
6220 {
6222 tree instantiation;
6223 tree instantiation_type;
6224 tree targs;
6227 /* We're only looking for templates. */
6232 /* We're not looking for a non-static member, and this is
6233 one, or vice versa. */
6236 /* Try to do argument deduction. */
6241 /* Argument deduction failed. */
6244 /* Instantiate the template. */
6247 /* Instantiation failed. */
6250 /* See if there's a match. */
6253 instantiation_type =
6259 }
6261 /* Now, remove all but the most specialized of the matches. */
6263 {
6268 }
6269 }
6271 /* Now we should have exactly one function in MATCHES. */
6273 {
6274 /* There were *no* matches. */
6276 {
6279 target_type);
6281 /* print_candidates expects a chain with the functions in
6282 TREE_VALUE slots, so we cons one up here (we're losing anyway,
6283 so why be clever?). */
6286 matches);
6289 }
6291 }
6293 {
6294 /* There were too many matches. */
6297 {
6298 tree match;
6302 target_type);
6304 /* Since print_candidates expects the functions in the
6305 TREE_VALUE slot, we flip them here. */
6310 }
6313 }
6315 /* Good, exactly one match. Now, convert it to the correct type. */
6320 {
6328 {
6331 }
6332 }
6337 else
6338 {
6339 /* The target must be a REFERENCE_TYPE. Above, build_unary_op
6340 will mark the function as addressed, but here we must do it
6341 explicitly. */
6345 }
6346 }
6348 /* This function will instantiate the type of the expression given in
6349 RHS to match the type of LHSTYPE. If errors exist, then return
6350 error_mark_node. FLAGS is a bit mask. If ITF_COMPLAIN is set, then
6351 we complain on errors. If we are not complaining, never modify rhs,
6352 as overload resolution wants to try many possible instantiations, in
6353 the hope that at least one will work.
6355 For non-recursive calls, LHSTYPE should be a function, pointer to
6356 function, or a pointer to member function. */
6358 tree
6362 {
6371 {
6375 }
6378 {
6385 }
6387 /* We don't overwrite rhs if it is an overloaded function.
6388 Copying it would destroy the tree link. */
6392 /* This should really only be used when attempting to distinguish
6393 what sort of a pointer to function we have. For now, any
6394 arithmetic operation which is not supported on pointers
6395 is rejected as an error. */
6398 {
6409 {
6410 tree new_rhs;
6420 }
6436 /* This can happen if we are forming a pointer-to-member for a
6437 member template. */
6440 /* Fall through. */
6443 {
6447 return
6449 fns,
6450 complain,
6451 allow_ptrmem,
6453 args);
6454 }
6457 return
6459 rhs,
6460 complain,
6461 allow_ptrmem,
6466 /* Now we should have a baselink. */
6472 /* This is too hard for now. */
6546 {
6550 }
6573 {
6578 }
6589 }
6590 }
6591 \f
6592 /* Return the name of the virtual function pointer field
6593 (as an IDENTIFIER_NODE) for the given TYPE. Note that
6594 this may have to look back through base types to find the
6595 ultimate field name. (For single inheritance, these could
6596 all be the same name. Who knows for multiple inheritance). */
6598 static tree
6600 tree type;
6601 {
6615 }
6617 void
6619 {
6620 #ifdef GATHER_STATISTICS
6626 {
6631 }
6632 #endif
6633 }
6635 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
6636 according to [class]:
6637 The class-name is also inserted
6638 into the scope of the class itself. For purposes of access checking,
6639 the inserted class name is treated as if it were a public member name. */
6641 void
6643 {
6646 tree saved_cas;
6659 }
6661 /* Returns 1 if TYPE contains only padding bytes. */
6663 int
6665 tree type;
6666 {
6674 }
6676 /* Find the enclosing class of the given NODE. NODE can be a *_DECL or
6677 a *_TYPE node. NODE can also be a local class. */
6679 tree
6681 tree type;
6682 {
6686 {
6688 {
6701 }
6702 }
6704 }
6706 /* Return 1 if TYPE or one of its enclosing classes is derived from BASE. */
6708 int
6711 {
6713 {
6718 }
6720 }
6722 /* Note that NAME was looked up while the current class was being
6723 defined and that the result of that lookup was DECL. */
6725 void
6727 tree name;
6728 tree decl;
6729 {
6730 splay_tree names_used;
6732 /* If we're not defining a class, there's nothing to do. */
6736 /* If there's already a binding for this NAME, then we don't have
6737 anything to worry about. */
6749 }
6751 /* Note that NAME was declared (as DECL) in the current class. Check
6752 to see that the declaration is legal. */
6754 void
6756 tree name;
6757 tree decl;
6758 {
6759 splay_tree names_used;
6760 splay_tree_node n;
6762 /* Look to see if we ever used this name. */
6763 names_used
6770 {
6771 /* [basic.scope.class]
6773 A name N used in a class S shall refer to the same declaration
6774 in its context and when re-evaluated in the completed scope of
6775 S. */
6780 }
6781 }
6783 /* Returns the VAR_DECL for the complete vtable associated with
6784 BINFO. (Under the new ABI, secondary vtables are merged with
6785 primary vtables; this function will return the VAR_DECL for the
6786 primary vtable.) */
6788 tree
6790 tree binfo;
6791 {
6792 tree decl;
6796 {
6800 }
6804 }
6806 /* Called from get_primary_binfo via dfs_walk. DATA is a TREE_LIST
6807 who's TREE_PURPOSE is the TYPE of the required primary base and
6808 who's TREE_VALUE is a list of candidate binfos that we fill in. */
6810 static tree
6812 tree binfo;
6814 {
6820 /* This is the right type of binfo, but it might be an unshared
6821 instance, and the shared instance is later in the dfs walk. We
6822 must keep looking. */
6826 }
6828 /* Returns the unshared binfo for the primary base of BINFO. Note
6829 that in a complex hierarchy the resulting BINFO may not actually
6830 *be* primary. In particular if the resulting BINFO is a virtual
6831 base, and it occurs elsewhere in the hierarchy, then this
6832 occurrence may not actually be a primary base in the complete
6833 object. Check BINFO_PRIMARY_P to be sure. */
6835 tree
6837 tree binfo;
6838 {
6839 tree primary_base;
6841 tree virtuals;
6847 /* A non-virtual primary base is always a direct base, and easy to
6848 find. */
6850 {
6853 /* Scan the direct basetypes until we find a base with the same
6854 type as the primary base. */
6856 {
6862 }
6864 /* We should always find the primary base. */
6866 }
6868 /* For a primary virtual base, we have to scan the entire hierarchy
6869 rooted at BINFO; the virtual base could be an indirect virtual
6870 base. There could be more than one instance of the primary base
6871 in the hierarchy, and if one is the canonical binfo we want that
6872 one. If it exists, it should be the first one we find, but as a
6873 consistency check we find them all and make sure. */
6878 /* We must have found at least one instance. */
6882 {
6883 /* We found more than one instance of the base. We must make
6884 sure that, if one is the canonical one, it is the first one
6885 we found. As the chain is in reverse dfs order, that means
6886 the last on the list. */
6887 tree complete_binfo;
6888 tree canonical;
6898 {
6902 {
6903 /* This is the unshared instance. Make sure it was the
6904 first one found. */
6907 }
6908 }
6909 }
6910 else
6913 }
6915 /* If INDENTED_P is zero, indent to INDENT. Return non-zero. */
6917 static int
6922 {
6926 }
6928 /* Dump the offsets of all the bases rooted at BINFO (in the hierarchy
6929 dominated by T) to stderr. INDENT should be zero when called from
6930 the top level; it is incremented recursively. */
6932 static void
6936 tree t;
6937 tree binfo;
6939 {
6954 {
6960 else
6962 }
6967 {
6971 TFF_PLAIN_IDENTIFIER),
6973 }
6975 {
6978 }
6983 {
6987 {
6991 TFF_PLAIN_IDENTIFIER));
6992 }
6994 {
6998 TFF_PLAIN_IDENTIFIER));
6999 }
7001 {
7005 TFF_PLAIN_IDENTIFIER));
7006 }
7008 {
7012 TFF_PLAIN_IDENTIFIER));
7013 }
7017 }
7024 }
7026 /* Dump the BINFO hierarchy for T. */
7028 static void
7030 tree t;
7031 {
7045 }
7047 static void
7050 tree decl;
7051 {
7052 tree inits;
7054 HOST_WIDE_INT elt;
7062 TFF_PLAIN_IDENTIFIER));
7069 }
7071 static void
7073 tree t;
7074 tree binfo;
7075 tree vtable;
7076 {
7084 {
7091 {
7095 }
7099 }
7102 }
7104 static void
7106 tree t;
7107 tree vtt;
7108 {
7116 {
7121 }
7124 }
7126 /* Virtual function table initialization. */
7128 /* Create all the necessary vtables for T and its base classes. */
7130 static void
7132 tree t;
7133 {
7135 {
7136 tree list;
7137 tree vbase;
7139 /* Under the new ABI, we lay out the primary and secondary
7140 vtables in one contiguous vtable. The primary vtable is
7141 first, followed by the non-virtual secondary vtables in
7142 inheritance graph order. */
7146 /* Then come the virtual bases, also in inheritance graph
7147 order. */
7149 {
7150 tree real_base;
7155 /* Although we walk in inheritance order, that might not get the
7156 canonical base. */
7161 }
7165 }
7166 else
7167 {
7172 }
7173 }
7175 /* Called from finish_vtbls via dfs_walk. */
7177 static tree
7179 tree binfo;
7181 {
7192 }
7194 /* Initialize the vtable for BINFO with the INITS. */
7196 static void
7198 tree binfo;
7199 tree inits;
7200 {
7201 tree decl;
7207 }
7209 /* Initialize DECL (a declaration for a namespace-scope array) with
7210 the INITS. */
7212 static void
7214 tree decl;
7215 tree inits;
7216 {
7217 tree context;
7224 }
7226 /* Build the VTT (virtual table table) for T.
7227 A class requires a VTT if it has virtual bases.
7229 This holds
7230 1 - primary virtual pointer for complete object T
7231 2 - secondary VTTs for each direct non-virtual base of T which requires a VTT
7232 3 - secondary virtual pointers for each direct or indirect base of T which
7233 has virtual bases or is reachable via a virtual path from T.
7234 4 - secondary VTTs for each direct or indirect virtual base of T.
7236 Secondary VTTs look like complete object VTTs without part 4. */
7238 static void
7240 tree t;
7241 {
7242 tree inits;
7243 tree type;
7244 tree vtt;
7245 tree index;
7247 /* Build up the initializers for the VTT. */
7252 /* If we didn't need a VTT, we're done. */
7256 /* Figure out the type of the VTT. */
7260 /* Now, build the VTT object itself. */
7266 }
7268 /* The type corresponding to BASE_BINFO is a base of the type of BINFO, but
7269 from within some heirarchy which is inherited from the type of BINFO.
7270 Return BASE_BINFO's equivalent binfo from the hierarchy dominated by
7271 BINFO. */
7273 static tree
7275 tree base_binfo;
7276 tree binfo;
7277 {
7278 tree derived;
7293 }
7295 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
7296 PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
7297 and CHAIN the vtable pointer for this binfo after construction is
7298 complete. VALUE can also be another BINFO, in which case we recurse. */
7300 static tree
7302 tree binfo;
7303 {
7304 tree vt;
7307 {
7313 else
7315 }
7318 }
7320 /* Recursively build the VTT-initializer for BINFO (which is in the
7321 hierarchy dominated by T). INITS points to the end of the initializer
7322 list to date. INDEX is the VTT index where the next element will be
7323 replaced. Iff BINFO is the binfo for T, this is the top level VTT (i.e.
7324 not a subvtt for some base of T). When that is so, we emit the sub-VTTs
7325 for virtual bases of T. When it is not so, we build the constructor
7326 vtables for the BINFO-in-T variant. */
7330 tree binfo;
7331 tree t;
7334 {
7336 tree b;
7337 tree init;
7338 tree secondary_vptrs;
7341 /* We only need VTTs for subobjects with virtual bases. */
7345 /* We need to use a construction vtable if this is not the primary
7346 VTT. */
7348 {
7351 /* Record the offset in the VTT where this sub-VTT can be found. */
7353 }
7355 /* Add the address of the primary vtable for the complete object. */
7360 {
7363 }
7366 /* Recursively add the secondary VTTs for non-virtual bases. */
7368 {
7373 }
7375 /* Add secondary virtual pointers for all subobjects of BINFO with
7376 either virtual bases or reachable along a virtual path, except
7377 subobjects that are non-virtual primary bases. */
7384 dfs_build_secondary_vptr_vtt_inits,
7385 NULL,
7386 dfs_ctor_vtable_bases_queue_p,
7387 secondary_vptrs);
7390 secondary_vptrs);
7394 /* The secondary vptrs come back in reverse order. After we reverse
7395 them, and add the INITS, the last init will be the first element
7396 of the chain. */
7399 {
7403 }
7405 /* Add the secondary VTTs for virtual bases. */
7408 {
7409 tree vbase;
7416 }
7419 {
7425 dfs_ctor_vtable_bases_queue_p,
7426 data);
7427 }
7430 }
7432 /* Called from build_vtt_inits via dfs_walk. BINFO is the binfo
7433 for the base in most derived. DATA is a TREE_LIST who's
7434 TREE_CHAIN is the type of the base being
7435 constructed whilst this secondary vptr is live. The TREE_UNSIGNED
7436 flag of DATA indicates that this is a constructor vtable. The
7437 TREE_TOP_LEVEL flag indicates that this is the primary VTT. */
7439 static tree
7441 tree binfo;
7443 {
7444 tree l;
7445 tree t;
7446 tree init;
7447 tree index;
7456 /* We don't care about bases that don't have vtables. */
7460 /* We're only interested in proper subobjects of T. */
7464 /* We're not interested in non-virtual primary bases. */
7468 /* If BINFO has virtual bases or is reachable via a virtual path
7469 from T, it'll have a secondary vptr. */
7474 /* Record the index where this secondary vptr can be found. */
7477 {
7480 }
7484 /* Add the initializer for the secondary vptr itself. */
7486 {
7487 /* It's a primary virtual base, and this is not the construction
7488 vtable. Find the base this is primary of in the inheritance graph,
7489 and use that base's vtable now. */
7492 }
7497 }
7499 /* dfs_walk_real predicate for building vtables. DATA is a TREE_LIST,
7500 VTT_MARKED_BINFO_P indicates whether marked or unmarked bases
7501 should be walked. TREE_PURPOSE is the TREE_TYPE that dominates the
7502 hierarchy. */
7504 static tree
7506 tree binfo;
7508 {
7510 /* Get the shared version. */
7516 }
7518 /* Called from build_vtt_inits via dfs_walk. After building constructor
7519 vtables and generating the sub-vtt from them, we need to restore the
7520 BINFO_VTABLES that were scribbled on. DATA is a TREE_LIST whose
7521 TREE_VALUE is the TREE_TYPE of the base whose sub vtt was generated. */
7523 static tree
7525 tree binfo;
7527 {
7530 /* We don't care about bases that don't have vtables. */
7534 /* If we scribbled the construction vtable vptr into BINFO, clear it
7535 out now. */
7543 }
7545 /* Build the construction vtable group for BINFO which is in the
7546 hierarchy dominated by T. */
7548 static void
7550 tree binfo;
7551 tree t;
7552 {
7553 tree list;
7554 tree type;
7555 tree vtbl;
7556 tree inits;
7557 tree id;
7558 tree vbase;
7560 /* See if we've already created this construction vtable group. */
7566 /* Build a version of VTBL (with the wrong type) for use in
7567 constructing the addresses of secondary vtables in the
7568 construction vtable group. */
7574 /* Add the vtables for each of our virtual bases using the vbase in T
7575 binfo. */
7577 vbase;
7579 {
7580 tree b;
7581 tree orig_base;
7589 }
7592 /* Figure out the type of the construction vtable. */
7597 /* Initialize the construction vtable. */
7601 }
7603 /* Add the vtbl initializers for BINFO (and its bases other than
7604 non-virtual primaries) to the list of INITS. BINFO is in the
7605 hierarchy dominated by T. RTTI_BINFO is the binfo within T of
7606 the constructor the vtbl inits should be accumulated for. (If this
7607 is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
7608 ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
7609 BINFO is the active base equivalent of ORIG_BINFO in the inheritance
7610 graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
7611 but are not necessarily the same in terms of layout. */
7613 static void
7615 tree binfo;
7616 tree orig_binfo;
7617 tree rtti_binfo;
7618 tree t;
7619 tree inits;
7620 {
7628 /* If it doesn't have a vptr, we don't do anything. */
7632 /* If we're building a construction vtable, we're not interested in
7633 subobjects that don't require construction vtables. */
7639 /* Build the initializers for the BINFO-in-T vtable. */
7645 /* Walk the BINFO and its bases. We walk in preorder so that as we
7646 initialize each vtable we can figure out at what offset the
7647 secondary vtable lies from the primary vtable. We can't use
7648 dfs_walk here because we need to iterate through bases of BINFO
7649 and RTTI_BINFO simultaneously. */
7651 {
7654 /* Skip virtual bases. */
7660 inits);
7661 }
7662 }
7664 /* Called from accumulate_vtbl_inits when using the new ABI.
7665 Accumulates the vtable initializers for all of the vtables into
7666 TREE_VALUE (DATA). Returns the initializers for the BINFO vtable. */
7668 static tree
7670 tree binfo;
7671 tree orig_binfo;
7672 tree rtti_binfo;
7673 tree t;
7674 tree l;
7675 {
7682 {
7683 /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
7684 primary virtual base. If it is not the same primary in
7685 the hierarchy of T, we'll need to generate a ctor vtable
7686 for it, to place at its location in T. If it is the same
7687 primary, we still need a VTT entry for the vtable, but it
7688 should point to the ctor vtable for the base it is a
7689 primary for within the sub-hierarchy of RTTI_BINFO.
7691 There are three possible cases:
7693 1) We are in the same place.
7694 2) We are a primary base within a lost primary virtual base of
7695 RTTI_BINFO.
7696 3) We are primary to something not a base of RTTI_BINFO. */
7701 /* First, look through the bases we are primary to for RTTI_BINFO
7702 or a virtual base. */
7704 {
7708 }
7709 /* If we run out of primary links, keep looking down our
7710 inheritance chain; we might be an indirect primary. */
7716 /* If we found RTTI_BINFO, this is case 1. If we found a virtual
7717 base B and it is a base of RTTI_BINFO, this is case 2. In
7718 either case, we share our vtable with LAST, i.e. the
7719 derived-most base within B of which we are a primary. */
7723 /* Just set our BINFO_VTABLE to point to LAST, as we may not have
7724 set LAST's BINFO_VTABLE yet. We'll extract the actual vptr in
7725 binfo_ctor_vtable after everything's been set up. */
7728 /* Otherwise, this is case 3 and we get our own. */
7729 }
7734 {
7735 tree index;
7738 /* Compute the initializer for this vtable. */
7742 /* Figure out the position to which the VPTR should point. */
7745 vtbl_ptr_type_node,
7746 vtbl);
7752 index);
7755 }
7758 /* For a construction vtable, we can't overwrite BINFO_VTABLE.
7759 So, we make a TREE_LIST. Later, dfs_fixup_binfo_vtbls will
7760 straighten this out. */
7764 else
7765 /* For an ordinary vtable, set BINFO_VTABLE. */
7769 }
7771 /* Construct the initializer for BINFOs virtual function table. BINFO
7772 is part of the hierarchy dominated by T. If we're building a
7773 construction vtable, the ORIG_BINFO is the binfo we should use to
7774 find the actual function pointers to put in the vtable - but they
7775 can be overridden on the path to most-derived in the graph that
7776 ORIG_BINFO belongs. Otherwise,
7777 ORIG_BINFO should be the same as BINFO. The RTTI_BINFO is the
7778 BINFO that should be indicated by the RTTI information in the
7779 vtable; it will be a base class of T, rather than T itself, if we
7780 are building a construction vtable.
7782 The value returned is a TREE_LIST suitable for wrapping in a
7783 CONSTRUCTOR to use as the DECL_INITIAL for a vtable. If
7784 NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
7785 number of non-function entries in the vtable.
7787 It might seem that this function should never be called with a
7788 BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
7789 base is always subsumed by a derived class vtable. However, when
7790 we are building construction vtables, we do build vtables for
7791 primary bases; we need these while the primary base is being
7792 constructed. */
7794 static tree
7796 tree binfo;
7797 tree orig_binfo;
7798 tree t;
7799 tree rtti_binfo;
7801 {
7803 tree vfun_inits;
7804 tree vbase;
7805 vtbl_init_data vid;
7807 /* Initialize VID. */
7815 /* The first vbase or vcall offset is at index -3 in the vtable. */
7818 /* Add entries to the vtable for RTTI. */
7821 /* Create an array for keeping track of the functions we've
7822 processed. When we see multiple functions with the same
7823 signature, we share the vcall offsets. */
7825 /* Add the vcall and vbase offset entries. */
7827 /* Clean up. */
7829 /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
7830 build_vbase_offset_vtbl_entries. */
7832 vbase;
7839 /* Go through all the ordinary virtual functions, building up
7840 initializers. */
7843 {
7844 tree delta;
7845 tree vcall_index;
7846 tree fn;
7847 tree pfn;
7848 tree init;
7850 /* Pull the offset for `this', and the function to call, out of
7851 the list. */
7855 {
7858 }
7859 else
7866 /* You can't call an abstract virtual function; it's abstract.
7867 So, we replace these functions with __pure_virtual. */
7871 /* Take the address of the function, considering it to be of an
7872 appropriate generic type. */
7874 /* The address of a function can't change. */
7877 /* Enter it in the vtable. */
7880 /* If the only definition of this function signature along our
7881 primary base chain is from a lost primary, this vtable slot will
7882 never be used, so just zero it out. This is important to avoid
7883 requiring extra thunks which cannot be generated with the function.
7885 We could also handle this in update_vtable_entry_for_fn; doing it
7886 here means we zero out unused slots in ctor vtables as well,
7887 rather than filling them with erroneous values (though harmless,
7888 apart from relocation costs). */
7891 {
7892 /* We found a defn before a lost primary; go ahead as normal. */
7896 /* The nearest definition is from a lost primary; clear the
7897 slot. */
7899 {
7902 }
7903 }
7905 /* And add it to the chain of initializers. */
7907 {
7912 else
7914 {
7921 }
7922 }
7923 else
7925 }
7927 /* The initializers for virtual functions were built up in reverse
7928 order; straighten them out now. */
7931 /* The negative offset initializers are also in reverse order. */
7934 /* Chain the two together. */
7936 }
7938 /* Adds to vid->inits the initializers for the vbase and vcall
7939 offsets in BINFO, which is in the hierarchy dominated by T. */
7941 static void
7943 tree binfo;
7945 {
7946 tree b;
7948 /* If this is a derived class, we must first create entries
7949 corresponding to the primary base class. */
7954 /* Add the vbase entries for this base. */
7956 /* Add the vcall entries for this base. */
7958 }
7960 /* Returns the initializers for the vbase offset entries in the vtable
7961 for BINFO (which is part of the class hierarchy dominated by T), in
7962 reverse order. VBASE_OFFSET_INDEX gives the vtable index
7963 where the next vbase offset will go. */
7965 static void
7967 tree binfo;
7969 {
7970 tree vbase;
7971 tree t;
7972 tree non_primary_binfo;
7974 /* Under the old ABI, pointers to virtual bases are stored in each
7975 object. */
7979 /* If there are no virtual baseclasses, then there is nothing to
7980 do. */
7986 /* We might be a primary base class. Go up the inheritance hierarchy
7987 until we find the most derived class of which we are a primary base:
7988 it is the offset of that which we need to use. */
7991 {
7992 tree b;
7994 /* If we have reached a virtual base, then it must be a primary
7995 base (possibly multi-level) of vid->binfo, or we wouldn't
7996 have called build_vcall_and_vbase_vtbl_entries for it. But it
7997 might be a lost primary, so just skip down to vid->binfo. */
7999 {
8002 }
8008 }
8010 /* Go through the virtual bases, adding the offsets. */
8012 vbase;
8014 {
8015 tree b;
8016 tree delta;
8021 /* Find the instance of this virtual base in the complete
8022 object. */
8025 /* If we've already got an offset for this virtual base, we
8026 don't need another one. */
8031 /* Figure out where we can find this vbase offset. */
8040 {
8041 tree orig_vbase;
8043 /* Find the instance of this virtual base in the type of BINFO. */
8047 /* The vbase offset had better be the same. */
8051 }
8053 /* The next vbase will come at a more negative offset. */
8056 /* The initializer is the delta from BINFO to this virtual base.
8057 The vbase offsets go in reverse inheritance-graph order, and
8058 we are walking in inheritance graph order so these end up in
8059 the right order. */
8065 vtable_entry_type,
8066 delta)));
8068 }
8069 }
8071 /* Adds the initializers for the vcall offset entries in the vtable
8072 for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
8073 to VID->INITS. */
8075 static void
8077 tree binfo;
8079 {
8080 /* Under the old ABI, the adjustments to the `this' pointer were made
8081 elsewhere. */
8085 /* We only need these entries if this base is a virtual base. */
8089 /* We need a vcall offset for each of the virtual functions in this
8090 vtable. For example:
8092 class A { virtual void f (); };
8093 class B1 : virtual public A { virtual void f (); };
8094 class B2 : virtual public A { virtual void f (); };
8095 class C: public B1, public B2 { virtual void f (); };
8097 A C object has a primary base of B1, which has a primary base of A. A
8098 C also has a secondary base of B2, which no longer has a primary base
8099 of A. So the B2-in-C construction vtable needs a secondary vtable for
8100 A, which will adjust the A* to a B2* to call f. We have no way of
8101 knowing what (or even whether) this offset will be when we define B2,
8102 so we store this "vcall offset" in the A sub-vtable and look it up in
8103 a "virtual thunk" for B2::f.
8105 We need entries for all the functions in our primary vtable and
8106 in our non-virtual bases' secondary vtables. */
8108 /* Now, walk through the non-virtual bases, adding vcall offsets. */
8110 }
8112 /* Build vcall offsets, starting with those for BINFO. */
8114 static void
8116 tree binfo;
8118 {
8120 tree primary_binfo;
8122 /* Don't walk into virtual bases -- except, of course, for the
8123 virtual base for which we are building vcall offsets. Any
8124 primary virtual base will have already had its offsets generated
8125 through the recursion in build_vcall_and_vbase_vtbl_entries. */
8129 /* If BINFO has a primary base, process it first. */
8134 /* Add BINFO itself to the list. */
8137 /* Scan the non-primary bases of BINFO. */
8139 {
8140 tree base_binfo;
8145 }
8146 }
8148 /* Called from build_vcall_offset_vtbl_entries_r. */
8150 static void
8152 tree binfo;
8154 {
8155 tree derived_virtuals;
8156 tree base_virtuals;
8157 tree orig_virtuals;
8158 tree binfo_inits;
8159 /* If BINFO is a primary base, the most derived class which has BINFO as
8160 a primary base; otherwise, just BINFO. */
8161 tree non_primary_binfo;
8165 /* We might be a primary base class. Go up the inheritance hierarchy
8166 until we find the most derived class of which we are a primary base:
8167 it is the BINFO_VIRTUALS there that we need to consider. */
8170 {
8171 tree b;
8173 /* If we have reached a virtual base, then it must be vid->vbase,
8174 because we ignore other virtual bases in
8175 add_vcall_offset_vtbl_entries_r. In turn, it must be a primary
8176 base (possibly multi-level) of vid->binfo, or we wouldn't
8177 have called build_vcall_and_vbase_vtbl_entries for it. But it
8178 might be a lost primary, so just skip down to vid->binfo. */
8180 {
8185 }
8191 }
8194 /* For a ctor vtable we need the equivalent binfo within the hierarchy
8195 where rtti_binfo is the most derived type. */
8196 non_primary_binfo = get_original_base
8199 /* Make entries for the rest of the virtuals. */
8203 base_virtuals;
8207 {
8208 tree orig_fn;
8209 tree fn;
8210 tree base;
8211 tree base_binfo;
8213 tree vcall_offset;
8215 /* Find the declaration that originally caused this function to
8216 be present in BINFO_TYPE (binfo). */
8219 /* When processing BINFO, we only want to generate vcall slots for
8220 function slots introduced in BINFO. So don't try to generate
8221 one if the function isn't even defined in BINFO. */
8225 /* Find the overriding function. */
8228 /* If there is already an entry for a function with the same
8229 signature as FN, then we do not need a second vcall offset.
8230 Check the list of functions already present in the derived
8231 class vtable. */
8233 {
8234 tree derived_entry;
8238 /* We only use one vcall offset for virtual destructors,
8239 even though there are two virtual table entries. */
8242 {
8247 }
8248 }
8252 /* The FN comes from BASE. So, we must calculate the adjustment from
8253 vid->vbase to BASE. We can just look for BASE in the complete
8254 object because we are converting from a virtual base, so if there
8255 were multiple copies, there would not be a unique final overrider
8256 and vid->derived would be ill-formed. */
8260 /* Compute the vcall offset. */
8261 /* As mentioned above, the vbase we're working on is a primary base of
8262 vid->binfo. But it might be a lost primary, so its BINFO_OFFSET
8263 might be wrong, so we just use the BINFO_OFFSET from vid->binfo. */
8266 vcall_offset);
8268 vcall_offset));
8273 /* Keep track of the vtable index where this vcall offset can be
8274 found. For a construction vtable, we already made this
8275 annotation when we built the original vtable. */
8279 /* The next vcall offset will be found at a more negative
8280 offset. */
8283 /* Keep track of this function. */
8285 }
8286 }
8288 /* Return vtbl initializers for the RTTI entries coresponding to the
8289 BINFO's vtable. The RTTI entries should indicate the object given
8290 by VID->rtti_binfo. */
8292 static void
8294 tree binfo;
8296 {
8297 tree b;
8298 tree t;
8299 tree basetype;
8300 tree offset;
8301 tree decl;
8302 tree init;
8307 /* For a COM object there is no RTTI entry. */
8311 /* To find the complete object, we will first convert to our most
8312 primary base, and then add the offset in the vtbl to that value. */
8316 {
8317 tree primary_base;
8322 }
8325 /* The second entry is the address of the typeinfo object. */
8328 else
8331 /* Convert the declaration to a type that can be stored in the
8332 vtable. */
8338 /* Add the offset-to-top entry. It comes earlier in the vtable that
8339 the the typeinfo entry. */
8341 {
8342 /* Convert the offset to look like a function pointer, so that
8343 we can put it in the vtable. */
8348 }
8349 }
8351 /* Build an entry in the virtual function table. DELTA is the offset
8352 for the `this' pointer. VCALL_INDEX is the vtable index containing
8353 the vcall offset; NULL_TREE if none. ENTRY is the virtual function
8354 table entry itself. It's TREE_TYPE must be VFUNC_PTR_TYPE_NODE,
8355 but it may not actually be a virtual function table pointer. (For
8356 example, it might be the address of the RTTI object, under the new
8357 ABI.) */
8359 static tree
8361 tree delta;
8362 tree vcall_index;
8363 tree entry;
8364 {
8366 {
8367 tree fn;
8373 {
8378 }
8379 #ifdef GATHER_STATISTICS
8381 #endif
8383 }
8384 else
8385 {
8391 /* We don't use vcall offsets when not using vtable thunks. */
8394 /* DELTA used to be constructed by `size_int' and/or size_binop,
8395 which caused overflow problems when it was negative. That should
8396 be fixed now. */
8399 {
8402 else
8403 sorry ("object size exceeds normal limit for virtual function table implementation, recompile all source and use -fhuge-objects");
8404 }
8410 #ifdef GATHER_STATISTICS
8412 #endif
8415 }
8416 }