| blob | 2d8ab83dee2aa55a19135e7f49057bfb0cea62ed |
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 binfo for the most-derived type. */
70 tree derived;
71 /* The negative-index vtable initializers built up so far. These
72 are in order from least negative index to most negative index. */
73 tree inits;
74 /* The last (i.e., most negative entry in INITS. */
76 /* The binfo for the virtual base for which we're building
77 vcall offset initializers. */
78 tree vbase;
79 /* The functions in vbase for which we have already provided vcall
80 offsets. */
81 varray_type fns;
82 /* The vtable index of the next vcall or vbase offset. */
83 tree index;
84 /* Nonzero if we are building the initializer for the primary
85 vtable. */
87 /* Nonzero if we are building the initializer for a construction
88 vtable. */
92 /* The type of a function passed to walk_subobject_offsets. */
95 /* The stack itself. This is an dynamically resized array. The
96 number of elements allocated is CURRENT_CLASS_STACK_SIZE. */
100 /* An array of all local classes present in this translation unit, in
101 declaration order. */
102 varray_type local_classes;
146 splay_tree));
148 splay_tree));
179 splay_tree));
184 tree));
188 vtbl_init_data *));
212 splay_tree_key k2));
215 /* Macros for dfs walking during vtt construction. See
216 dfs_ctor_vtable_bases_queue_p, dfs_build_secondary_vptr_vtt_inits
217 and dfs_fixup_binfo_vtbls. */
218 #define VTT_TOP_LEVEL_P(node) TREE_UNSIGNED(node)
219 #define VTT_MARKED_BINFO_P(node) TREE_USED(node)
221 /* Variables shared between class.c and call.c. */
223 #ifdef GATHER_STATISTICS
232 #endif
234 /* Virtual base class layout. */
236 /* Returns a list of virtual base class pointers as a chain of
237 FIELD_DECLS. */
239 static tree
241 record_layout_info rli;
243 {
244 /* Chain to hold all the new FIELD_DECLs which point at virtual
245 base classes. */
250 tree decl;
253 /* Under the new ABI, there are no vbase pointers in the object.
254 Instead, the offsets are stored in the vtable. */
258 /* Loop over the baseclasses, adding vbase pointers as needed. */
260 {
265 /* This error is now reported in xref_tag, thus giving better
266 location information. */
269 /* All basetypes are recorded in the association list of the
270 derived type. */
273 {
277 /* The offset for a virtual base class is only used in computing
278 virtual function tables and for initializing virtual base
279 pointers. It is built once `get_vbase_types' is called. */
281 /* If this basetype can come from another vbase pointer
282 without an additional indirection, we will share
283 that pointer. If an indirection is involved, we
284 make our own pointer. */
286 {
291 }
296 rec,
297 basetype,
298 empty_p);
305 got_it:
306 /* The space this decl occupies has already been accounted for. */
307 ;
308 }
309 }
312 }
314 /* Returns a pointer to the virtual base class of EXP that has the
315 indicated TYPE. EXP is of class type, not a pointer type. */
317 static tree
320 {
322 {
323 tree vbase;
324 tree vbase_ptr;
326 /* Find the shared copy of TYPE; that's where the vtable offset
327 is recorded. */
329 /* Find the virtual function table pointer. */
331 /* Compute the location where the offset will lie. */
334 vbase_ptr,
338 vbase_ptr);
339 /* Add the contents of this location to EXP. */
344 }
345 else
346 {
350 }
351 }
353 /* Build multi-level access to EXPR using hierarchy path PATH.
354 CODE is PLUS_EXPR if we are going with the grain,
355 and MINUS_EXPR if we are not (in which case, we cannot traverse
356 virtual baseclass links).
358 TYPE is the type we want this path to have on exit.
360 NONNULL is non-zero if we know (for any reason) that EXPR is
361 not, in fact, zero. */
363 tree
368 {
373 tree basetype;
379 /* We could do better if we had additional logic to convert back to the
380 unconverted type (the static type of the complete object), and then
381 convert back to the type we want. Until that is done, we only optimize
382 if the complete type is the same type as expr has. */
394 {
396 {
399 {
403 {
404 tree ind;
406 /* We already check for ambiguous things in the caller, just
407 find a path. */
409 {
412 }
418 {
422 integer_zero_node),
424 }
425 }
426 /* else we'll figure out the offset below. */
428 /* Happens in the case of parse errors. */
431 }
432 else
433 {
435 last_virtual);
437 }
438 }
441 }
442 /* LAST is now the last basetype assoc on the path. */
444 /* A pointer to a virtual base member of a non-null object
445 is non-null. Therefore, we only need to test for zeroness once.
446 Make EXPR the canonical expression to deal with here. */
448 {
452 }
453 else
456 /* If we go through any virtual base pointers, make sure that
457 casts to BASETYPE from the last virtual base class use
458 the right value for BASETYPE. */
460 {
464 offset
466 }
467 else
471 {
472 /* Bash types to make the backend happy. */
475 /* If expr might be 0, we need to preserve that zeroness. */
477 {
480 else
487 null_expr,
489 }
491 }
493 /* Cannot change the TREE_TYPE of a NOP_EXPR here, since it may
494 be used multiple times in initialization of multiple inheritance. */
496 {
499 }
500 else
502 }
504 \f
505 /* Virtual function things. */
507 /* We want to give the assembler the vtable identifier as well as
508 the offset to the function pointer. So we generate
510 __asm__ __volatile__ (".vtable_entry %c0, %c1"
511 : : "s"(&class_vtable),
512 "i"((long)&vtbl[idx].pfn - (long)&vtbl[0])); */
514 static void
517 {
538 }
540 /* Given an object INSTANCE, return an expression which yields the
541 virtual function vtable element corresponding to INDEX. There are
542 many special cases for INSTANCE which we take care of here, mainly
543 to avoid creating extra tree nodes when we don't have to. */
545 tree
548 {
557 else
558 {
560 {
561 /* Try to figure out what a reference refers to, and
562 access its virtual function table directly. */
573 {
580 {
586 }
587 }
588 }
594 {
596 /* Knowing the dynamic type of INSTANCE we can easily obtain
597 the correct vtable entry. In the new ABI, we resolve
598 this back to be in terms of the primary vtable. */
600 {
603 idx,
609 }
610 }
611 else
613 }
623 }
625 /* Given an object INSTANCE, return an expression which yields the
626 virtual function corresponding to INDEX. There are many special
627 cases for INSTANCE which we take care of here, mainly to avoid
628 creating extra tree nodes when we don't have to. */
630 tree
633 tree idx;
634 {
637 /* When using thunks, there is no extra delta, and we get the pfn
638 directly. */
643 {
644 /* Save the intermediate result in a SAVE_EXPR so we don't have to
645 compute each component of the virtual function pointer twice. */
649 *ptr_to_instptr
654 }
657 }
659 /* Return the name of the virtual function table (as an IDENTIFIER_NODE)
660 for the given TYPE. */
662 static tree
664 tree type;
665 {
667 }
669 /* Return an IDENTIFIER_NODE for the name of the virtual table table
670 for TYPE. */
672 tree
674 tree type;
675 {
677 }
679 /* Return the offset to the main vtable for a given base BINFO. */
681 tree
683 tree binfo;
684 {
685 return
688 }
690 /* Get the offset to the start of the original binfo that we derived
691 this binfo from. If we find TYPE first, return the offset only
692 that far. The shortened search is useful because the this pointer
693 on method calling is expected to point to a DECL_CONTEXT (fndecl)
694 object, and not a baseclass of it. */
696 static tree
699 {
701 tree offset2;
708 }
710 /* Create a VAR_DECL for a primary or secondary vtable for CLASS_TYPE.
711 (For a secondary vtable for B-in-D, CLASS_TYPE should be D, not B.)
712 Use NAME for the name of the vtable, and VTABLE_TYPE for its type. */
714 static tree
716 tree class_type;
717 tree name;
718 tree vtable_type;
719 {
720 tree decl;
726 #ifndef WRITABLE_VTABLES
727 /* Make them READONLY by default. (mrs) */
729 #endif
734 }
736 /* Get the VAR_DECL of the vtable for TYPE. TYPE need not be polymorphic,
737 or even complete. If this does not exist, create it. If COMPLETE is
738 non-zero, then complete the definition of it -- that will render it
739 impossible to actually build the vtable, but is useful to get at those
740 which are known to exist in the runtime. */
742 tree
744 tree type;
746 {
751 {
755 }
762 /* At one time the vtable info was grabbed 2 words at a time. This
763 fails on sparc unless you have 8-byte alignment. (tiemann) */
768 {
771 }
774 }
776 /* Returns a copy of the BINFO_VIRTUALS list in BINFO. The
777 BV_VCALL_INDEX for each entry is cleared. */
779 static tree
781 tree binfo;
782 {
783 tree copies;
784 tree t;
788 {
792 }
795 }
797 /* Build the primary virtual function table for TYPE. If BINFO is
798 non-NULL, build the vtable starting with the initial approximation
799 that it is the same as the one which is the head of the association
800 list. Returns a non-zero value if a new vtable is actually
801 created. */
803 static int
806 {
807 tree decl;
808 tree virtuals;
813 {
815 /* We have already created a vtable for this base, so there's
816 no need to do it again. */
823 }
824 else
825 {
829 }
831 #ifdef GATHER_STATISTICS
834 #endif
836 /* Initialize the association list for this type, based
837 on our first approximation. */
842 }
844 /* Give TYPE a new virtual function table which is initialized
845 with a skeleton-copy of its original initialization. The only
846 entry that changes is the `delta' entry, so we can really
847 share a lot of structure.
849 FOR_TYPE is the derived type which caused this table to
850 be needed.
852 BINFO is the type association which provided TYPE for FOR_TYPE.
854 The order in which vtables are built (by calling this function) for
855 an object must remain the same, otherwise a binary incompatibility
856 can result. */
858 static int
861 {
862 tree basetype;
864 tree name;
865 tree new_decl;
866 tree offset;
873 #ifdef JOINER
875 #endif
879 current_class_type),
883 /* We already created a vtable for this base. There's no need to
884 do it again. */
887 /* Remember that we've created a vtable for this BINFO, so that we
888 don't try to do so again. */
891 /* Make fresh virtual list, so we can smash it later. */
895 {
898 /* XXX - This should never happen, if it does, the caller should
899 ensure that the binfo is from for_type's binfos, not from any
900 base type's. We can remove all this code after a while. */
905 }
906 else
909 /* In the new ABI, secondary vtables are laid out as part of the
910 same structure as the primary vtable. */
912 {
915 }
917 /* Create the declaration for the secondary vtable. */
922 /* We know that the vtable that we are going to create doesn't exist
923 yet in the global namespace, and when we finish, it will be
924 pushed into the global namespace. In complex MI hierarchies, we
925 have to loop while the name we are thinking of adding is globally
926 defined, adding more name components to the vtable name as we
927 loop, until the name is unique. This is because in complex MI
928 cases, we might have the same base more than once. This means
929 that the order in which this function is called for vtables must
930 remain the same, otherwise binary compatibility can be
931 compromised. */
934 {
940 buf2);
945 /* If this name doesn't clash, then we can use it, otherwise
946 we add more to the name until it is unique. */
951 /* Set values for next loop through, if the name isn't unique. */
955 /* We better not run out of stuff to make it unique. */
961 {
962 /* If we run out of basetypes in the path, we have already
963 found created a vtable with that name before, we now
964 resort to tacking on _%d to distinguish them. */
977 /* If this name doesn't clash, then we can use it,
978 otherwise we add something different to the name until
979 it is unique. */
982 /* Hey, they really like MI don't they? Increase the 3
983 above to 6, and the 999 to 999999. :-) */
987 }
994 }
1001 #ifdef GATHER_STATISTICS
1004 #endif
1007 }
1009 /* Create a new vtable for BINFO which is the hierarchy dominated by
1010 T. */
1012 static int
1014 tree t;
1015 tree binfo;
1016 {
1018 /* In this case, it is *type*'s vtable we are modifying. We start
1019 with the approximation that it's vtable is that of the
1020 immediate base class. */
1022 t);
1023 else
1024 /* This is our very own copy of `basetype' to play with. Later,
1025 we will fill in all the virtual functions that override the
1026 virtual functions in these base classes which are not defined
1027 by the current type. */
1029 }
1031 /* Make *VIRTUALS, an entry on the BINFO_VIRTUALS list for BINFO
1032 (which is in the hierarchy dominated by T) list FNDECL as its
1033 BV_FN. DELTA is the required constant adjustment from the `this'
1034 pointer where the vtable entry appears to the `this' required when
1035 the function is actually called. */
1037 static void
1039 tree t;
1040 tree binfo;
1041 tree fndecl;
1042 tree delta;
1044 {
1045 tree v;
1051 {
1052 tree base_fndecl;
1054 /* We need a new vtable for BINFO. */
1056 {
1057 /* If we really did make a new vtable, we also made a copy
1058 of the BINFO_VIRTUALS list. Now, we have to find the
1059 corresponding entry in that list. */
1064 }
1071 /* Now assign virtual dispatch information, if unset. We can
1072 dispatch this, through any overridden base function. */
1074 {
1077 }
1078 }
1079 }
1081 /* Set DECL_VINDEX for DECL. VINDEX_P is the number of virtual
1082 functions present in the vtable so far. */
1084 static void
1086 tree decl;
1088 {
1093 }
1095 /* Add a virtual function to all the appropriate vtables for the class
1096 T. DECL_VINDEX(X) should be error_mark_node, if we want to
1097 allocate a new slot in our table. If it is error_mark_node, we
1098 know that no other function from another vtable is overridden by X.
1099 VFUNS_P keeps track of how many virtuals there are in our
1100 main vtable for the type, and we build upon the NEW_VIRTUALS list
1101 and return it. */
1103 static void
1109 tree fndecl;
1111 {
1112 tree new_virtual;
1114 /* If this function doesn't override anything from a base class, we
1115 can just assign it a new DECL_VINDEX now. Otherwise, if it does
1116 override something, we keep it around and assign its DECL_VINDEX
1117 later, in modify_all_vtables. */
1119 /* We've already dealt with this function. */
1127 {
1128 /* FNDECL is a new virtual function; it doesn't override any
1129 virtual function in a base class. */
1131 /* We remember that this was the base sub-object for rtti. */
1134 /* Now assign virtual dispatch information. */
1138 /* Save the state we've computed on the NEW_VIRTUALS list. */
1141 }
1142 else
1143 {
1144 /* FNDECL overrides a function from a base class. */
1147 }
1148 }
1149 \f
1150 /* Add method METHOD to class TYPE. If ERROR_P is true, we are adding
1151 the method after the class has already been defined because a
1152 declaration for it was seen. (Even though that is erroneous, we
1153 add the method for improved error recovery.) */
1155 void
1157 tree type;
1158 tree method;
1160 {
1164 tree method_vec;
1167 /* Make a new method vector. We start with 8 entries. We must
1168 allocate at least two (for constructors and destructors), and
1169 we're going to end up with an assignment operator at some point
1170 as well.
1172 We could use a TREE_LIST for now, and convert it to a TREE_VEC
1173 in finish_struct, but we would probably waste more memory
1174 making the links in the list than we would by over-allocating
1175 the size of the vector here. Furthermore, we would complicate
1176 all the code that expects this to be a vector. */
1182 /* Constructors and destructors go in special slots. */
1187 else
1188 {
1189 /* See if we already have an entry with this name. */
1193 slot)))
1198 {
1199 /* We need a bigger method vector. */
1201 tree new_vec;
1203 /* In the non-error case, we are processing a class
1204 definition. Double the size of the vector to give room
1205 for new methods. */
1208 /* In the error case, the vector is already complete. We
1209 don't expect many errors, and the rest of the front-end
1210 will get confused if there are empty slots in the vector. */
1211 else
1220 }
1223 {
1224 /* Type conversion operators have to come before ordinary
1225 methods; add_conversions depends on this to speed up
1226 looking for conversion operators. So, if necessary, we
1227 slide some of the vector elements up. In theory, this
1228 makes this algorithm O(N^2) but we don't expect many
1229 conversion operators. */
1231 {
1235 /* There are no more entries in the vector, so we
1236 can insert the new conversion operator here. */
1240 /* We can insert the new function right at the
1241 SLOTth position. */
1243 }
1246 /* There is nothing in the Ith slot, so we can avoid
1247 moving anything. */
1248 ;
1249 else
1250 {
1251 /* We know the last slot in the vector is empty
1252 because we know that at this point there's room
1253 for a new function. */
1258 }
1259 }
1260 }
1263 /* TYPE is a template class. Don't issue any errors now; wait
1264 until instantiation time to complain. */
1265 ;
1266 else
1267 {
1268 tree fns;
1270 /* Check to see if we've already got this method. */
1272 fns;
1274 {
1281 {
1282 /* [over.load] Member function declarations with the
1283 same name and the same parameter types cannot be
1284 overloaded if any of them is a static member
1285 function declaration. */
1289 {
1299 {
1301 /* Defer to the local function. */
1303 else
1306 }
1307 }
1309 /* Since this is an ordinary function in a
1310 non-template class, it's mangled name can be used
1311 as a unique identifier. This technique is only
1312 an optimization; we would get the same results if
1313 we just used decls_match here. */
1317 }
1321 /* There has already been a declaration of this method
1322 or member template. */
1326 /* We don't call duplicate_decls here to merge the
1327 declarations because that will confuse things if the
1328 methods have inline definitions. In particular, we
1329 will crash while processing the definitions. */
1331 }
1332 }
1334 /* Actually insert the new method. */
1338 /* Add the new binding. */
1343 }
1345 /* Subroutines of finish_struct. */
1347 /* Look through the list of fields for this struct, deleting
1348 duplicates as we go. This must be recursive to handle
1349 anonymous unions.
1351 FIELD is the field which may not appear anywhere in FIELDS.
1352 FIELD_PTR, if non-null, is the starting point at which
1353 chained deletions may take place.
1354 The value returned is the first acceptable entry found
1355 in FIELDS.
1357 Note that anonymous fields which are not of UNION_TYPE are
1358 not duplicates, they are just anonymous fields. This happens
1359 when we have unnamed bitfields, for example. */
1361 static tree
1364 {
1365 tree x;
1368 {
1375 }
1376 else
1377 {
1379 {
1381 {
1387 {
1390 else
1392 }
1393 }
1395 /* A using declaration may is allowed to appear more than
1396 once. We'll prune these from the field list later, and
1397 handle_using_decl will complain about invalid multiple
1398 uses. */
1399 ;
1401 {
1408 x);
1411 {
1415 }
1418 {
1419 /* Hide tag decls. */
1426 x);
1427 }
1428 else
1432 else
1434 }
1435 }
1436 }
1438 }
1440 static void
1442 tree fields;
1443 {
1444 tree x;
1447 }
1449 /* Change the access of FDECL to ACCESS in T. Return 1 if change was
1450 legit, otherwise return 0. */
1452 static int
1454 tree t;
1455 tree fdecl;
1456 tree access;
1457 {
1458 tree elem;
1465 {
1467 {
1470 else
1473 }
1474 else
1475 {
1476 /* They're changing the access to the same thing they changed
1477 it to before. That's OK. */
1478 ;
1479 }
1480 }
1481 else
1482 {
1486 }
1488 }
1490 /* Process the USING_DECL, which is a member of T. */
1492 static void
1494 tree using_decl;
1495 tree t;
1496 {
1499 tree access
1505 tree old_value;
1513 {
1516 }
1519 {
1522 }
1527 {
1530 }
1533 /* Ignore base type this came from. */
1538 {
1544 else
1546 }
1552 ;
1554 {
1556 /* It's OK to use functions from a base when there are functions with
1558 else
1559 {
1564 }
1565 }
1567 {
1571 }
1573 /* Make type T see field decl FDECL with access ACCESS.*/
1576 {
1579 }
1580 else
1582 }
1583 \f
1584 /* Run through the base clases of T, updating
1585 CANT_HAVE_DEFAULT_CTOR_P, CANT_HAVE_CONST_CTOR_P, and
1586 NO_CONST_ASN_REF_P. Also set flag bits in T based on properties of
1587 the bases. */
1589 static void
1591 no_const_asn_ref_p)
1592 tree t;
1596 {
1600 tree binfos;
1606 /* An aggregate cannot have baseclasses. */
1610 {
1611 tree base_binfo;
1612 tree basetype;
1614 /* Figure out what base we're looking at. */
1618 /* If the type of basetype is incomplete, then we already
1619 complained about that fact (and we should have fixed it up as
1620 well). */
1622 {
1624 /* The base type is of incomplete type. It is
1625 probably best to pretend that it does not
1626 exist. */
1634 }
1636 /* Effective C++ rule 14. We only need to check TYPE_POLYMORPHIC_P
1637 here because the case of virtual functions but non-virtual
1638 dtor is handled in finish_struct_1. */
1642 basetype);
1644 /* If the base class doesn't have copy constructors or
1645 assignment operators that take const references, then the
1646 derived class cannot have such a member automatically
1647 generated. */
1653 /* Similarly, if the base class doesn't have a default
1654 constructor, then the derived class won't have an
1655 automatically generated default constructor. */
1658 {
1662 basetype);
1663 }
1665 /* If the base class is not empty or nearly empty, then this
1666 class cannot be nearly empty. */
1669 /* And if there is more than one nearly empty base, then the
1670 derived class is not nearly empty either. */
1674 /* If this is the first nearly empty base class, then remember
1675 that we saw it. */
1679 /* A lot of properties from the bases also apply to the derived
1680 class. */
1692 /* Derived classes can implicitly become COMified if their bases
1693 are COM. */
1697 {
1698 cp_error
1702 }
1703 }
1704 }
1706 /* Binfo FROM is within a virtual heirarchy which is being reseated to
1707 TO. Move primary information from FROM to TO, and recursively traverse
1708 into FROM's bases. The heirarchy is dominated by TYPE. MAPPINGS is an
1709 assoc list of binfos that have already been reseated. */
1711 static void
1713 tree to;
1714 tree from;
1715 tree type;
1716 tree mappings;
1717 {
1724 {
1726 tree assoc;
1728 /* We might have just moved the primary base too, see if it's on our
1729 mappings. */
1735 }
1739 {
1744 {
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 {
1776 }
1778 /* Make BASE_BINFO the primary virtual base of BINFO within the hierarchy
1779 dominated by TYPE. Returns BASE_BINFO, if it can be made so, NULL
1780 otherwise (because something else has already made it primary). */
1782 static tree
1784 tree binfo;
1785 tree base_binfo;
1786 tree type;
1787 {
1789 tree delta;
1792 {
1793 /* It's already allocated in the hierarchy. BINFO won't have a
1794 primary base in this hierachy, even though the complete object
1795 BINFO is for, would do. */
1799 }
1801 /* We need to make sure that the assoc list
1802 CLASSTYPE_VBASECLASSES of TYPE, indicates this particular
1803 primary BINFO for the virtual base, as this is the one
1804 that'll really exist. */
1810 {
1813 }
1815 }
1817 /* Set BINFO_PRIMARY_BASE_OF for all binfos in the hierarchy
1818 dominated by TYPE that are primary bases. */
1820 static void
1822 tree type;
1823 {
1824 tree binfo;
1826 /* Walk the bases in inheritance graph order. */
1828 {
1829 tree base_binfo;
1832 /* Not a dynamic base. */
1842 }
1843 }
1845 /* Make the BINFO the primary base of T. */
1847 static void
1849 tree t;
1850 tree binfo;
1852 {
1853 tree basetype;
1862 }
1864 /* Determine the primary class for T. */
1866 static void
1868 tree t;
1870 {
1872 tree vbases;
1873 tree type_binfo;
1875 /* If there are no baseclasses, there is certainly no primary base. */
1882 {
1887 {
1888 /* Even a virtual baseclass can contain our RTTI
1889 information. But, we prefer a non-virtual polymorphic
1890 baseclass. */
1894 /* A virtual baseclass can't be the primary base under the
1895 old ABI. And under the new ABI we still prefer a
1896 non-virtual base. */
1901 {
1904 }
1905 else
1906 {
1907 tree vfields;
1909 /* Only add unique vfields, and flatten them out as we go. */
1911 vfields;
1919 }
1920 }
1921 }
1926 /* Find the indirect primary bases - those virtual bases which are primary
1927 bases of something else in this hierarchy. */
1929 vbases;
1931 {
1934 /* See if this virtual base is an indirect primary base. To be so,
1935 it must be a primary base within the hierarchy of one of our
1936 direct bases. */
1938 {
1940 tree v;
1943 v;
1945 {
1951 {
1954 }
1955 }
1957 /* If we've discovered that this virtual base is an indirect
1958 primary base, then we can move on to the next virtual
1959 base. */
1962 }
1963 }
1965 /* The new ABI allows for the use of a "nearly-empty" virtual base
1966 class as the primary base class if no non-virtual polymorphic
1967 base can be found. */
1969 {
1970 /* If not NULL, this is the best primary base candidate we have
1971 found so far. */
1973 tree base_binfo;
1975 /* Loop over the baseclasses. */
1977 base_binfo;
1979 {
1984 {
1985 /* If this is not an indirect primary base, then it's
1986 definitely our primary base. */
1988 {
1991 }
1993 /* If this is an indirect primary base, it still could be
1994 our primary base -- unless we later find there's another
1995 nearly-empty virtual base that isn't an indirect
1996 primary base. */
1999 }
2000 }
2002 /* If we've got a primary base, use it. */
2004 {
2008 }
2009 }
2011 /* Mark the primary base classes at this point. */
2013 }
2014 \f
2015 /* Set memoizing fields and bits of T (and its variants) for later
2016 use. */
2018 static void
2020 tree t;
2021 {
2024 /* Fix up variants (if any). */
2027 {
2028 /* These fields are in the _TYPE part of the node, not in
2029 the TYPE_LANG_SPECIFIC component, so they are not shared. */
2040 /* Copy whatever these are holding today. */
2047 }
2050 /* For a class w/o baseclasses, `finish_struct' has set
2051 CLASS_TYPE_ABSTRACT_VIRTUALS correctly (by
2052 definition). Similarly for a class whose base classes do not
2053 have vtables. When neither of these is true, we might have
2054 removed abstract virtuals (by providing a definition), added
2055 some (by declaring new ones), or redeclared ones from a base
2056 class. We need to recalculate what's really an abstract virtual
2057 at this point (by looking in the vtables). */
2061 {
2062 /* Notice whether this class has type conversion functions defined. */
2065 tree basetype;
2068 {
2072 }
2073 }
2075 /* If this type has a copy constructor, force its mode to be BLKmode, and
2076 force its TREE_ADDRESSABLE bit to be nonzero. This will cause it to
2077 be passed by invisible reference and prevent it from being returned in
2078 a register.
2080 Also do this if the class has BLKmode but can still be returned in
2081 registers, since function_cannot_inline_p won't let us inline
2082 functions returning such a type. This affects the HP-PA. */
2086 {
2087 tree variants;
2090 {
2093 }
2094 }
2095 }
2097 /* Issue warnings about T having private constructors, but no friends,
2098 and so forth.
2100 HAS_NONPRIVATE_METHOD is nonzero if T has any non-private methods or
2101 static members. HAS_NONPRIVATE_STATIC_FN is nonzero if T has any
2102 non-private static member functions. */
2104 static void
2106 tree t;
2107 {
2110 tree fn;
2113 /* If the class has friends, those entities might create and
2114 access instances, so we should not warn. */
2117 /* We will have warned when the template was declared; there's
2118 no need to warn on every instantiation. */
2120 /* There's no reason to even consider warning about this
2121 class. */
2124 /* We only issue one warning, if more than one applies, because
2125 otherwise, on code like:
2127 class A {
2128 // Oops - forgot `public:'
2129 A();
2130 A(const A&);
2131 ~A();
2132 };
2134 we warn several times about essentially the same problem. */
2136 /* Check to see if all (non-constructor, non-destructor) member
2137 functions are private. (Since there are no friends or
2138 non-private statics, we can't ever call any of the private member
2139 functions.) */
2141 /* We're not interested in compiler-generated methods; they don't
2142 provide any way to call private members. */
2144 {
2146 {
2148 /* A non-private static member function is just like a
2149 friend; it can create and invoke private member
2150 functions, and be accessed without a class
2151 instance. */
2156 }
2159 }
2162 {
2163 /* There are no non-private methods, and there's at least one
2164 private member function that isn't a constructor or
2165 destructor. (If all the private members are
2166 constructors/destructors we want to use the code below that
2167 issues error messages specifically referring to
2168 constructors/destructors.) */
2174 {
2177 }
2179 {
2182 }
2183 }
2185 /* Even if some of the member functions are non-private, the class
2186 won't be useful for much if all the constructors or destructors
2187 are private: such an object can never be created or destroyed. */
2189 {
2193 {
2195 t);
2197 }
2198 }
2201 {
2204 /* If a non-template class does not define a copy
2205 constructor, one is defined for it, enabling it to avoid
2206 this warning. For a template class, this does not
2207 happen, and so we would normally get a warning on:
2209 template <class T> class C { private: C(); };
2211 To avoid this asymmetry, we check TYPE_HAS_INIT_REF. All
2212 complete non-template or fully instantiated classes have this
2213 flag set. */
2216 else
2218 fn;
2220 {
2222 /* Ideally, we wouldn't count copy constructors (or, in
2223 fact, any constructor that takes an argument of the
2224 class type as a parameter) because such things cannot
2225 be used to construct an instance of the class unless
2226 you already have one. But, for now at least, we're
2227 more generous. */
2229 {
2232 }
2233 }
2236 {
2238 t);
2240 }
2241 }
2242 }
2244 /* Function to help qsort sort FIELD_DECLs by name order. */
2246 static int
2249 {
2251 /* A nontype is "greater" than a type. */
2260 }
2262 /* Comparison function to compare two TYPE_METHOD_VEC entries by name. */
2264 static int
2267 {
2277 }
2279 /* Warn about duplicate methods in fn_fields. Also compact method
2280 lists so that lookup can be made faster.
2282 Data Structure: List of method lists. The outer list is a
2283 TREE_LIST, whose TREE_PURPOSE field is the field name and the
2284 TREE_VALUE is the DECL_CHAIN of the FUNCTION_DECLs. TREE_CHAIN
2285 links the entire list of methods for TYPE_METHODS. Friends are
2286 chained in the same way as member functions (? TREE_CHAIN or
2287 DECL_CHAIN), but they live in the TREE_TYPE field of the outer
2288 list. That allows them to be quickly deleted, and requires no
2289 extra storage.
2291 Sort methods that are not special (i.e., constructors, destructors,
2292 and type conversion operators) so that we can find them faster in
2293 search. */
2295 static void
2297 tree t;
2298 {
2299 tree fn_fields;
2300 tree method_vec;
2304 {
2305 /* Clear these for safety; perhaps some parsing error could set
2306 these incorrectly. */
2311 }
2317 /* First fill in entry 0 with the constructors, entry 1 with destructors,
2318 and the next few with type conversion operators (if any). */
2321 /* Clear out this flag. */
2325 /* We thought there was a destructor, but there wasn't. Some
2326 parse errors cause this anomalous situation. */
2329 /* Issue warnings about private constructors and such. If there are
2330 no methods, then some public defaults are generated. */
2333 /* Now sort the methods. */
2335 len--;
2338 /* The type conversion ops have to live at the front of the vec, so we
2339 can't sort them. */
2341 {
2346 }
2350 }
2352 /* Emit error when a duplicate definition of a type is seen. Patch up. */
2354 void
2356 tree t;
2357 {
2361 /* Pretend we haven't defined this type. */
2363 /* All of the component_decl's were TREE_CHAINed together in the parser.
2364 finish_struct_methods walks these chains and assembles all methods with
2365 the same base name into DECL_CHAINs. Now we don't need the parser chains
2366 anymore, so we unravel them. */
2368 /* This used to be in finish_struct, but it turns out that the
2369 TREE_CHAIN is used by dbxout_type_methods and perhaps some other
2370 things... */
2372 {
2376 {
2379 {
2382 }
2383 }
2384 }
2387 {
2403 }
2412 /* Clear TYPE_LANG_FLAGS -- those in TYPE_LANG_SPECIFIC are cleared above. */
2420 /* But not this one. */
2422 }
2424 /* Make the BINFO's vtablehave N entries, including RTTI entries,
2425 vbase and vcall offsets, etc. Set its type and call the backend
2426 to lay it out. */
2428 static void
2430 tree binfo;
2432 {
2433 tree itype;
2434 tree atype;
2435 tree vtable;
2442 /* We may have to grow the vtable. */
2445 {
2450 /* At one time the vtable info was grabbed 2 words at a time. This
2451 fails on Sparc unless you have 8-byte alignment. */
2454 }
2455 }
2457 /* True iff FNDECL and BASE_FNDECL (both non-static member functions)
2458 have the same signature. */
2460 static int
2463 {
2464 /* One destructor overrides another if they are the same kind of
2465 destructor. */
2469 /* But a non-destructor never overrides a destructor, nor vice
2470 versa, nor do different kinds of destructors override
2471 one-another. For example, a complete object destructor does not
2472 override a deleting destructor. */
2477 {
2485 }
2487 }
2490 /* The function for which we are trying to find a final overrider. */
2491 tree fn;
2492 /* The base class in which the function was declared. */
2493 tree declaring_base;
2494 /* The most derived class in the hierarchy. */
2495 tree most_derived_type;
2496 /* The final overriding function. */
2497 tree overriding_fn;
2498 /* The BINFO for the class in which the final overriding function
2499 appears. */
2500 tree overriding_base;
2503 /* Called from find_final_overrider via dfs_walk. */
2505 static tree
2507 tree binfo;
2509 {
2516 {
2517 tree path;
2518 tree method;
2520 /* We haven't found an overrider yet. */
2522 /* We've found a path to the declaring base. Walk down the path
2523 looking for an overrider for FN. */
2525 path;
2527 {
2529 method;
2537 }
2539 /* If we found an overrider, record the overriding function, and
2540 the base from which it came. */
2542 {
2543 tree base;
2545 /* Assume the path is non-virtual. See if there are any
2546 virtual bases from (but not including) the overrider up
2547 to and including the base where the function is
2548 defined. */
2551 {
2554 }
2557 {
2558 /* We've found a different overrider along a different
2559 path. That can be OK if the new one overrides the
2560 old one. Consider:
2562 struct S { virtual void f(); };
2563 struct T : public virtual S { virtual void f(); };
2564 struct U : public virtual S, public virtual T {};
2566 Here `T::f' is the final overrider for `S::f'. */
2568 {
2571 }
2573 {
2580 }
2581 }
2583 && (!tree_int_cst_equal
2586 {
2587 /* We've found two instances of the same base that
2588 provide overriders. */
2594 }
2595 else
2596 {
2599 }
2600 }
2601 }
2604 }
2606 /* Returns a TREE_LIST whose TREE_PURPOSE is the final overrider for
2607 FN and whose TREE_VALUE is the binfo for the base where the
2608 overriding occurs. BINFO (in the hierarchy dominated by T) is the
2609 base object in which FN is declared. */
2611 static tree
2613 tree t;
2614 tree binfo;
2615 tree fn;
2616 {
2617 find_final_overrider_data ffod;
2619 /* Getting this right is a little tricky. This is legal:
2621 struct S { virtual void f (); };
2622 struct T { virtual void f (); };
2623 struct U : public S, public T { };
2625 even though calling `f' in `U' is ambiguous. But,
2627 struct R { virtual void f(); };
2628 struct S : virtual public R { virtual void f (); };
2629 struct T : virtual public R { virtual void f (); };
2630 struct U : public S, public T { };
2632 is not -- there's no way to decide whether to put `S::f' or
2633 `T::f' in the vtable for `R'.
2635 The solution is to look at all paths to BINFO. If we find
2636 different overriders along any two, then there is a problem. */
2644 dfs_find_final_overrider,
2645 NULL,
2650 }
2652 /* Update a entry in the vtable for BINFO, which is in the hierarchy
2653 dominated by T. FN has been overridden in BINFO; VIRTUALS points
2654 to the corresponding position in the BINFO_VIRTUALS list. */
2656 static void
2658 tree t;
2659 tree binfo;
2660 tree fn;
2662 {
2663 tree b;
2664 tree overrider;
2665 tree delta;
2666 tree virtual_base;
2669 /* Find the function which originally caused this vtable
2670 entry to be present. */
2673 {
2674 tree primary_base;
2675 tree f;
2682 f;
2692 }
2694 /* Find the final overrider. */
2699 /* Compute the constant adjustment to the `this' pointer. The
2700 `this' pointer, when this function is called, will point at the
2701 class whose vtable this is. */
2707 /* Assume that we will produce a thunk that convert all the way to
2708 the final overrider, and not to an intermediate virtual base. */
2711 /* Assume that we will always generate thunks with the vtables that
2712 reference them. */
2715 /* Under the new ABI, we will convert to an intermediate virtual
2716 base first, and then use the vcall offset located there to finish
2717 the conversion. */
2719 {
2720 /* If we find BINFO, then the final overrider is in a class
2721 derived from BINFO, so the thunks can be generated with
2722 the final overrider. */
2727 /* If we find the final overrider, then we can stop
2728 walking. */
2733 /* If we find a virtual base, and we haven't yet found the
2734 overrider, then there is a virtual base between the
2735 declaring base and the final overrider. */
2737 {
2740 }
2743 }
2746 /* The `this' pointer needs to be adjusted to the nearest virtual
2747 base. */
2749 else
2750 /* The `this' pointer needs to be adjusted from pointing to
2751 BINFO to pointing at the base where the final overrider
2752 appears. */
2756 binfo,
2758 delta,
2759 virtuals);
2765 }
2767 /* Called from modify_all_vtables via dfs_walk. */
2769 static tree
2771 tree binfo;
2773 {
2775 primary base; we're not going to use that vtable anyhow
2776 (virtual primary bases can become non-primary in a
2777 class derivation of this one.) */
2779 /* Similarly, a base without a vtable needs no modification. */
2781 {
2782 tree t;
2783 tree virtuals;
2784 tree old_virtuals;
2788 /* If we're supporting RTTI then we always need a new vtable to
2789 point to the RTTI information. Under the new ABI we may need
2790 a new vtable to contain vcall and vbase offsets. */
2793 /* Now, go through each of the virtual functions in the virtual
2794 function table for BINFO. Find the final overrider, and
2795 update the BINFO_VIRTUALS list appropriately. */
2798 virtuals;
2802 binfo,
2805 }
2810 }
2812 /* Update all of the primary and secondary vtables for T. Create new
2813 vtables as required, and initialize their RTTI information. Each
2814 of the functions in OVERRIDDEN_VIRTUALS overrides a virtual
2815 function from a base class; find and modify the appropriate entries
2816 to point to the overriding functions. Returns a list, in
2817 declaration order, of the functions that are overridden in this
2818 class, but do not appear in the primary base class vtable, and
2819 which should therefore be appended to the end of the vtable for T. */
2821 static tree
2823 tree t;
2825 tree overridden_virtuals;
2826 {
2827 tree binfo;
2831 /* Update all of the vtables. */
2833 dfs_modify_vtables,
2834 dfs_unmarked_real_bases_queue_p,
2835 t);
2838 /* If we should include overriding functions for secondary vtables
2839 in our primary vtable, add them now. */
2841 {
2845 {
2850 {
2851 /* Set the vtable index. */
2853 /* We don't need to convert to a base class when calling
2854 this function. */
2857 /* We don't need to adjust the `this' pointer when
2858 calling this function. */
2862 /* This is an overridden function not already in our
2863 vtable. Keep it. */
2865 }
2866 else
2867 /* We've already got an entry for this function. Skip
2868 it. */
2870 }
2871 }
2872 else
2876 }
2878 /* Here, we already know that they match in every respect.
2879 All we have to check is where they had their declarations. */
2881 static int
2884 {
2891 }
2893 /* Get the base virtual function declarations in T that are either
2894 overridden or hidden by FNDECL as a list. We set TREE_PURPOSE with
2895 the overrider/hider. */
2897 static tree
2900 {
2907 {
2914 }
2920 {
2925 base_fndecls);
2926 }
2929 }
2931 /* Mark the functions that have been hidden with their overriders.
2932 Since we start out with all functions already marked with a hider,
2933 no need to mark functions that are just hidden.
2935 Subroutine of warn_hidden. */
2937 static void
2940 {
2944 }
2946 /* If this declaration supersedes the declaration of
2947 a method declared virtual in the base class, then
2948 mark this field as being virtual as well. */
2950 static void
2953 {
2955 /* In [temp.mem] we have:
2957 A specialization of a member function template does not
2958 override a virtual function from a base class. */
2964 {
2965 /* Set DECL_VINDEX to a value that is neither an
2966 INTEGER_CST nor the error_mark_node so that
2967 add_virtual_function will realize this is an
2968 overriding function. */
2970 }
2972 {
2976 }
2977 }
2979 /* Warn about hidden virtual functions that are not overridden in t.
2980 We know that constructors and destructors don't apply. */
2982 void
2984 tree t;
2985 {
2990 /* We go through each separately named virtual function. */
2992 {
3000 /* First see if we have any virtual functions in this batch. */
3002 {
3006 }
3011 /* First we get a list of all possible functions that might be
3012 hidden from each base class. */
3014 {
3019 base_fndecls);
3020 }
3024 /* ...then mark up all the base functions with overriders, preferring
3025 overriders to hiders. */
3028 {
3032 }
3034 /* Now give a warning for all base functions without overriders,
3035 as they are hidden. */
3039 {
3040 /* Here we know it is a hider, and no overrider exists. */
3043 }
3044 }
3045 }
3047 /* Check for things that are invalid. There are probably plenty of other
3048 things we should check for also. */
3050 static void
3052 tree t;
3053 {
3054 tree field;
3057 {
3065 {
3068 {
3074 elt);
3077 {
3079 elt);
3081 }
3085 elt);
3088 elt);
3092 }
3093 }
3094 }
3095 }
3097 /* Create default constructors, assignment operators, and so forth for
3098 the type indicated by T, if they are needed.
3099 CANT_HAVE_DEFAULT_CTOR, CANT_HAVE_CONST_CTOR, and
3100 CANT_HAVE_CONST_ASSIGNMENT are nonzero if, for whatever reason, the
3101 class cannot have a default constructor, copy constructor taking a
3102 const reference argument, or an assignment operator taking a const
3103 reference, respectively. If a virtual destructor is created, its
3104 DECL is returned; otherwise the return value is NULL_TREE. */
3106 static tree
3108 cant_have_const_cctor,
3109 cant_have_const_assignment)
3110 tree t;
3114 {
3115 tree default_fn;
3120 /* Destructor. */
3122 {
3126 /* If we couldn't make it work, then pretend we didn't need it. */
3129 else
3130 {
3136 }
3137 }
3138 else
3139 /* Any non-implicit destructor is non-trivial. */
3142 /* Default constructor. */
3144 {
3148 }
3150 /* Copy constructor. */
3152 {
3153 /* ARM 12.18: You get either X(X&) or X(const X&), but
3154 not both. --Chip */
3155 default_fn
3160 }
3162 /* Assignment operator. */
3164 {
3165 default_fn
3170 }
3172 /* Now, hook all of the new functions on to TYPE_METHODS,
3173 and add them to the CLASSTYPE_METHOD_VEC. */
3180 }
3182 /* Subroutine of finish_struct_1. Recursively count the number of fields
3183 in TYPE, including anonymous union members. */
3185 static int
3187 tree fields;
3188 {
3189 tree x;
3192 {
3195 else
3197 }
3199 }
3201 /* Subroutine of finish_struct_1. Recursively add all the fields in the
3202 TREE_LIST FIELDS to the TREE_VEC FIELD_VEC, starting at offset IDX. */
3204 static int
3208 {
3209 tree x;
3211 {
3214 else
3216 }
3218 }
3220 /* FIELD is a bit-field. We are finishing the processing for its
3221 enclosing type. Issue any appropriate messages and set appropriate
3222 flags. */
3224 static void
3226 tree field;
3227 {
3231 /* Detect invalid bit-field type. */
3234 {
3237 }
3239 /* Detect and ignore out of range field width. */
3241 {
3244 /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs. */
3247 /* detect invalid field size. */
3250 else
3254 {
3256 field);
3258 }
3260 {
3263 }
3265 {
3268 }
3278 min_precision
3283 }
3285 /* Remove the bit-field width indicator so that the rest of the
3286 compiler does not treat that value as an initializer. */
3290 {
3295 {
3296 #ifdef EMPTY_FIELD_BOUNDARY
3298 EMPTY_FIELD_BOUNDARY);
3299 #endif
3300 #ifdef PCC_BITFIELD_TYPE_MATTERS
3302 {
3306 }
3307 #endif
3308 }
3309 }
3310 else
3311 {
3312 /* Non-bit-fields are aligned for their type. */
3317 }
3318 }
3320 /* FIELD is a non bit-field. We are finishing the processing for its
3321 enclosing type T. Issue any appropriate messages and set appropriate
3322 flags. */
3324 static void
3327 any_default_members)
3328 tree field;
3329 tree t;
3334 {
3337 /* An anonymous union cannot contain any fields which would change
3338 the settings of CANT_HAVE_CONST_CTOR and friends. */
3340 ;
3341 /* And, we don't set TYPE_HAS_CONST_INIT_REF, etc., for anonymous
3342 structs. So, we recurse through their fields here. */
3344 {
3345 tree fields;
3351 any_default_members);
3352 }
3353 /* Check members with class type for constructors, destructors,
3354 etc. */
3356 {
3357 /* Never let anything with uninheritable virtuals
3358 make it through without complaint. */
3362 {
3365 field);
3368 field);
3371 field);
3372 }
3373 else
3374 {
3380 }
3391 }
3393 {
3394 /* `build_class_init_list' does not recognize
3395 non-FIELD_DECLs. */
3399 }
3401 /* Non-bit-fields are aligned for their type, except packed fields
3402 which require only BITS_PER_UNIT alignment. */
3405 ? BITS_PER_UNIT
3409 }
3411 /* Check the data members (both static and non-static), class-scoped
3412 typedefs, etc., appearing in the declaration of T. Issue
3413 appropriate diagnostics. Sets ACCESS_DECLS to a list (in
3414 declaration order) of access declarations; each TREE_VALUE in this
3415 list is a USING_DECL.
3417 In addition, set the following flags:
3419 EMPTY_P
3420 The class is empty, i.e., contains no non-static data members.
3422 CANT_HAVE_DEFAULT_CTOR_P
3423 This class cannot have an implicitly generated default
3424 constructor.
3426 CANT_HAVE_CONST_CTOR_P
3427 This class cannot have an implicitly generated copy constructor
3428 taking a const reference.
3430 CANT_HAVE_CONST_ASN_REF
3431 This class cannot have an implicitly generated assignment
3432 operator taking a const reference.
3434 All of these flags should be initialized before calling this
3435 function.
3437 Returns a pointer to the end of the TYPE_FIELDs chain; additional
3438 fields can be added by adding to this chain. */
3440 static void
3443 no_const_asn_ref_p)
3444 tree t;
3450 {
3456 /* First, delete any duplicate fields. */
3459 /* Assume there are no access declarations. */
3461 /* Assume this class has no pointer members. */
3463 /* Assume none of the members of this class have default
3464 initializations. */
3468 {
3477 {
3481 /* We don't treat zero-width bitfields as making a class
3482 non-empty. */
3483 ;
3484 else
3485 {
3486 /* The class is non-empty. */
3488 /* The class is not even nearly empty. */
3490 }
3491 }
3494 {
3495 /* Prune the access declaration from the list of fields. */
3498 /* Save the access declarations for our caller. */
3501 /* Since we've reset *FIELD there's no reason to skip to the
3502 next field. */
3505 }
3511 /* If we've gotten this far, it's a data member, possibly static,
3512 or an enumerator. */
3516 /* ``A local class cannot have static data members.'' ARM 9.4 */
3520 /* Perform error checking that did not get done in
3521 grokdeclarator. */
3523 {
3525 x);
3528 }
3530 {
3534 }
3536 {
3540 }
3545 /* When this goes into scope, it will be a non-local reference. */
3552 {
3554 /* Unions cannot have static members. */
3558 }
3560 /* Now it can only be a FIELD_DECL. */
3565 /* If this is of reference type, check if it needs an init.
3566 Also do a little ANSI jig if necessary. */
3568 {
3573 /* ARM $12.6.2: [A member initializer list] (or, for an
3574 aggregate, initialization by a brace-enclosed list) is the
3575 only way to initialize nonstatic const and reference
3576 members. */
3582 }
3593 /* For some reason, pointers to members are POD types themselves,
3594 but are not allowed in POD structs. Silly. */
3598 /* If any field is const, the structure type is pseudo-const. */
3600 {
3605 /* ARM $12.6.2: [A member initializer list] (or, for an
3606 aggregate, initialization by a brace-enclosed list) is the
3607 only way to initialize nonstatic const and reference
3608 members. */
3614 }
3615 /* A field that is pseudo-const makes the structure likewise. */
3617 {
3621 }
3623 /* Core issue 80: A nonstatic data member is required to have a
3624 different name from the class iff the class has a
3625 user-defined constructor. */
3630 /* We set DECL_C_BIT_FIELD in grokbitfield.
3631 If the type and width are valid, we'll also set DECL_BIT_FIELD. */
3634 else
3636 cant_have_const_ctor_p,
3637 cant_have_default_ctor_p,
3638 no_const_asn_ref_p,
3640 }
3642 /* Effective C++ rule 11. */
3645 {
3649 {
3653 }
3656 }
3659 /* Check anonymous struct/anonymous union fields. */
3662 /* We've built up the list of access declarations in reverse order.
3663 Fix that now. */
3665 }
3667 /* Return a FIELD_DECL for a pointer-to-virtual-table or
3668 pointer-to-virtual-base. The NAME, ASSEMBLER_NAME, and TYPE of the
3669 field are as indicated. The CLASS_TYPE in which this field occurs
3670 is also indicated. FCONTEXT is the type that is needed for the debug
3671 info output routines. *EMPTY_P is set to a non-zero value by this
3672 function to indicate that a class containing this field is
3673 non-empty. */
3675 static tree
3677 empty_p)
3678 tree name;
3679 tree assembler_name;
3680 tree type;
3681 tree class_type;
3682 tree fcontext;
3684 {
3685 tree field;
3687 /* This class is non-empty. */
3690 /* Build the FIELD_DECL. */
3700 /* Return it. */
3702 }
3704 /* If TYPE is an empty class type, records its OFFSET in the table of
3705 OFFSETS. */
3707 static int
3709 tree type;
3710 tree offset;
3711 splay_tree offsets;
3712 {
3713 splay_tree_node n;
3718 /* Record the location of this empty object in OFFSETS. */
3726 type,
3730 }
3732 /* Returns non-zero if TYPE is an empty class type and there is
3733 already an entry in OFFSETS for the same TYPE as the same OFFSET. */
3735 static int
3737 tree type;
3738 tree offset;
3739 splay_tree offsets;
3740 {
3741 splay_tree_node n;
3742 tree t;
3747 /* Record the location of this empty object in OFFSETS. */
3757 }
3759 /* Walk through all the subobjects of TYPE (located at OFFSET). Call
3760 F for every subobject, passing it the type, offset, and table of
3761 OFFSETS. If VBASES_P is non-zero, then even virtual non-primary
3762 bases should be traversed; otherwise, they are ignored. If F
3763 returns a non-zero value, the traversal ceases, and that value is
3764 returned. Otherwise, returns zero. */
3766 static int
3768 tree type;
3769 subobject_offset_fn f;
3770 tree offset;
3771 splay_tree offsets;
3773 {
3777 {
3778 tree field;
3781 /* Record the location of TYPE. */
3786 /* Iterate through the direct base classes of TYPE. */
3788 {
3797 f,
3799 offset,
3801 offsets,
3802 vbases_p);
3805 }
3807 /* Iterate through the fields of TYPE. */
3810 {
3812 f,
3814 offset,
3816 offsets,
3820 }
3821 }
3823 {
3825 tree index;
3827 /* Step through each of the elements in the array. */
3831 {
3833 f,
3834 offset,
3835 offsets,
3841 }
3842 }
3845 }
3847 /* Record all of the empty subobjects of TYPE (located at OFFSET) in
3848 OFFSETS. If VBASES_P is non-zero, virtual bases of TYPE are
3849 examined. */
3851 static void
3853 tree type;
3854 tree offset;
3855 splay_tree offsets;
3857 {
3860 }
3862 /* Returns non-zero if any of the empty subobjects of TYPE (located at
3863 OFFSET) conflict with entries in OFFSETS. If VBASES_P is non-zero,
3864 virtual bases of TYPE are examined. */
3866 static int
3868 tree type;
3869 tree offset;
3870 splay_tree offsets;
3872 {
3875 }
3877 /* DECL is a FIELD_DECL corresponding either to a base subobject of a
3878 non-static data member of the type indicated by RLI. BINFO is the
3879 binfo corresponding to the base subobject, OFFSETS maps offsets to
3880 types already located at those offsets. This function determines
3881 the position of the DECL. */
3883 static void
3885 record_layout_info rli;
3886 tree decl;
3887 tree binfo;
3888 splay_tree offsets;
3889 {
3892 /* If we are laying out a base class, rather than a field, then
3893 DECL_ARTIFICIAL will be set on the FIELD_DECL. */
3896 /* Try to place the field. It may take more than one try if we have
3897 a hard time placing the field without putting two objects of the
3898 same type at the same address. */
3900 {
3903 /* Place this field. */
3907 /* We have to check to see whether or not there is already
3908 something of the same type at the offset we're about to use.
3909 For example:
3911 struct S {};
3912 struct T : public S { int i; };
3913 struct U : public S, public T {};
3915 Here, we put S at offset zero in U. Then, we can't put T at
3916 offset zero -- its S component would be at the same address
3917 as the S we already allocated. So, we have to skip ahead.
3918 Since all data members, including those whose type is an
3919 empty class, have non-zero size, any overlap can happen only
3920 with a direct or indirect base-class -- it can't happen with
3921 a data member. */
3923 offset,
3924 offsets,
3925 field_p))
3926 {
3927 /* Strip off the size allocated to this field. That puts us
3928 at the first place we could have put the field with
3929 proper alignment. */
3932 /* Bump up by the alignment required for the type. */
3933 rli->bitpos
3939 }
3940 else
3941 /* There was no conflict. We're done laying out this field. */
3943 }
3945 /* Now that we know where it wil be placed, update its
3946 BINFO_OFFSET. */
3950 }
3952 /* Layout the empty base BINFO. EOC indicates the byte currently just
3953 past the end of the class, and should be correctly aligned for a
3954 class of the type indicated by BINFO; OFFSETS gives the offsets of
3955 the empty bases allocated so far. */
3957 static void
3959 tree binfo;
3960 tree eoc;
3961 splay_tree offsets;
3962 {
3963 tree alignment;
3966 /* This routine should only be used for empty classes. */
3970 /* This is an empty base class. We first try to put it at offset
3971 zero. */
3974 offsets,
3976 {
3977 /* That didn't work. Now, we move forward from the next
3978 available spot in the class. */
3981 {
3984 offsets,
3986 /* We finally found a spot where there's no overlap. */
3989 /* There's overlap here, too. Bump along to the next spot. */
3991 }
3992 }
3993 }
3995 /* Build a FIELD_DECL for the base given by BINFO in the class
3996 indicated by RLI. If the new object is non-empty, clear *EMPTY_P.
3997 *BASE_ALIGN is a running maximum of the alignments of any base
3998 class. OFFSETS gives the location of empty base subobjects. */
4000 static void
4002 record_layout_info rli;
4003 tree binfo;
4005 splay_tree offsets;
4006 {
4008 tree decl;
4011 /* This error is now reported in xref_tag, thus giving better
4012 location information. */
4024 {
4025 /* The containing class is non-empty because it has a non-empty
4026 base class. */
4029 /* Try to place the field. It may take more than one try if we
4030 have a hard time placing the field without putting two
4031 objects of the same type at the same address. */
4033 }
4034 else
4035 {
4038 /* On some platforms (ARM), even empty classes will not be
4039 byte-aligned. */
4043 }
4045 /* Check for inaccessible base classes. If the same base class
4046 appears more than once in the hierarchy, but isn't virtual, then
4047 it's ambiguous. */
4052 /* Record the offsets of BINFO and its base subobjects. */
4055 offsets,
4057 }
4059 /* Layout all of the non-virtual base classes. Record empty
4060 subobjects in OFFSETS. */
4062 static void
4064 record_layout_info rli;
4066 splay_tree offsets;
4067 {
4068 /* Chain to hold all the new FIELD_DECLs which stand in for base class
4069 subobjects. */
4074 /* Under the new ABI, the primary base class is always allocated
4075 first. */
4080 /* Now allocate the rest of the bases. */
4082 {
4083 tree base_binfo;
4087 /* Under the new ABI, the primary base was already allocated
4088 above, so we don't need to allocate it again here. */
4092 /* A primary virtual base class is allocated just like any other
4093 base class, but a non-primary virtual base is allocated
4094 later, in layout_virtual_bases. */
4100 }
4101 }
4103 /* Go through the TYPE_METHODS of T issuing any appropriate
4104 diagnostics, figuring out which methods override which other
4105 methods, and so forth. */
4107 static void
4109 tree t;
4110 {
4111 tree x;
4115 {
4118 /* If this was an evil function, don't keep it in class. */
4126 /* The name of the field is the original field name
4127 Save this in auxiliary field for later overloading. */
4129 {
4134 }
4137 {
4138 tree second_parm;
4140 /* When dynamically allocating an array of this type, we
4141 need a "cookie" to record how many elements we allocated,
4142 even if the array elements have no non-trivial
4143 destructor, if the usual array deallocation function
4144 takes a second argument of type size_t. The standard (in
4145 [class.free]) requires that the second argument be set
4146 correctly. */
4148 /* Under the new ABI, we choose only those function that are
4149 explicitly declared as `operator delete[] (void *,
4150 size_t)'. */
4152 && second_parm
4156 /* If there's no second parameter, then this is the usual
4157 deallocation function. */
4160 }
4161 }
4162 }
4164 /* FN is a constructor or destructor. Clone the declaration to create
4165 a specialized in-charge or not-in-charge version, as indicated by
4166 NAME. */
4168 static tree
4170 tree fn;
4171 tree name;
4172 {
4173 tree parms;
4174 tree clone;
4176 /* Copy the function. */
4178 /* Remember where this function came from. */
4180 /* Reset the function name. */
4183 /* There's no pending inline data for this function. */
4186 /* And it hasn't yet been deferred. */
4188 /* There's no magic VTT parameter in the clone. */
4191 /* The base-class destructor is not virtual. */
4193 {
4197 }
4199 /* If there was an in-charge parameter, drop it from the function
4200 type. */
4202 {
4203 tree basetype;
4204 tree parmtypes;
4205 tree exceptions;
4210 /* Skip the `this' parameter. */
4212 /* Skip the in-charge parameter. */
4214 /* If this is subobject constructor or destructor, add the vtt
4215 parameter. */
4221 parmtypes);
4224 exceptions);
4225 }
4227 /* Copy the function parameters. But, DECL_ARGUMENTS aren't
4228 function parameters; instead, those are the template parameters. */
4230 {
4232 /* Remove the in-charge parameter. */
4234 {
4238 }
4240 /* Add the VTT parameter. */
4242 {
4243 tree parm;
4246 vtt_parm_type);
4249 }
4252 {
4255 }
4256 }
4258 /* Mangle the function name. */
4261 /* Create the RTL for this function. */
4265 /* Make it easy to find the CLONE given the FN. */
4269 /* If this is a template, handle the DECL_TEMPLATE_RESULT as well. */
4271 {
4272 tree result;
4279 }
4284 }
4286 /* Produce declarations for all appropriate clones of FN. If
4287 UPDATE_METHOD_VEC_P is non-zero, the clones are added to the
4288 CLASTYPE_METHOD_VEC as well. */
4290 void
4292 tree fn;
4294 {
4295 tree clone;
4297 /* Avoid inappropriate cloning. */
4303 {
4304 /* For each constructor, we need two variants: an in-charge version
4305 and a not-in-charge version. */
4312 }
4313 else
4314 {
4317 /* For each destructor, we need three variants: an in-charge
4318 version, a not-in-charge version, and an in-charge deleting
4319 version. We clone the deleting version first because that
4320 means it will go second on the TYPE_METHODS list -- and that
4321 corresponds to the correct layout order in the virtual
4322 function table.
4324 For a non-virtual destructor, we do not build a deleting
4325 destructor. */
4327 {
4331 }
4338 }
4339 }
4341 /* For each of the constructors and destructors in T, create an
4342 in-charge and not-in-charge variant. */
4344 static void
4346 tree t;
4347 {
4348 tree fns;
4350 /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail
4351 out now. */
4359 }
4361 /* Remove all zero-width bit-fields from T. */
4363 static void
4365 tree t;
4366 {
4371 {
4376 else
4378 }
4379 }
4381 /* Check the validity of the bases and members declared in T. Add any
4382 implicitly-generated functions (like copy-constructors and
4383 assignment operators). Compute various flag bits (like
4384 CLASSTYPE_NON_POD_T) for T. This routine works purely at the C++
4385 level: i.e., independently of the ABI in use. */
4387 static void
4389 tree t;
4391 {
4392 /* Nonzero if we are not allowed to generate a default constructor
4393 for this case. */
4395 /* Nonzero if the implicitly generated copy constructor should take
4396 a non-const reference argument. */
4398 /* Nonzero if the the implicitly generated assignment operator
4399 should take a non-const reference argument. */
4401 tree access_decls;
4403 /* By default, we use const reference arguments and generate default
4404 constructors. */
4409 /* Assume that the class is nearly empty; we'll clear this flag if
4410 it turns out not to be nearly empty. */
4413 /* Check all the base-classes. */
4417 /* Check all the data member declarations. */
4423 /* Check all the method declarations. */
4426 /* A nearly-empty class has to be vptr-containing; a nearly empty
4427 class contains just a vptr. */
4431 /* Do some bookkeeping that will guide the generation of implicitly
4432 declared member functions. */
4450 /* Synthesize any needed methods. Note that methods will be synthesized
4451 for anonymous unions; grok_x_components undoes that. */
4453 cant_have_const_ctor,
4454 no_const_asn_ref);
4456 /* Create the in-charge and not-in-charge variants of constructors
4457 and destructors. */
4460 /* Process the using-declarations. */
4464 /* Build and sort the CLASSTYPE_METHOD_VEC. */
4466 }
4468 /* If T needs a pointer to its virtual function table, set TYPE_VFIELD
4469 accordingly. If a new vfield was created (because T doesn't have a
4470 primary base class), then the newly created field is returned. It
4471 is not added to the TYPE_FIELDS list; it is the caller's
4472 responsibility to do that. */
4474 static tree
4477 tree t;
4482 {
4483 tree fn;
4485 /* Loop over the virtual functions, adding them to our various
4486 vtables. */
4492 /* If we couldn't find an appropriate base class, create a new field
4493 here. Even if there weren't any new virtual functions, we might need a
4494 new virtual function table if we're supposed to include vptrs in
4495 all classes that need them. */
4497 && (*vfuns_p
4499 {
4500 /* We build this decl with vtbl_ptr_type_node, which is a
4501 `vtable_entry_type*'. It might seem more precise to use
4502 `vtable_entry_type (*)[N]' where N is the number of firtual
4503 functions. However, that would require the vtable pointer in
4504 base classes to have a different type than the vtable pointer
4505 in derived classes. We could make that happen, but that
4506 still wouldn't solve all the problems. In particular, the
4507 type-based alias analysis code would decide that assignments
4508 to the base class vtable pointer can't alias assignments to
4509 the derived class vtable pointer, since they have different
4510 types. Thus, in an derived class destructor, where the base
4511 class constructor was inlined, we could generate bad code for
4512 setting up the vtable pointer.
4514 Therefore, we use one type for all vtable pointers. We still
4515 use a type-correct type; it's just doesn't indicate the array
4516 bounds. That's better than using `void*' or some such; it's
4517 cleaner, and it let's the alias analysis code know that these
4518 stores cannot alias stores to void*! */
4522 vtbl_ptr_type_node,
4523 t,
4524 t,
4525 empty_p);
4528 /* If there were any baseclasses, they can't possibly be at
4529 offset zero any more, because that's where the vtable
4530 pointer is. So, converting to a base class is going to
4531 take work. */
4535 }
4538 }
4540 /* Fixup the inline function given by INFO now that the class is
4541 complete. */
4543 static void
4545 tree fn;
4546 {
4548 {
4551 {
4554 }
4555 }
4556 }
4558 /* Fixup the inline methods and friends in TYPE now that TYPE is
4559 complete. */
4561 static void
4563 tree type;
4564 {
4568 {
4573 else
4575 }
4577 /* Do inline member functions. */
4581 /* Do friends. */
4583 method;
4587 }
4589 /* Add OFFSET to all base types of BINFO which is a base in the
4590 hierarchy dominated by T.
4592 OFFSET, which is a type offset, is number of bytes. */
4594 static void
4596 tree binfo;
4597 tree offset;
4598 {
4600 tree primary_binfo;
4602 /* Update BINFO's offset. */
4607 offset));
4609 /* Find the primary base class. */
4612 /* Scan all of the bases, pushing the BINFO_OFFSET adjust
4613 downwards. */
4615 {
4616 tree base_binfo;
4618 /* On the first through the loop, do the primary base. Because
4619 the primary base need not be an immediate base, we must
4620 handle the primary base specially. */
4622 {
4627 }
4628 else
4629 {
4631 /* Don't do the primary base twice. */
4634 }
4636 /* Skip virtual bases that aren't our primary base. */
4642 }
4643 }
4645 /* Called via dfs_walk from layout_virtual bases. */
4647 static tree
4649 tree binfo;
4651 {
4652 /* If this is a virtual base, make sure it has the same offset as
4653 the shared copy. If it's a primary base, then we know it's
4654 correct. */
4656 {
4658 tree vbase;
4659 tree offset;
4664 }
4667 }
4669 /* Set BINFO_OFFSET for all of the virtual bases for T. Update
4670 TYPE_ALIGN and TYPE_SIZE for T. OFFSETS gives the location of
4671 empty subobjects of T. */
4673 static void
4675 tree t;
4676 splay_tree offsets;
4677 {
4678 tree vbases;
4685 #ifdef STRUCTURE_SIZE_BOUNDARY
4686 /* Packed structures don't need to have minimum size. */
4689 #endif
4691 /* DSIZE is the size of the class without the virtual bases. */
4694 /* Make every class have alignment of at least one. */
4697 /* Go through the virtual bases, allocating space for each virtual
4698 base that is not already a primary base class. Under the new
4699 ABI, these are allocated according to a depth-first left-to-right
4700 postorder traversal; in the new ABI, inheritance graph order is
4701 used instead. */
4703 vbases;
4705 {
4706 tree vbase;
4713 {
4714 /* This virtual base is not a primary base of any class in the
4715 hierarchy, so we have to add space for it. */
4716 tree basetype;
4724 /* Add padding so that we can put the virtual base class at an
4725 appropriately aligned offset. */
4728 /* Under the new ABI, we try to squish empty virtual bases in
4729 just like ordinary empty bases. */
4733 offsets);
4734 else
4735 {
4736 tree offset;
4743 /* And compute the offset of the virtual base. */
4745 /* Every virtual baseclass takes a least a UNIT, so that
4746 we can take it's address and get something different
4747 for each base. */
4750 }
4752 /* Keep track of the offsets assigned to this virtual base. */
4755 offsets,
4757 }
4758 }
4760 /* Now, go through the TYPE_BINFO hierarchy, setting the
4761 BINFO_OFFSETs correctly for all non-primary copies of the virtual
4762 bases and their direct and indirect bases. The ambiguity checks
4763 in get_base_distance depend on the BINFO_OFFSETs being set
4764 correctly. */
4767 /* If we had empty base classes that protruded beyond the end of the
4768 class, we didn't update DSIZE above; we were hoping to overlay
4769 multiple such bases at the same location. */
4774 /* Now, make sure that the total size of the type is a multiple of
4775 its alignment. */
4780 bitsize_unit_node));
4782 /* Check for ambiguous virtual bases. */
4785 vbases;
4787 {
4792 }
4793 }
4795 /* Returns the offset of the byte just past the end of the base class
4796 with the highest offset in T. If INCLUDE_VIRTUALS_P is zero, then
4797 only non-virtual bases are included. */
4799 static unsigned HOST_WIDE_INT
4801 tree t;
4803 {
4808 {
4809 tree base_binfo;
4810 tree offset;
4826 }
4829 }
4831 /* Compare two INTEGER_CSTs K1 and K2. */
4833 static int
4835 splay_tree_key k1;
4836 splay_tree_key k2;
4837 {
4839 }
4841 /* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T. Calculate
4842 BINFO_OFFSETs for all of the base-classes. Position the vtable
4843 pointer. */
4845 static void
4848 tree t;
4853 {
4854 tree non_static_data_members;
4855 tree field;
4856 tree vptr;
4857 record_layout_info rli;
4859 /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of
4860 types that appear at that offset. */
4861 splay_tree empty_base_offsets;
4863 /* Keep track of the first non-static data member. */
4866 /* Start laying out the record. */
4869 /* If possible, we reuse the virtual function table pointer from one
4870 of our base classes. */
4873 /* Create a pointer to our virtual function table. */
4877 /* Under the new ABI, the vptr is always the first thing in the
4878 class. */
4880 {
4883 }
4885 /* Build FIELD_DECLs for all of the non-virtual base-types. */
4889 /* Add pointers to all of our virtual base-classes. */
4893 /* CLASSTYPE_INLINE_FRIENDS is really TYPE_NONCOPIED_PARTS. Thus,
4894 we have to save this before we start modifying
4895 TYPE_NONCOPIED_PARTS. */
4898 /* Layout the non-static data members. */
4900 {
4901 tree type;
4902 tree padding;
4904 /* We still pass things that aren't non-static data members to
4905 the back-end, in case it wants to do something with them. */
4907 {
4910 }
4914 /* If this field is a bit-field whose width is greater than its
4915 type, then there are some special rules for allocating it
4916 under the new ABI. Under the old ABI, there were no special
4917 rules, but the back-end can't handle bitfields longer than a
4918 `long long', so we use the same mechanism. */
4921 {
4922 integer_type_kind itk;
4923 tree integer_type;
4925 /* We must allocate the bits as if suitably aligned for the
4926 longest integer type that fits in this many bits. type
4927 of the field. Then, we are supposed to use the left over
4928 bits as additional padding. */
4934 /* ITK now indicates a type that is too large for the
4935 field. We have to back up by one to find the largest
4936 type that fits. */
4943 }
4944 else
4948 empty_base_offsets);
4950 /* If we needed additional padding after this field, add it
4951 now. */
4953 {
4954 tree padding_field;
4957 NULL_TREE,
4958 char_type_node);
4964 NULL_TREE,
4965 empty_base_offsets);
4966 }
4967 }
4969 /* It might be the case that we grew the class to allocate a
4970 zero-sized base class. That won't be reflected in RLI, yet,
4971 because we are willing to overlay multiple bases at the same
4972 offset. However, now we need to make sure that RLI is big enough
4973 to reflect the entire class. */
4977 {
4980 }
4982 /* We make all structures have at least one element, so that they
4983 have non-zero size. In the new ABI, the class may be empty even
4984 if it has basetypes. Therefore, we add the fake field after all
4985 the other fields; if there are already FIELD_DECLs on the list,
4986 their offsets will not be disturbed. */
4988 {
4989 tree padding;
4996 }
4998 /* Let the back-end lay out the type. Note that at this point we
4999 have only included non-virtual base-classes; we will lay out the
5000 virtual base classes later. So, the TYPE_SIZE/TYPE_ALIGN after
5001 this call are not necessarily correct; they are just the size and
5002 alignment when no virtual base clases are used. */
5005 /* Delete all zero-width bit-fields from the list of fields. Now
5006 that the type is laid out they are no longer important. */
5009 /* Remember the size and alignment of the class before adding
5010 the virtual bases. */
5012 {
5015 }
5016 else
5017 {
5020 }
5025 /* Set the TYPE_DECL for this type to contain the right
5026 value for DECL_OFFSET, so that we can use it as part
5027 of a COMPONENT_REF for multiple inheritance. */
5030 /* Now fix up any virtual base class types that we left lying
5031 around. We must get these done before we try to lay out the
5032 virtual function table. As a side-effect, this will remove the
5033 base subobject fields. */
5036 /* Clean up. */
5038 }
5040 /* Create a RECORD_TYPE or UNION_TYPE node for a C struct or union declaration
5041 (or C++ class declaration).
5043 For C++, we must handle the building of derived classes.
5044 Also, C++ allows static class members. The way that this is
5045 handled is to keep the field name where it is (as the DECL_NAME
5046 of the field), and place the overloaded decl in the bit position
5047 of the field. layout_record and layout_union will know about this.
5049 More C++ hair: inline functions have text in their
5050 DECL_PENDING_INLINE_INFO nodes which must somehow be parsed into
5051 meaningful tree structure. After the struct has been laid out, set
5052 things up so that this can happen.
5054 And still more: virtual functions. In the case of single inheritance,
5055 when a new virtual function is seen which redefines a virtual function
5056 from the base class, the new virtual function is placed into
5057 the virtual function table at exactly the same address that
5058 it had in the base class. When this is extended to multiple
5059 inheritance, the same thing happens, except that multiple virtual
5060 function tables must be maintained. The first virtual function
5061 table is treated in exactly the same way as in the case of single
5062 inheritance. Additional virtual function tables have different
5063 DELTAs, which tell how to adjust `this' to point to the right thing.
5065 ATTRIBUTES is the set of decl attributes to be applied, if any. */
5067 void
5069 tree t;
5070 {
5071 tree x;
5073 /* The NEW_VIRTUALS is a TREE_LIST. The TREE_VALUE of each node is
5074 a FUNCTION_DECL. Each of these functions is a virtual function
5075 declared in T that does not override any virtual function from a
5076 base class. */
5078 /* The OVERRIDDEN_VIRTUALS list is like the NEW_VIRTUALS list,
5079 except that each declaration here overrides the declaration from
5080 a base class. */
5083 tree vfield;
5087 {
5090 else
5094 }
5098 /* If this type was previously laid out as a forward reference,
5099 make sure we lay it out again. */
5106 /* Do end-of-class semantic processing: checking the validity of the
5107 bases and members and add implicitly generated methods. */
5110 /* Layout the class itself. */
5117 t);
5119 /* Set up the DECL_FIELD_BITPOS of the vfield if we need to, as we
5120 might need to know it for setting up the offsets in the vtable
5121 (or in thunks) below. */
5125 {
5136 }
5138 overridden_virtuals
5141 /* If we created a new vtbl pointer for this class, add it to the
5142 list. */
5147 /* If necessary, create the primary vtable for this class. */
5149 || overridden_virtuals
5151 {
5153 /* We must enter these virtuals into the table. */
5157 /* Here we know enough to change the type of our virtual
5158 function table, but we will wait until later this function. */
5161 /* If this type has basetypes with constructors, then those
5162 constructors might clobber the virtual function table. But
5163 they don't if the derived class shares the exact vtable of the base
5164 class. */
5167 }
5168 /* If we didn't need a new vtable, see if we should copy one from
5169 the base. */
5171 {
5174 /* If this class uses a different vtable than its primary base
5175 then when we will need to initialize our vptr after the base
5176 class constructor runs. */
5179 }
5182 {
5191 /* Entries for virtual functions defined in the primary base are
5192 followed by entries for new functions unique to this class. */
5195 /* Finally, add entries for functions that override virtuals
5196 from non-primary bases. */
5199 }
5203 /* Complete the rtl for any static member objects of the type we're
5204 working on. */
5206 {
5209 {
5212 }
5213 }
5215 /* Done with FIELDS...now decide whether to sort these for
5216 faster lookups later.
5218 The C front-end only does this when n_fields > 15. We use
5219 a smaller number because most searches fail (succeeding
5220 ultimately as the search bores through the inheritance
5221 hierarchy), and we want this failure to occur quickly. */
5225 {
5233 }
5236 {
5240 {
5241 /* Mark the fact that constructor for T
5242 could affect anybody inheriting from T
5243 who wants to initialize vtables for VFIELDS's type. */
5247 }
5248 }
5250 /* Make the rtl for any new vtables we have created, and unmark
5251 the base types we marked. */
5254 /* Build the VTT for T. */
5258 {
5259 /* In addition to this one, all the other vfields should be listed. */
5260 /* Before that can be done, we have to have FIELD_DECLs for them, and
5261 a place to find them. */
5269 t);
5270 }
5279 /* Finish debugging output for this type. */
5281 }
5283 /* When T was built up, the member declarations were added in reverse
5284 order. Rearrange them to declaration order. */
5286 void
5288 tree t;
5289 {
5290 tree next;
5291 tree prev;
5292 tree x;
5294 /* The TYPE_FIELDS, TYPE_METHODS, and CLASSTYPE_TAGS are all in
5295 reverse order. Put them in declaration order now. */
5299 /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
5300 reverse order, so we can't just use nreverse. */
5305 {
5309 }
5311 {
5315 }
5316 }
5318 tree
5321 {
5325 /* Now that we've got all the field declarations, reverse everything
5326 as necessary. */
5331 /* Nadger the current location so that diagnostics point to the start of
5332 the struct, not the end. */
5337 {
5340 }
5341 else
5351 else
5355 {
5359 }
5362 }
5363 \f
5364 /* Return the dynamic type of INSTANCE, if known.
5365 Used to determine whether the virtual function table is needed
5366 or not.
5368 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5369 of our knowledge of its type. *NONNULL should be initialized
5370 before this function is called. */
5372 static tree
5374 tree instance;
5376 {
5378 {
5380 /* Check that we are not going through a cast of some sort. */
5384 /* fall through... */
5386 /* This is a call to a constructor, hence it's never zero. */
5388 {
5392 }
5396 /* This is a call to a constructor, hence it's never zero. */
5398 {
5402 }
5411 /* Propagate nonnull. */
5433 {
5437 }
5438 /* fall through... */
5442 {
5446 }
5448 {
5451 {
5452 /* Normally, 'this' must be non-null. */
5456 /* <0 means we're in a constructor and we know our type. */
5459 }
5461 /* Reference variables should be references to objects. */
5463 }
5468 }
5469 }
5471 /* Return non-zero if the dynamic type of INSTANCE is known, and equivalent
5472 to the static type. We also handle the case where INSTANCE is really
5473 a pointer.
5475 Used to determine whether the virtual function table is needed
5476 or not.
5478 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5479 of our knowledge of its type. *NONNULL should be initialized
5480 before this function is called. */
5482 int
5484 tree instance;
5486 {
5494 }
5496 \f
5497 void
5499 {
5502 current_class_stack
5520 }
5522 /* Set current scope to NAME. CODE tells us if this is a
5523 STRUCT, UNION, or ENUM environment.
5525 NAME may end up being NULL_TREE if this is an anonymous or
5526 late-bound struct (as in "struct { ... } foo;") */
5528 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE to
5529 appropriate values, found by looking up the type definition of
5530 NAME (as a CODE).
5532 If MODIFY is 1, we set IDENTIFIER_CLASS_VALUE's of names
5533 which can be seen locally to the class. They are shadowed by
5534 any subsequent local declaration (including parameter names).
5536 If MODIFY is 2, we set IDENTIFIER_CLASS_VALUE's of names
5537 which have static meaning (i.e., static members, static
5538 member functions, enum declarations, etc).
5540 If MODIFY is 3, we set IDENTIFIER_CLASS_VALUE of names
5541 which can be seen locally to the class (as in 1), but
5542 know that we are doing this for declaration purposes
5543 (i.e. friend foo::bar (int)).
5545 So that we may avoid calls to lookup_name, we cache the _TYPE
5546 nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
5548 For multiple inheritance, we perform a two-pass depth-first search
5549 of the type lattice. The first pass performs a pre-order search,
5550 marking types after the type has had its fields installed in
5551 the appropriate IDENTIFIER_CLASS_VALUE slot. The second pass merely
5552 unmarks the marked types. If a field or member function name
5553 appears in an ambiguous way, the IDENTIFIER_CLASS_VALUE of
5554 that name becomes `error_mark_node'. */
5556 void
5558 tree type;
5560 {
5563 /* Make sure there is enough room for the new entry on the stack. */
5565 {
5567 current_class_stack
5569 current_class_stack_size
5571 }
5573 /* Insert a new entry on the class stack. */
5578 current_class_depth++;
5580 /* Now set up the new type. */
5586 /* By default, things in classes are private, while things in
5587 structures or unions are public. */
5589 ? access_private_node
5596 {
5597 /* Forcibly remove any old class remnants. */
5599 }
5601 /* If we're about to enter a nested class, clear
5602 IDENTIFIER_CLASS_VALUE for the enclosing classes. */
5609 {
5612 else
5613 {
5614 tree item;
5616 /* We are re-entering the same class we just left, so we
5617 don't have to search the whole inheritance matrix to find
5618 all the decls to bind again. Instead, we install the
5619 cached class_shadowed list, and walk through it binding
5620 names and setting up IDENTIFIER_TYPE_VALUEs. */
5623 {
5630 }
5632 }
5635 }
5636 }
5638 /* When we exit a toplevel class scope, we save the
5639 IDENTIFIER_CLASS_VALUEs so that we can restore them quickly if we
5640 reenter the class. Here, we've entered some other class, so we
5641 must invalidate our cache. */
5643 void
5645 {
5646 tree t;
5648 /* The IDENTIFIER_CLASS_VALUEs are no longer valid. */
5654 }
5656 /* Get out of the current class scope. If we were in a class scope
5657 previously, that is the one popped to. */
5659 void
5661 {
5663 /* Since poplevel_class does the popping of class decls nowadays,
5664 this really only frees the obstack used for these decls. */
5667 current_class_depth--;
5673 }
5675 /* Returns 1 if current_class_type is either T or a nested type of T.
5676 We start looking from 1 because entry 0 is from global scope, and has
5677 no type. */
5679 int
5681 tree t;
5682 {
5690 }
5692 /* If either current_class_type or one of its enclosing classes are derived
5693 from T, return the appropriate type. Used to determine how we found
5694 something via unqualified lookup. */
5696 tree
5698 tree t;
5699 {
5710 }
5712 /* When entering a class scope, all enclosing class scopes' names with
5713 static meaning (static variables, static functions, types and enumerators)
5714 have to be visible. This recursive function calls pushclass for all
5715 enclosing class contexts until global or a local scope is reached.
5716 TYPE is the enclosed class and MODIFY is equivalent with the pushclass
5717 formal of the same name. */
5719 void
5721 tree type;
5723 {
5724 tree context;
5726 /* A namespace might be passed in error cases, like A::B:C. */
5740 }
5742 /* Undoes a push_nested_class call. MODIFY is passed on to popclass. */
5744 void
5746 {
5752 }
5754 /* Set global variables CURRENT_LANG_NAME to appropriate value
5755 so that behavior of name-mangling machinery is correct. */
5757 void
5759 tree name;
5760 {
5764 {
5769 }
5772 {
5774 }
5776 {
5778 /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
5779 (See record_builtin_java_type in decl.c.) However, that causes
5780 incorrect debug entries if these types are actually used.
5781 So we re-enable debug output after extern "Java". */
5790 }
5792 {
5794 }
5795 else
5797 }
5799 /* Get out of the current language scope. */
5801 void
5803 {
5804 /* Clear the current entry so that garbage collector won't hold on
5805 to it. */
5808 }
5809 \f
5810 /* Type instantiation routines. */
5812 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
5813 matches the TARGET_TYPE. If there is no satisfactory match, return
5814 error_mark_node, and issue an error message if COMPLAIN is
5815 non-zero. Permit pointers to member function if PTRMEM is non-zero.
5816 If TEMPLATE_ONLY, the name of the overloaded function
5817 was a template-id, and EXPLICIT_TARGS are the explicitly provided
5818 template arguments. */
5820 static tree
5822 overload,
5823 complain,
5824 ptrmem,
5825 template_only,
5826 explicit_targs)
5827 tree target_type;
5828 tree overload;
5832 tree explicit_targs;
5833 {
5834 /* Here's what the standard says:
5836 [over.over]
5838 If the name is a function template, template argument deduction
5839 is done, and if the argument deduction succeeds, the deduced
5840 arguments are used to generate a single template function, which
5841 is added to the set of overloaded functions considered.
5843 Non-member functions and static member functions match targets of
5844 type "pointer-to-function" or "reference-to-function." Nonstatic
5845 member functions match targets of type "pointer-to-member
5846 function;" the function type of the pointer to member is used to
5847 select the member function from the set of overloaded member
5848 functions. If a nonstatic member function is selected, the
5849 reference to the overloaded function name is required to have the
5850 form of a pointer to member as described in 5.3.1.
5852 If more than one function is selected, any template functions in
5853 the set are eliminated if the set also contains a non-template
5854 function, and any given template function is eliminated if the
5855 set contains a second template function that is more specialized
5856 than the first according to the partial ordering rules 14.5.5.2.
5857 After such eliminations, if any, there shall remain exactly one
5858 selected function. */
5862 /* We store the matches in a TREE_LIST rooted here. The functions
5863 are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
5864 interoperability with most_specialized_instantiation. */
5866 tree fn;
5868 /* By the time we get here, we should be seeing only real
5869 pointer-to-member types, not the internal POINTER_TYPE to
5870 METHOD_TYPE representation. */
5878 /* Check that the TARGET_TYPE is reasonable. */
5882 /* This is OK, too. */
5885 {
5886 /* This is OK, too. This comes from a conversion to reference
5887 type. */
5890 }
5891 else
5892 {
5898 }
5900 /* If we can find a non-template function that matches, we can just
5901 use it. There's no point in generating template instantiations
5902 if we're just going to throw them out anyhow. But, of course, we
5903 can only do this when we don't *need* a template function. */
5905 {
5906 tree fns;
5909 {
5911 tree fntype;
5914 /* We're not looking for templates just yet. */
5919 /* We're looking for a non-static member, and this isn't
5920 one, or vice versa. */
5923 /* See if there's a match. */
5932 }
5933 }
5935 /* Now, if we've already got a match (or matches), there's no need
5936 to proceed to the template functions. But, if we don't have a
5937 match we need to look at them, too. */
5939 {
5940 tree target_fn_type;
5941 tree target_arg_types;
5942 tree target_ret_type;
5943 tree fns;
5946 target_fn_type
5948 else
5953 /* Never do unification on the 'this' parameter. */
5958 {
5960 tree instantiation;
5961 tree instantiation_type;
5962 tree targs;
5965 /* We're only looking for templates. */
5970 /* We're not looking for a non-static member, and this is
5971 one, or vice versa. */
5974 /* Try to do argument deduction. */
5979 /* Argument deduction failed. */
5982 /* Instantiate the template. */
5985 /* Instantiation failed. */
5988 /* See if there's a match. */
5991 instantiation_type =
5997 }
5999 /* Now, remove all but the most specialized of the matches. */
6001 {
6006 }
6007 }
6009 /* Now we should have exactly one function in MATCHES. */
6011 {
6012 /* There were *no* matches. */
6014 {
6017 target_type);
6019 /* print_candidates expects a chain with the functions in
6020 TREE_VALUE slots, so we cons one up here (we're losing anyway,
6021 so why be clever?). */
6024 matches);
6027 }
6029 }
6031 {
6032 /* There were too many matches. */
6035 {
6036 tree match;
6040 target_type);
6042 /* Since print_candidates expects the functions in the
6043 TREE_VALUE slot, we flip them here. */
6048 }
6051 }
6053 /* Good, exactly one match. Now, convert it to the correct type. */
6058 {
6066 {
6069 }
6070 }
6075 else
6076 {
6077 /* The target must be a REFERENCE_TYPE. Above, build_unary_op
6078 will mark the function as addressed, but here we must do it
6079 explicitly. */
6083 }
6084 }
6086 /* This function will instantiate the type of the expression given in
6087 RHS to match the type of LHSTYPE. If errors exist, then return
6088 error_mark_node. FLAGS is a bit mask. If ITF_COMPLAIN is set, then
6089 we complain on errors. If we are not complaining, never modify rhs,
6090 as overload resolution wants to try many possible instantiations, in
6091 the hope that at least one will work.
6093 For non-recursive calls, LHSTYPE should be a function, pointer to
6094 function, or a pointer to member function. */
6096 tree
6100 {
6109 {
6113 }
6116 {
6123 }
6125 /* We don't overwrite rhs if it is an overloaded function.
6126 Copying it would destroy the tree link. */
6130 /* This should really only be used when attempting to distinguish
6131 what sort of a pointer to function we have. For now, any
6132 arithmetic operation which is not supported on pointers
6133 is rejected as an error. */
6136 {
6147 {
6148 tree new_rhs;
6158 }
6174 /* This can happen if we are forming a pointer-to-member for a
6175 member template. */
6178 /* Fall through. */
6181 {
6185 return
6187 fns,
6188 complain,
6189 allow_ptrmem,
6191 args);
6192 }
6195 return
6197 rhs,
6198 complain,
6199 allow_ptrmem,
6204 /* Now we should have a baselink. */
6210 /* This is too hard for now. */
6284 {
6288 }
6311 {
6316 }
6327 }
6328 }
6329 \f
6330 /* Return the name of the virtual function pointer field
6331 (as an IDENTIFIER_NODE) for the given TYPE. Note that
6332 this may have to look back through base types to find the
6333 ultimate field name. (For single inheritance, these could
6334 all be the same name. Who knows for multiple inheritance). */
6336 static tree
6338 tree type;
6339 {
6353 }
6355 void
6357 {
6358 #ifdef GATHER_STATISTICS
6364 {
6369 }
6370 #endif
6371 }
6373 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
6374 according to [class]:
6375 The class-name is also inserted
6376 into the scope of the class itself. For purposes of access checking,
6377 the inserted class name is treated as if it were a public member name. */
6379 void
6381 {
6384 tree saved_cas;
6397 }
6399 /* Returns 1 if TYPE contains only padding bytes. */
6401 int
6403 tree type;
6404 {
6412 }
6414 /* Find the enclosing class of the given NODE. NODE can be a *_DECL or
6415 a *_TYPE node. NODE can also be a local class. */
6417 tree
6419 tree type;
6420 {
6424 {
6426 {
6439 }
6440 }
6442 }
6444 /* Return 1 if TYPE or one of its enclosing classes is derived from BASE. */
6446 int
6449 {
6451 {
6456 }
6458 }
6460 /* Note that NAME was looked up while the current class was being
6461 defined and that the result of that lookup was DECL. */
6463 void
6465 tree name;
6466 tree decl;
6467 {
6468 splay_tree names_used;
6470 /* If we're not defining a class, there's nothing to do. */
6474 /* If there's already a binding for this NAME, then we don't have
6475 anything to worry about. */
6487 }
6489 /* Note that NAME was declared (as DECL) in the current class. Check
6490 to see that the declaration is legal. */
6492 void
6494 tree name;
6495 tree decl;
6496 {
6497 splay_tree names_used;
6498 splay_tree_node n;
6500 /* Look to see if we ever used this name. */
6501 names_used
6508 {
6509 /* [basic.scope.class]
6511 A name N used in a class S shall refer to the same declaration
6512 in its context and when re-evaluated in the completed scope of
6513 S. */
6518 }
6519 }
6521 /* Returns the VAR_DECL for the complete vtable associated with
6522 BINFO. (Under the new ABI, secondary vtables are merged with
6523 primary vtables; this function will return the VAR_DECL for the
6524 primary vtable.) */
6526 tree
6528 tree binfo;
6529 {
6530 tree decl;
6534 {
6538 }
6542 }
6544 /* Called from get_primary_binfo via dfs_walk. */
6546 static tree
6548 tree binfo;
6550 {
6558 }
6560 /* Returns the binfo for the primary base of BINFO. Note that in a
6561 complex hierarchy the resulting BINFO may not actually *be*
6562 primary. In particular if the resulting BINFO is a virtual base,
6563 and it occurs elsewhere in the hierarchy, then this occurrence may
6564 not actually be a primary base in the complete object. Check
6565 BINFO_PRIMARY_P to be sure. */
6567 tree
6569 tree binfo;
6570 {
6571 tree primary_base;
6572 tree result;
6578 /* A non-virtual primary base is always a direct base, and easy to
6579 find. */
6581 {
6584 /* Scan the direct basetypes until we find a base with the same
6585 type as the primary base. */
6587 {
6593 }
6595 /* We should always find the primary base. */
6597 }
6599 /* For a primary virtual base, we have to scan the entire hierarchy
6600 rooted at BINFO; the virtual base could be an indirect virtual
6601 base. */
6605 }
6607 /* Dump the offsets of all the bases rooted at BINFO (in the hierarchy
6608 dominated by T) to stderr. INDENT should be zero when called from
6609 the top level; it is incremented recursively. */
6611 static void
6614 tree t;
6615 tree binfo;
6617 {
6630 {
6635 else
6637 }
6648 }
6650 /* Dump the BINFO hierarchy for T. */
6652 void
6655 tree t;
6656 {
6660 {
6667 }
6674 }
6676 /* Virtual function table initialization. */
6678 /* Create all the necessary vtables for T and its base classes. */
6680 static void
6682 tree t;
6683 {
6685 {
6686 tree list;
6687 tree vbase;
6689 /* Under the new ABI, we lay out the primary and secondary
6690 vtables in one contiguous vtable. The primary vtable is
6691 first, followed by the non-virtual secondary vtables in
6692 inheritance graph order. */
6696 /* Then come the virtual bases, also in inheritance graph
6697 order. */
6699 {
6700 tree real_base;
6705 /* Although we walk in inheritance order, that might not get the
6706 canonical base. */
6711 }
6715 }
6716 else
6717 {
6722 }
6723 }
6725 /* Called from finish_vtbls via dfs_walk. */
6727 static tree
6729 tree binfo;
6731 {
6742 }
6744 /* Initialize the vtable for BINFO with the INITS. */
6746 static void
6748 tree binfo;
6749 tree inits;
6750 {
6751 tree decl;
6756 }
6758 /* Initialize DECL (a declaration for a namespace-scope array) with
6759 the INITS. */
6761 static void
6763 tree decl;
6764 tree inits;
6765 {
6766 tree context;
6773 }
6775 /* Build the VTT (virtual table table) for T.
6776 A class requires a VTT if it has virtual bases.
6778 This holds
6779 1 - primary virtual pointer for complete object T
6780 2 - secondary VTTs for each direct non-virtual base of T which requires a VTT
6781 3 - secondary virtual pointers for each direct or indirect base of T which
6782 has virtual bases or is reachable via a virtual path from T.
6783 4 - secondary VTTs for each direct or indirect virtual base of T.
6785 Secondary VTTs look like complete object VTTs without part 4. */
6787 static void
6789 tree t;
6790 {
6791 tree inits;
6792 tree type;
6793 tree vtt;
6794 tree index;
6796 /* Build up the initializers for the VTT. */
6801 /* If we didn't need a VTT, we're done. */
6805 /* Figure out the type of the VTT. */
6809 /* Now, build the VTT object itself. */
6813 }
6815 /* The type corresponding to BINFO is a base class of T, but BINFO is
6816 in the base class hierarchy of a class derived from T. Return the
6817 base, in T's hierarchy, that corresponds to BINFO. */
6819 static tree
6821 tree binfo;
6822 tree t;
6823 {
6824 tree derived;
6841 }
6843 /* Recursively build the VTT-initializer for BINFO (which is in the
6844 hierarchy dominated by T). INITS points to the end of the initializer
6845 list to date. INDEX is the VTT index where the next element will be
6846 replaced. Iff BINFO is the binfo for T, this is the top level VTT (i.e.
6847 not a subvtt for some base of T). When that is so, we emit the sub-VTTs
6848 for virtual bases of T. When it is not so, we build the constructor
6849 vtables for the BINFO-in-T variant. */
6853 tree binfo;
6854 tree t;
6857 {
6859 tree b;
6860 tree init;
6861 tree secondary_vptrs;
6864 /* We only need VTTs for subobjects with virtual bases. */
6868 /* We need to use a construction vtable if this is not the primary
6869 VTT. */
6871 {
6874 /* Record the offset in the VTT where this sub-VTT can be found. */
6876 }
6878 /* Add the address of the primary vtable for the complete object. */
6885 {
6888 }
6891 /* Recursively add the secondary VTTs for non-virtual bases. */
6893 {
6898 }
6900 /* Add secondary virtual pointers for all subobjects of BINFO with
6901 either virtual bases or reachable along a virtual path, except
6902 subobjects that are non-virtual primary bases. */
6909 dfs_build_secondary_vptr_vtt_inits,
6910 NULL,
6911 dfs_ctor_vtable_bases_queue_p,
6912 secondary_vptrs);
6915 secondary_vptrs);
6919 /* The secondary vptrs come back in reverse order. After we reverse
6920 them, and add the INITS, the last init will be the first element
6921 of the chain. */
6924 {
6928 }
6930 /* Add the secondary VTTs for virtual bases. */
6933 {
6934 tree vbase;
6941 }
6944 {
6950 dfs_ctor_vtable_bases_queue_p,
6951 data);
6952 }
6955 }
6957 /* Called from build_vtt_inits via dfs_walk. BINFO is the binfo
6958 for the base in most derived. DATA is a TREE_LIST who's
6959 TREE_CHAIN is the type of the base being
6960 constructed whilst this secondary vptr is live. The TREE_UNSIGNED
6961 flag of DATA indicates that this is a constructor vtable. The
6962 TREE_TOP_LEVEL flag indicates that this is the primary VTT. */
6964 static tree
6966 tree binfo;
6968 {
6969 tree l;
6970 tree t;
6971 tree init;
6972 tree index;
6981 /* We don't care about bases that don't have vtables. */
6985 /* We're only interested in proper subobjects of T. */
6989 /* We're not interested in non-virtual primary bases. */
6993 /* If BINFO has virtual bases or is reachable via a virtual path
6994 from T, it'll have a secondary vptr. */
6999 /* Record the index where this secondary vptr can be found. */
7002 {
7005 }
7009 /* Add the initializer for the secondary vptr itself. */
7011 {
7012 /* It's a primary virtual base, and this is not the construction
7013 vtable. Find the base this is primary of in the inheritance graph,
7014 and use that base's vtable now. */
7017 }
7024 }
7026 /* dfs_walk_real predicate for building vtables. DATA is a TREE_LIST,
7027 TREE_UNSIGNED indicates that a constructor vtable is being built.
7028 TREE_USED indicates whether marked or unmarked bases should be walked.
7029 TREE_PURPOSE is the TREE_TYPE that dominates the hierarchy. */
7031 static tree
7033 tree binfo;
7035 {
7037 {
7040 /* This is a non-primary virtual base, get the shared version. */
7044 }
7048 }
7050 /* Called from build_vtt_inits via dfs_walk. After building constructor
7051 vtables and generating the sub-vtt from them, we need to restore the
7052 BINFO_VTABLES that were scribbled on. DATA is a TREE_LIST whose
7053 TREE_VALUE is the TREE_TYPE of the base whose sub vtt was generated. */
7055 static tree
7057 tree binfo;
7059 {
7062 /* We don't care about bases that don't have vtables. */
7066 /* If we scribbled the construction vtable vptr into BINFO, clear it
7067 out now. */
7074 }
7076 /* Build the construction vtable group for BINFO which is in the
7077 hierarchy dominated by T. */
7079 static void
7081 tree binfo;
7082 tree t;
7083 {
7084 tree list;
7085 tree type;
7086 tree vtbl;
7087 tree inits;
7088 tree id;
7089 tree vbase;
7091 /* See if we've already create this construction vtable group. */
7097 /* Build a version of VTBL (with the wrong type) for use in
7098 constructing the addresses of secondary vtables in the
7099 construction vtable group. */
7105 /* Add the vtables for each of our virtual bases using the vbase in T
7106 binfo. */
7108 vbase;
7110 {
7111 tree b;
7112 tree orig_base;
7120 }
7123 /* Figure out the type of the construction vtable. */
7128 /* Initialize the construction vtable. */
7131 }
7133 /* Add the vtbl initializers for BINFO (and its bases other than
7134 non-virtual primaries) to the list of INITS. BINFO is in the
7135 hierarchy dominated by T. RTTI_BINFO is the binfo within T of
7136 the constructor the vtbl inits should be accumulated for. (If this
7137 is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
7138 ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
7139 BINFO is the active base equivalent of ORIG_BINFO in the inheritance
7140 graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
7141 but are not necessarily the same in terms of layout. */
7143 static void
7145 tree binfo;
7146 tree orig_binfo;
7147 tree rtti_binfo;
7148 tree t;
7149 tree inits;
7150 {
7158 /* If we're building a construction vtable, we're not interested in
7159 subobjects that don't require construction vtables. */
7165 /* Build the initializers for the BINFO-in-T vtable. */
7171 /* Walk the BINFO and its bases. We walk in preorder so that as we
7172 initialize each vtable we can figure out at what offset the
7173 secondary vtable lies from the primary vtable. We can't use
7174 dfs_walk here because we need to iterate through bases of BINFO
7175 and RTTI_BINFO simultaneously. */
7177 {
7180 /* Skip virtual bases. */
7186 inits);
7187 }
7188 }
7190 /* Called from accumulate_vtbl_inits when using the new ABI.
7191 Accumulates the vtable initializers for all of the vtables into
7192 TREE_VALUE (DATA). Returns the initializers for the BINFO vtable. */
7194 static tree
7196 tree binfo;
7197 tree orig_binfo;
7198 tree rtti_binfo;
7199 tree t;
7200 tree l;
7201 {
7208 {
7209 /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a primary
7210 virtual base. If it is not the same primary in the hierarchy of T,
7211 we'll need to generate a ctor vtable for it, to place at its
7212 location in T. If it is the same primary, we still need a VTT
7213 entry for the vtable, but that must be the base it is a
7214 primary for within the sub-hierarchy of RTTI_BINFO. */
7215 tree parent;
7217 tree primary_for;
7222 primary_for;
7224 {
7226 parent;
7228 {
7230 {
7233 }
7234 }
7237 }
7239 {
7242 {
7246 }
7247 }
7248 }
7253 {
7254 tree index;
7257 /* Compute the initializer for this vtable. */
7261 /* Figure out the position to which the VPTR should point. */
7264 vtbl_ptr_type_node,
7265 vtbl);
7271 index);
7274 }
7277 {
7278 /* For an ordinary vtable, set BINFO_VTABLE. */
7282 }
7283 else
7284 /* For a construction vtable, we can't overwrite BINFO_VTABLE.
7285 So, we make a TREE_LIST. Later, dfs_fixup_binfo_vtbls will
7286 straighten this out. */
7290 }
7292 /* Construct the initializer for BINFOs virtual function table. BINFO
7293 is part of the hierarchy dominated by T. If we're building a
7294 construction vtable, the ORIG_BINFO is the binfo we should use to
7295 find the actual function pointers to put in the vtable - but they
7296 can be overridden on the path to most-derived in the graph that
7297 ORIG_BINFO belongs. Otherwise,
7298 ORIG_BINFO should be the same as BINFO. The RTTI_BINFO is the
7299 BINFO that should be indicated by the RTTI information in the
7300 vtable; it will be a base class of T, rather than T itself, if we
7301 are building a construction vtable.
7303 The value returned is a TREE_LIST suitable for wrapping in a
7304 CONSTRUCTOR to use as the DECL_INITIAL for a vtable. If
7305 NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
7306 number of non-function entries in the vtable.
7308 It might seem that this function should never be called with a
7309 BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
7310 base is always subsumed by a derived class vtable. However, when
7311 we are building construction vtables, we do build vtables for
7312 primary bases; we need these while the primary base is being
7313 constructed. */
7315 static tree
7317 tree binfo;
7318 tree orig_binfo;
7319 tree t;
7320 tree rtti_binfo;
7322 {
7323 tree v;
7324 tree vfun_inits;
7325 tree vbase;
7326 vtbl_init_data vid;
7328 /* Initialize VID. */
7335 /* The first vbase or vcall offset is at index -3 in the vtable. */
7338 /* Add entries to the vtable for RTTI. */
7341 /* Create an array for keeping track of the functions we've
7342 processed. When we see multiple functions with the same
7343 signature, we share the vcall offsets. */
7345 /* Add the vcall and vbase offset entries. */
7347 /* Clean up. */
7349 /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
7350 build_vbase_offset_vtbl_entries. */
7352 vbase;
7359 /* Go through all the ordinary virtual functions, building up
7360 initializers. */
7363 {
7364 tree delta;
7365 tree vcall_index;
7366 tree fn;
7367 tree pfn;
7368 tree init;
7370 /* Pull the offset for `this', and the function to call, out of
7371 the list. */
7375 {
7378 }
7379 else
7386 /* You can't call an abstract virtual function; it's abstract.
7387 So, we replace these functions with __pure_virtual. */
7391 /* Take the address of the function, considering it to be of an
7392 appropriate generic type. */
7394 /* The address of a function can't change. */
7396 /* Enter it in the vtable. */
7399 /* And add it to the chain of initializers. */
7401 }
7403 /* The initializers for virtual functions were built up in reverse
7404 order; straighten them out now. */
7407 /* The negative offset initializers are also in reverse order. */
7410 /* Chain the two together. */
7412 }
7414 /* Sets vid->inits to be the initializers for the vbase and vcall
7415 offsets in BINFO, which is in the hierarchy dominated by T. */
7417 static void
7419 tree binfo;
7421 {
7422 tree b;
7424 /* If this is a derived class, we must first create entries
7425 corresponding to the primary base class. */
7430 /* Add the vbase entries for this base. */
7432 /* Add the vcall entries for this base. */
7434 }
7436 /* Returns the initializers for the vbase offset entries in the vtable
7437 for BINFO (which is part of the class hierarchy dominated by T), in
7438 reverse order. VBASE_OFFSET_INDEX gives the vtable index
7439 where the next vbase offset will go. */
7441 static void
7443 tree binfo;
7445 {
7446 tree vbase;
7447 tree t;
7449 /* Under the old ABI, pointers to virtual bases are stored in each
7450 object. */
7454 /* If there are no virtual baseclasses, then there is nothing to
7455 do. */
7461 /* Go through the virtual bases, adding the offsets. */
7463 vbase;
7465 {
7466 tree b;
7467 tree delta;
7472 /* Find the instance of this virtual base in the complete
7473 object. */
7476 /* If we've already got an offset for this virtual base, we
7477 don't need another one. */
7482 /* Figure out where we can find this vbase offset. */
7491 {
7492 tree orig_vbase;
7494 /* Find the instance of this virtual base in the type of BINFO. */
7498 /* The vbase offset had better be the same. */
7502 }
7504 /* The next vbase will come at a more negative offset. */
7507 /* The initializer is the delta from BINFO to this virtual base.
7508 The vbase offsets go in reverse inheritance-graph order, and
7509 we are walking in inheritance graph order so these end up in
7510 the right order. */
7515 vtable_entry_type,
7516 delta)));
7518 }
7519 }
7521 /* Adds the initializers for the vcall offset entries in the vtable
7522 for BINFO (which is part of the class hierarchy dominated by T) to
7523 VID->INITS. */
7525 static void
7527 tree binfo;
7529 {
7530 /* Under the old ABI, the adjustments to the `this' pointer were made
7531 elsewhere. */
7535 /* We only need these entries if this base is a virtual base. */
7539 /* We need a vcall offset for each of the virtual functions in this
7540 vtable. For example:
7542 class A { virtual void f (); };
7543 class B : virtual public A { };
7544 class C: virtual public A, public B {};
7546 Now imagine:
7548 B* b = new C;
7549 b->f();
7551 The location of `A' is not at a fixed offset relative to `B'; the
7552 offset depends on the complete object derived from `B'. So,
7553 `B' vtable contains an entry for `f' that indicates by what
7554 amount the `this' pointer for `B' needs to be adjusted to arrive
7555 at `A'.
7557 We need entries for all the functions in our primary vtable and
7558 in our non-virtual bases vtables. */
7560 /* Now, walk through the non-virtual bases, adding vcall offsets. */
7562 }
7564 /* Build vcall offsets, starting with those for BINFO. */
7566 static void
7568 tree binfo;
7570 {
7572 tree primary_binfo;
7574 /* Don't walk into virtual bases -- except, of course, for the
7575 virtual base for which we are building vcall offsets. */
7579 /* If BINFO has a primary base, process it first. */
7584 /* Add BINFO itself to the list. */
7587 /* Scan the non-primary bases of BINFO. */
7589 {
7590 tree base_binfo;
7595 }
7596 }
7598 /* Called from build_vcall_offset_vtbl_entries_r. */
7600 static void
7602 tree binfo;
7604 {
7605 tree derived_virtuals;
7606 tree base_virtuals;
7607 tree orig_virtuals;
7608 tree binfo_inits;
7609 /* If BINFO is a primary base, this is the least derived class of
7610 BINFO that is not a primary base. */
7611 tree non_primary_binfo;
7615 /* We might be a primary base class. Go up the inheritance
7616 hierarchy until we find the class of which we are a primary base:
7617 it is the BINFO_VIRTUALS there that we need to consider. */
7620 {
7621 tree b;
7623 /* If we have reached a virtual base, then it must be the
7624 virtual base for which we are building vcall offsets. In
7625 turn, the virtual base must be a (possibly indirect) primary
7626 base of the class that we are initializing, or we wouldn't
7627 care about its vtable offsets. */
7629 {
7632 }
7638 }
7640 /* Make entries for the rest of the virtuals. */
7644 base_virtuals;
7648 {
7649 tree orig_fn;
7650 tree fn;
7651 tree base;
7652 tree base_binfo;
7655 /* Find the declaration that originally caused this function to
7656 be present. */
7659 /* We do not need an entry if this function is declared in a
7660 virtual base (or one of its virtual bases), and not
7661 overridden in the section of the hierarchy dominated by the
7662 virtual base for which we are building vcall offsets. */
7666 /* Find the overriding function. */
7669 /* If there is already an entry for a function with the same
7670 signature as FN, then we do not need a second vcall offset.
7671 Check the list of functions already present in the derived
7672 class vtable. */
7674 {
7675 tree derived_entry;
7679 {
7683 }
7684 }
7688 /* The FN comes from BASE. So, we must calculate the adjustment
7689 from the virtual base that derived from BINFO to BASE. */
7693 /* Compute the vcall offset. */
7695 = (build_tree_list
7702 /* Keep track of the vtable index where this vcall offset can be
7703 found. For a construction vtable, we already made this
7704 annotation when we build the original vtable. */
7708 /* The next vcall offset will be found at a more negative
7709 offset. */
7712 /* Keep track of this function. */
7714 }
7715 }
7717 /* Return vtbl initializers for the RTTI entries coresponding to the
7718 BINFO's vtable. The RTTI entries should indicate the object given
7719 by RTTI_BINFO. */
7721 static void
7723 tree binfo;
7724 tree rtti_binfo;
7726 {
7727 tree b;
7728 tree t;
7729 tree basetype;
7730 tree offset;
7731 tree decl;
7732 tree init;
7737 /* For a COM object there is no RTTI entry. */
7741 /* To find the complete object, we will first convert to our most
7742 primary base, and then add the offset in the vtbl to that value. */
7746 {
7747 tree primary_base;
7752 }
7755 /* The second entry is, in the case of the new ABI, the address of
7756 the typeinfo object, or, in the case of the old ABI, a function
7757 which returns a typeinfo object. */
7759 {
7762 else
7765 /* Convert the declaration to a type that can be stored in the
7766 vtable. */
7769 }
7770 else
7771 {
7774 else
7777 /* Convert the declaration to a type that can be stored in the
7778 vtable. */
7783 }
7787 /* Add the offset-to-top entry. It comes earlier in the vtable that
7788 the the typeinfo entry. */
7790 {
7791 /* Convert the offset to look like a function pointer, so that
7792 we can put it in the vtable. */
7797 }
7798 }
7800 /* Build an entry in the virtual function table. DELTA is the offset
7801 for the `this' pointer. VCALL_INDEX is the vtable index containing
7802 the vcall offset; zero if none. ENTRY is the virtual function
7803 table entry itself. It's TREE_TYPE must be VFUNC_PTR_TYPE_NODE,
7804 but it may not actually be a virtual function table pointer. (For
7805 example, it might be the address of the RTTI object, under the new
7806 ABI.) */
7808 static tree
7810 tree delta;
7811 tree vcall_index;
7812 tree entry;
7814 {
7816 {
7817 tree fn;
7823 {
7825 generate_with_vtable_p);
7829 }
7830 #ifdef GATHER_STATISTICS
7832 #endif
7834 }
7835 else
7836 {
7842 /* We don't use vcall offsets when not using vtable thunks. */
7845 /* DELTA used to be constructed by `size_int' and/or size_binop,
7846 which caused overflow problems when it was negative. That should
7847 be fixed now. */
7850 {
7853 else
7854 sorry ("object size exceeds normal limit for virtual function table implementation, recompile all source and use -fhuge-objects");
7855 }
7861 #ifdef GATHER_STATISTICS
7863 #endif
7866 }
7867 }