| blob | 4512950745bbb201e2d7d0618d58481ff727cbd3 |
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, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GCC.
8 GCC 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 GCC 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 GCC; 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. */
39 /* The number of nested classes being processed. If we are not in the
40 scope of any class, this is zero. */
44 /* In order to deal with nested classes, we keep a stack of classes.
45 The topmost entry is the innermost class, and is the entry at index
46 CURRENT_CLASS_DEPTH */
49 /* The name of the class. */
50 tree name;
52 /* The _TYPE node for the class. */
53 tree type;
55 /* The access specifier pending for new declarations in the scope of
56 this class. */
57 tree access;
59 /* If were defining TYPE, the names used in this class. */
60 splay_tree names_used;
64 {
65 /* The base for which we're building initializers. */
66 tree binfo;
67 /* The type of the most-derived type. */
68 tree derived;
69 /* The binfo for the dynamic type. This will be TYPE_BINFO (derived),
70 unless ctor_vtbl_p is true. */
71 tree rtti_binfo;
72 /* The negative-index vtable initializers built up so far. These
73 are in order from least negative index to most negative index. */
74 tree inits;
75 /* The last (i.e., most negative) entry in INITS. */
77 /* The binfo for the virtual base for which we're building
78 vcall offset initializers. */
79 tree vbase;
80 /* The functions in vbase for which we have already provided vcall
81 offsets. */
82 varray_type fns;
83 /* The vtable index of the next vcall or vbase offset. */
84 tree index;
85 /* Nonzero if we are building the initializer for the primary
86 vtable. */
88 /* Nonzero if we are building the initializer for a construction
89 vtable. */
91 /* True when adding vcall offset entries to the vtable. False when
92 merely computing the indices. */
96 /* The type of a function passed to walk_subobject_offsets. */
99 /* The stack itself. This is a dynamically resized array. The
100 number of elements allocated is CURRENT_CLASS_STACK_SIZE. */
104 /* An array of all local classes present in this translation unit, in
105 declaration order. */
106 varray_type local_classes;
178 tree);
197 splay_tree_key k2);
206 /* Variables shared between class.c and call.c. */
208 #ifdef GATHER_STATISTICS
216 #endif
218 /* Convert to or from a base subobject. EXPR is an expression of type
219 `A' or `A*', an expression of type `B' or `B*' is returned. To
220 convert A to a base B, CODE is PLUS_EXPR and BINFO is the binfo for
221 the B base instance within A. To convert base A to derived B, CODE
222 is MINUS_EXPR and BINFO is the binfo for the A instance within B.
223 In this latter case, A must not be a morally virtual base of B.
224 NONNULL is true if EXPR is known to be non-NULL (this is only
225 needed when EXPR is of pointer type). CV qualifiers are preserved
226 from EXPR. */
228 tree
230 tree expr,
231 tree binfo,
233 {
236 tree probe;
237 tree offset;
238 tree target_type;
240 tree ptr_target_type;
250 {
256 }
268 /* Nothing to do. */
272 {
276 }
279 /* This must happen before the call to save_expr. */
285 /* Do we need to look in the vtable for the real offset? */
288 /* Do we need to check for a null pointer? */
292 /* Protect against multiple evaluation if necessary. */
296 /* Now that we've saved expr, build the real null test. */
298 {
302 }
304 /* If this is a simple base reference, express it as a COMPONENT_REF. */
306 /* We don't build base fields for empty bases, and they aren't very
307 interesting to the optimizers anyway. */
309 {
316 }
319 {
320 /* Going via virtual base V_BINFO. We need the static offset
321 from V_BINFO to BINFO, and the dynamic offset from D_BINFO to
322 V_BINFO. That offset is an entry in D_BINFO's vtable. */
323 tree v_offset;
326 {
327 /* In a base member initializer, we cannot rely on
328 the vtable being set up. We have to use the vtt_parm. */
330 tree t;
338 }
339 else
347 v_offset);
360 /* Negative fixed_type_p means this is a constructor or destructor;
361 virtual base layout is fixed in in-charge [cd]tors, but not in
362 base [cd]tors. */
366 v_offset,
368 else
370 }
374 target_type = cp_build_qualified_type
384 else
390 out:
394 integer_zero_node))));
397 }
399 /* Subroutine of build_base_path; EXPR and BINFO are as in that function.
400 Perform a derived-to-base conversion by recursively building up a
401 sequence of COMPONENT_REFs to the appropriate base fields. */
403 static tree
405 {
408 tree field;
411 {
414 }
416 /* Recurse. */
421 /* Is this the base field created by build_base_field? */
428 /* Didn't find the base field?!? */
430 }
432 /* Convert OBJECT to the base TYPE. OBJECT is an expression whose
433 type is a class type or a pointer to a class type. In the former
434 case, TYPE is also a class type; in the latter it is another
435 pointer type. If CHECK_ACCESS is true, an error message is emitted
436 if TYPE is inaccessible. If OBJECT has pointer type, the value is
437 assumed to be non-NULL. */
439 tree
441 {
442 tree binfo;
443 tree object_type;
446 {
449 }
450 else
455 NULL);
460 }
462 /* EXPR is an expression with unqualified class type. BASE is a base
463 binfo of that class type. Returns EXPR, converted to the BASE
464 type. This function assumes that EXPR is the most derived class;
465 therefore virtual bases can be found at their static offsets. */
467 tree
469 {
470 tree expr_type;
474 {
475 tree pointer_type;
484 }
487 }
489 \f
490 tree
492 {
498 /* First, convert to the requested type. */
503 /* Second, the requested type may not be the owner of its own vptr.
504 If not, convert to the base class that owns it. We cannot use
505 convert_to_base here, because VCONTEXT may appear more than once
506 in the inheritance hierarchy of TYPE, and thus direct conversion
507 between the types may be ambiguous. Following the path back up
508 one step at a time via primary bases avoids the problem. */
512 {
515 }
518 }
520 /* Given an object INSTANCE, return an expression which yields the
521 vtable element corresponding to INDEX. There are many special
522 cases for INSTANCE which we take care of here, mainly to avoid
523 creating extra tree nodes when we don't have to. */
525 static tree
527 {
528 tree aref;
531 /* Try to figure out what a reference refers to, and
532 access its virtual function table directly. */
540 {
545 }
557 }
559 tree
561 {
565 }
567 /* Given a stable object pointer INSTANCE_PTR, return an expression which
568 yields a function pointer corresponding to vtable element INDEX. */
570 tree
572 {
573 tree aref;
577 /* When using function descriptors, the address of the
578 vtable entry is treated as a function pointer. */
583 /* Remember this as a method reference, for later devirtualization. */
587 }
589 /* Return the name of the virtual function table (as an IDENTIFIER_NODE)
590 for the given TYPE. */
592 static tree
594 {
596 }
598 /* Return an IDENTIFIER_NODE for the name of the virtual table table
599 for TYPE. */
601 tree
603 {
605 }
607 /* DECL is an entity associated with TYPE, like a virtual table or an
608 implicitly generated constructor. Determine whether or not DECL
609 should have external or internal linkage at the object file
610 level. This routine does not deal with COMDAT linkage and other
611 similar complexities; it simply sets TREE_PUBLIC if it possible for
612 entities in other translation units to contain copies of DECL, in
613 the abstract. */
615 void
617 {
618 /* If TYPE involves a local class in a function with internal
619 linkage, then DECL should have internal linkage too. Other local
620 classes have no linkage -- but if their containing functions
621 have external linkage, it makes sense for DECL to have external
622 linkage too. That will allow template definitions to be merged,
623 for example. */
625 {
628 }
629 else
631 }
633 /* Create a VAR_DECL for a primary or secondary vtable for CLASS_TYPE.
634 (For a secondary vtable for B-in-D, CLASS_TYPE should be D, not B.)
635 Use NAME for the name of the vtable, and VTABLE_TYPE for its type. */
637 static tree
639 {
640 tree decl;
643 /* vtable names are already mangled; give them their DECL_ASSEMBLER_NAME
644 now to avoid confusion in mangle_decl. */
653 /* At one time the vtable info was grabbed 2 words at a time. This
654 fails on sparc unless you have 8-byte alignment. (tiemann) */
658 /* The vtable has not been defined -- yet. */
662 /* Mark the VAR_DECL node representing the vtable itself as a
663 "gratuitous" one, thereby forcing dwarfout.c to ignore it. It
664 is rather important that such things be ignored because any
665 effort to actually generate DWARF for them will run into
666 trouble when/if we encounter code like:
668 #pragma interface
669 struct S { virtual void member (); };
671 because the artificial declaration of the vtable itself (as
672 manufactured by the g++ front end) will say that the vtable is
673 a static member of `S' but only *after* the debug output for
674 the definition of `S' has already been output. This causes
675 grief because the DWARF entry for the definition of the vtable
676 will try to refer back to an earlier *declaration* of the
677 vtable as a static member of `S' and there won't be one. We
678 might be able to arrange to have the "vtable static member"
679 attached to the member list for `S' before the debug info for
680 `S' get written (which would solve the problem) but that would
681 require more intrusive changes to the g++ front end. */
685 }
687 /* Get the VAR_DECL of the vtable for TYPE. TYPE need not be polymorphic,
688 or even complete. If this does not exist, create it. If COMPLETE is
689 nonzero, then complete the definition of it -- that will render it
690 impossible to actually build the vtable, but is useful to get at those
691 which are known to exist in the runtime. */
693 tree
695 {
696 tree decl;
705 {
708 }
711 }
713 /* Build the primary virtual function table for TYPE. If BINFO is
714 non-NULL, build the vtable starting with the initial approximation
715 that it is the same as the one which is the head of the association
716 list. Returns a nonzero value if a new vtable is actually
717 created. */
719 static int
721 {
722 tree decl;
723 tree virtuals;
728 {
730 /* We have already created a vtable for this base, so there's
731 no need to do it again. */
738 }
739 else
740 {
743 }
745 #ifdef GATHER_STATISTICS
748 #endif
750 /* Initialize the association list for this type, based
751 on our first approximation. */
756 }
758 /* Give BINFO a new virtual function table which is initialized
759 with a skeleton-copy of its original initialization. The only
760 entry that changes is the `delta' entry, so we can really
761 share a lot of structure.
763 FOR_TYPE is the most derived type which caused this table to
764 be needed.
766 Returns nonzero if we haven't met BINFO before.
768 The order in which vtables are built (by calling this function) for
769 an object must remain the same, otherwise a binary incompatibility
770 can result. */
772 static int
774 {
776 /* We already created a vtable for this base. There's no need to
777 do it again. */
780 /* Remember that we've created a vtable for this BINFO, so that we
781 don't try to do so again. */
784 /* Make fresh virtual list, so we can smash it later. */
787 /* Secondary vtables are laid out as part of the same structure as
788 the primary vtable. */
791 }
793 /* Create a new vtable for BINFO which is the hierarchy dominated by
794 T. Return nonzero if we actually created a new vtable. */
796 static int
798 {
800 /* In this case, it is *type*'s vtable we are modifying. We start
801 with the approximation that its vtable is that of the
802 immediate base class. */
804 else
805 /* This is our very own copy of `basetype' to play with. Later,
806 we will fill in all the virtual functions that override the
807 virtual functions in these base classes which are not defined
808 by the current type. */
810 }
812 /* Make *VIRTUALS, an entry on the BINFO_VIRTUALS list for BINFO
813 (which is in the hierarchy dominated by T) list FNDECL as its
814 BV_FN. DELTA is the required constant adjustment from the `this'
815 pointer where the vtable entry appears to the `this' required when
816 the function is actually called. */
818 static void
820 tree binfo,
821 tree fndecl,
822 tree delta,
824 {
825 tree v;
831 {
832 /* We need a new vtable for BINFO. */
834 {
835 /* If we really did make a new vtable, we also made a copy
836 of the BINFO_VIRTUALS list. Now, we have to find the
837 corresponding entry in that list. */
842 }
847 }
848 }
850 \f
851 /* Add method METHOD to class TYPE. */
853 void
855 {
858 tree overload;
864 tree current_fns;
878 {
879 /* Make a new method vector. We start with 8 entries. We must
880 allocate at least two (for constructors and destructors), and
881 we're going to end up with an assignment operator at some
882 point as well. */
884 /* Create slots for constructors and destructors. */
888 }
890 /* Constructors and destructors go in special slots. */
894 {
903 }
904 else
905 {
906 tree m;
909 /* See if we already have an entry with this name. */
913 {
916 {
921 }
925 {
928 }
933 }
934 }
938 /* TYPE is a template class. Don't issue any errors now; wait
939 until instantiation time to complain. */
940 ;
941 else
942 {
943 tree fns;
945 /* Check to see if we've already got this method. */
947 {
949 tree parms1;
950 tree parms2;
956 /* [over.load] Member function declarations with the
957 same name and the same parameter types cannot be
958 overloaded if any of them is a static member
959 function declaration.
961 [namespace.udecl] When a using-declaration brings names
962 from a base class into a derived class scope, member
963 functions in the derived class override and/or hide member
964 functions with the same name and parameter types in a base
965 class (rather than conflicting). */
969 /* Compare the quals on the 'this' parm. Don't compare
970 the whole types, as used functions are treated as
971 coming from the using class in overload resolution. */
978 /* For templates, the template parms must be identical. */
993 {
995 /* Defer to the local function. */
997 else
998 {
1002 /* We don't call duplicate_decls here to merge
1003 the declarations because that will confuse
1004 things if the methods have inline
1005 definitions. In particular, we will crash
1006 while processing the definitions. */
1008 }
1009 }
1010 }
1011 }
1013 /* Add the new binding. */
1020 {
1021 /* We only expect to add few methods in the COMPLETE_P case, so
1022 just make room for one more method in that case. */
1027 else
1029 }
1030 else
1031 /* Replace the current slot. */
1033 }
1035 /* Subroutines of finish_struct. */
1037 /* Change the access of FDECL to ACCESS in T. Return 1 if change was
1038 legit, otherwise return 0. */
1040 static int
1042 {
1043 tree elem;
1052 {
1054 {
1058 else
1061 }
1062 else
1063 {
1064 /* They're changing the access to the same thing they changed
1065 it to before. That's OK. */
1066 ;
1067 }
1068 }
1069 else
1070 {
1074 }
1076 }
1078 /* Process the USING_DECL, which is a member of T. */
1080 static void
1082 {
1085 tree access
1091 tree old_value;
1098 {
1105 }
1108 {
1111 }
1113 {
1116 }
1121 {
1124 }
1127 /* Ignore base type this came from. */
1132 {
1138 else
1140 }
1146 ;
1148 {
1150 /* It's OK to use functions from a base when there are functions with
1152 else
1153 {
1158 }
1159 }
1161 {
1165 }
1167 /* Make type T see field decl FDECL with access ACCESS. */
1170 {
1173 }
1174 else
1176 }
1177 \f
1178 /* Run through the base classes of T, updating
1179 CANT_HAVE_DEFAULT_CTOR_P, CANT_HAVE_CONST_CTOR_P, and
1180 NO_CONST_ASN_REF_P. Also set flag bits in T based on properties of
1181 the bases. */
1183 static void
1188 {
1191 tree base_binfo;
1192 tree binfo;
1198 {
1203 /* Effective C++ rule 14. We only need to check TYPE_POLYMORPHIC_P
1204 here because the case of virtual functions but non-virtual
1205 dtor is handled in finish_struct_1. */
1210 /* If the base class doesn't have copy constructors or
1211 assignment operators that take const references, then the
1212 derived class cannot have such a member automatically
1213 generated. */
1219 /* Similarly, if the base class doesn't have a default
1220 constructor, then the derived class won't have an
1221 automatically generated default constructor. */
1224 {
1229 basetype);
1230 }
1233 /* A virtual base does not effect nearly emptiness. */
1234 ;
1236 {
1238 /* And if there is more than one nearly empty base, then the
1239 derived class is not nearly empty either. */
1241 else
1242 /* Remember we've seen one. */
1244 }
1246 /* If the base class is not empty or nearly empty, then this
1247 class cannot be nearly empty. */
1250 /* A lot of properties from the bases also apply to the derived
1251 class. */
1261 }
1262 }
1264 /* Determine all the primary bases within T. Sets BINFO_PRIMARY_BASE_P for
1265 those that are primaries. Sets BINFO_LOST_PRIMARY_P for those
1266 that have had a nearly-empty virtual primary base stolen by some
1267 other base in the hierarchy. Determines CLASSTYPE_PRIMARY_BASE for
1268 T. */
1270 static void
1272 {
1276 tree base_binfo;
1278 /* Determine the primary bases of our bases. */
1281 {
1284 /* See if we're the non-virtual primary of our inheritance
1285 chain. */
1287 {
1294 /* We are the primary binfo. */
1296 }
1297 /* Determine if we have a virtual primary base, and mark it so.
1298 */
1300 {
1304 /* Someone already claimed this base. */
1306 else
1307 {
1308 tree delta;
1313 /* A virtual binfo might have been copied from within
1314 another hierarchy. As we're about to use it as a
1315 primary base, make sure the offsets match. */
1322 }
1323 }
1324 }
1326 /* First look for a dynamic direct non-virtual base. */
1328 {
1332 {
1335 }
1336 }
1338 /* A "nearly-empty" virtual base class can be the primary base
1339 class, if no non-virtual polymorphic base can be found. Look for
1340 a nearly-empty virtual dynamic base that is not already a primary
1341 base of something in the hierarchy. If there is no such base,
1342 just pick the first nearly-empty virtual base. */
1348 {
1350 {
1351 /* Found one that is not primary. */
1354 }
1356 /* Remember the first candidate. */
1358 }
1360 found:
1361 /* If we've got a primary base, use it. */
1363 {
1368 /* We are stealing a primary base. */
1372 {
1373 tree delta;
1376 /* A virtual binfo might have been copied from within
1377 another hierarchy. As we're about to use it as a primary
1378 base, make sure the offsets match. */
1383 }
1390 }
1391 }
1392 \f
1393 /* Set memoizing fields and bits of T (and its variants) for later
1394 use. */
1396 static void
1398 {
1399 tree variants;
1401 /* Fix up variants (if any). */
1403 variants;
1405 {
1406 /* These fields are in the _TYPE part of the node, not in
1407 the TYPE_LANG_SPECIFIC component, so they are not shared. */
1418 /* Copy whatever these are holding today. */
1424 }
1427 /* For a class w/o baseclasses, 'finish_struct' has set
1428 CLASSTYPE_PURE_VIRTUALS correctly (by definition).
1429 Similarly for a class whose base classes do not have vtables.
1430 When neither of these is true, we might have removed abstract
1431 virtuals (by providing a definition), added some (by declaring
1432 new ones), or redeclared ones from a base class. We need to
1433 recalculate what's really an abstract virtual at this point (by
1434 looking in the vtables). */
1437 /* If this type has a copy constructor or a destructor, force its
1438 mode to be BLKmode, and force its TREE_ADDRESSABLE bit to be
1439 nonzero. This will cause it to be passed by invisible reference
1440 and prevent it from being returned in a register. */
1442 {
1443 tree variants;
1446 {
1449 }
1450 }
1451 }
1453 /* Issue warnings about T having private constructors, but no friends,
1454 and so forth.
1456 HAS_NONPRIVATE_METHOD is nonzero if T has any non-private methods or
1457 static members. HAS_NONPRIVATE_STATIC_FN is nonzero if T has any
1458 non-private static member functions. */
1460 static void
1462 {
1465 tree fn;
1468 /* If the class has friends, those entities might create and
1469 access instances, so we should not warn. */
1472 /* We will have warned when the template was declared; there's
1473 no need to warn on every instantiation. */
1475 /* There's no reason to even consider warning about this
1476 class. */
1479 /* We only issue one warning, if more than one applies, because
1480 otherwise, on code like:
1482 class A {
1483 // Oops - forgot `public:'
1484 A();
1485 A(const A&);
1486 ~A();
1487 };
1489 we warn several times about essentially the same problem. */
1491 /* Check to see if all (non-constructor, non-destructor) member
1492 functions are private. (Since there are no friends or
1493 non-private statics, we can't ever call any of the private member
1494 functions.) */
1496 /* We're not interested in compiler-generated methods; they don't
1497 provide any way to call private members. */
1499 {
1501 {
1503 /* A non-private static member function is just like a
1504 friend; it can create and invoke private member
1505 functions, and be accessed without a class
1506 instance. */
1510 /* Keep searching for a static member function. */
1511 }
1514 }
1517 {
1518 /* There are no non-private methods, and there's at least one
1519 private member function that isn't a constructor or
1520 destructor. (If all the private members are
1521 constructors/destructors we want to use the code below that
1522 issues error messages specifically referring to
1523 constructors/destructors.) */
1529 {
1532 }
1534 {
1537 }
1538 }
1540 /* Even if some of the member functions are non-private, the class
1541 won't be useful for much if all the constructors or destructors
1542 are private: such an object can never be created or destroyed. */
1545 {
1547 t);
1549 }
1552 {
1555 /* If a non-template class does not define a copy
1556 constructor, one is defined for it, enabling it to avoid
1557 this warning. For a template class, this does not
1558 happen, and so we would normally get a warning on:
1560 template <class T> class C { private: C(); };
1562 To avoid this asymmetry, we check TYPE_HAS_INIT_REF. All
1563 complete non-template or fully instantiated classes have this
1564 flag set. */
1567 else
1569 {
1571 /* Ideally, we wouldn't count copy constructors (or, in
1572 fact, any constructor that takes an argument of the
1573 class type as a parameter) because such things cannot
1574 be used to construct an instance of the class unless
1575 you already have one. But, for now at least, we're
1576 more generous. */
1578 {
1581 }
1582 }
1585 {
1587 t);
1589 }
1590 }
1591 }
1594 gt_pointer_operator new_value;
1598 /* Comparison function to compare two TYPE_METHOD_VEC entries by name. */
1600 static int
1602 {
1615 }
1617 /* This routine compares two fields like method_name_cmp but using the
1618 pointer operator in resort_field_decl_data. */
1620 static int
1622 {
1631 {
1638 }
1640 }
1642 /* Resort TYPE_METHOD_VEC because pointers have been reordered. */
1644 void
1647 gt_pointer_operator new_value,
1649 {
1653 tree fn;
1655 /* The type conversion ops have to live at the front of the vec, so we
1656 can't sort them. */
1664 {
1668 resort_method_name_cmp);
1669 }
1670 }
1672 /* Warn about duplicate methods in fn_fields.
1674 Sort methods that are not special (i.e., constructors, destructors,
1675 and type conversion operators) so that we can find them faster in
1676 search. */
1678 static void
1680 {
1681 tree fn_fields;
1691 /* Clear DECL_IN_AGGR_P for all functions. */
1697 /* We thought there was a destructor, but there wasn't. Some
1698 parse errors cause this anomalous situation. */
1701 /* Issue warnings about private constructors and such. If there are
1702 no methods, then some public defaults are generated. */
1705 /* The type conversion ops have to live at the front of the vec, so we
1706 can't sort them. */
1715 }
1717 /* Make BINFO's vtable have N entries, including RTTI entries,
1718 vbase and vcall offsets, etc. Set its type and call the backend
1719 to lay it out. */
1721 static void
1723 {
1724 tree atype;
1725 tree vtable;
1731 /* We may have to grow the vtable. */
1734 {
1738 }
1739 }
1741 /* True iff FNDECL and BASE_FNDECL (both non-static member functions)
1742 have the same signature. */
1744 int
1746 {
1747 /* One destructor overrides another if they are the same kind of
1748 destructor. */
1752 /* But a non-destructor never overrides a destructor, nor vice
1753 versa, nor do different kinds of destructors override
1754 one-another. For example, a complete object destructor does not
1755 override a deleting destructor. */
1764 {
1772 }
1774 }
1776 /* Returns TRUE if DERIVED is a binfo containing the binfo BASE as a
1777 subobject. */
1779 static bool
1781 {
1782 tree probe;
1785 {
1789 /* If we meet a virtual base, we can't follow the inheritance
1790 any more. See if the complete type of DERIVED contains
1791 such a virtual base. */
1794 }
1796 }
1799 /* The function for which we are trying to find a final overrider. */
1800 tree fn;
1801 /* The base class in which the function was declared. */
1802 tree declaring_base;
1803 /* The candidate overriders. */
1804 tree candidates;
1805 /* Path to most derived. */
1809 /* Add the overrider along the current path to FFOD->CANDIDATES.
1810 Returns true if an overrider was found; false otherwise. */
1812 static bool
1816 {
1817 tree method;
1819 /* If BINFO is not the most derived type, try a more derived class.
1820 A definition there will overrider a definition here. */
1822 {
1823 depth--;
1827 }
1831 {
1834 /* Remove any candidates overridden by this new function. */
1836 {
1837 /* If *CANDIDATE overrides METHOD, then METHOD
1838 cannot override anything else on the list. */
1841 /* If METHOD overrides *CANDIDATE, remove *CANDIDATE. */
1844 else
1846 }
1848 /* Add the new function. */
1851 }
1854 }
1856 /* Called from find_final_overrider via dfs_walk. */
1858 static tree
1860 {
1868 }
1870 static tree
1872 {
1877 }
1879 /* Returns a TREE_LIST whose TREE_PURPOSE is the final overrider for
1880 FN and whose TREE_VALUE is the binfo for the base where the
1881 overriding occurs. BINFO (in the hierarchy dominated by the binfo
1882 DERIVED) is the base object in which FN is declared. */
1884 static tree
1886 {
1887 find_final_overrider_data ffod;
1889 /* Getting this right is a little tricky. This is valid:
1891 struct S { virtual void f (); };
1892 struct T { virtual void f (); };
1893 struct U : public S, public T { };
1895 even though calling `f' in `U' is ambiguous. But,
1897 struct R { virtual void f(); };
1898 struct S : virtual public R { virtual void f (); };
1899 struct T : virtual public R { virtual void f (); };
1900 struct U : public S, public T { };
1902 is not -- there's no way to decide whether to put `S::f' or
1903 `T::f' in the vtable for `R'.
1905 The solution is to look at all paths to BINFO. If we find
1906 different overriders along any two, then there is a problem. */
1910 /* Determine the depth of the hierarchy. */
1921 /* If there was no winner, issue an error message. */
1923 {
1927 }
1930 }
1932 /* Return the index of the vcall offset for FN when TYPE is used as a
1933 virtual base. */
1935 static tree
1937 {
1939 tree_pair_p p;
1947 /* There should always be an appropriate index. */
1949 }
1951 /* Update an entry in the vtable for BINFO, which is in the hierarchy
1952 dominated by T. FN has been overridden in BINFO; VIRTUALS points to the
1953 corresponding position in the BINFO_VIRTUALS list. */
1955 static void
1958 {
1959 tree b;
1960 tree overrider;
1961 tree delta;
1962 tree virtual_base;
1963 tree first_defn;
1969 /* Find the nearest primary base (possibly binfo itself) which defines
1970 this function; this is the class the caller will convert to when
1971 calling FN through BINFO. */
1973 {
1978 /* The nearest definition is from a lost primary. */
1981 }
1984 /* Find the final overrider. */
1990 /* Check for adjusting covariant return types. */
1998 {
1999 /* If FN is a covariant thunk, we must figure out the adjustment
2000 to the final base FN was converting to. As OVERRIDER_TARGET might
2001 also be converting to the return type of FN, we have to
2002 combine the two conversions here. */
2006 {
2010 }
2011 else
2015 /* Find the equivalent binfo within the return type of the
2016 overriding function. We will want the vbase offset from
2017 there. */
2022 {
2023 /* There was no existing virtual thunk (which takes
2024 precedence). */
2025 tree thunk_binfo;
2026 base_kind kind;
2034 {
2038 {
2039 /* We convert via virtual base. Find the virtual
2040 base and adjust the fixed offset to be from there. */
2045 offset = size_diffop
2048 }
2050 /* There was an existing fixed offset, this must be
2051 from the base just converted to, and the base the
2052 FN was thunking to. */
2054 else
2056 }
2057 }
2060 /* Replace the overriding function with a covariant thunk. We
2061 will emit the overriding function in its own slot as
2062 well. */
2065 }
2066 else
2069 /* Assume that we will produce a thunk that convert all the way to
2070 the final overrider, and not to an intermediate virtual base. */
2073 /* See if we can convert to an intermediate virtual base first, and then
2074 use the vcall offset located there to finish the conversion. */
2076 {
2077 /* If we find the final overrider, then we can stop
2078 walking. */
2083 /* If we find a virtual base, and we haven't yet found the
2084 overrider, then there is a virtual base between the
2085 declaring base (first_defn) and the final overrider. */
2087 {
2090 }
2091 }
2094 {
2095 /* The ABI specifies that a covariant thunk includes a mangling
2096 for a this pointer adjustment. This-adjusting thunks that
2097 override a function from a virtual base have a vcall
2098 adjustment. When the virtual base in question is a primary
2099 virtual base, we know the adjustments are zero, (and in the
2100 non-covariant case, we would not use the thunk).
2101 Unfortunately we didn't notice this could happen, when
2102 designing the ABI and so never mandated that such a covariant
2103 thunk should be emitted. Because we must use the ABI mandated
2104 name, we must continue searching from the binfo where we
2105 found the most recent definition of the function, towards the
2106 primary binfo which first introduced the function into the
2107 vtable. If that enters a virtual base, we must use a vcall
2108 this-adjusting thunk. Bleah! */
2117 /* Even if we find a virtual base, the correct delta is
2118 between the overrider and the binfo we're building a vtable
2119 for. */
2121 }
2123 /* Compute the constant adjustment to the `this' pointer. The
2124 `this' pointer, when this function is called, will point at BINFO
2125 (or one of its primary bases, which are at the same offset). */
2127 /* The `this' pointer needs to be adjusted from the declaration to
2128 the nearest virtual base. */
2132 /* If the nearest definition is in a lost primary, we don't need an
2133 entry in our vtable. Except possibly in a constructor vtable,
2134 if we happen to get our primary back. In that case, the offset
2135 will be zero, as it will be a primary base. */
2137 else
2138 /* The `this' pointer needs to be adjusted from pointing to
2139 BINFO to pointing at the base where the final overrider
2140 appears. */
2141 virtual_covariant:
2151 else
2153 }
2155 /* Called from modify_all_vtables via dfs_walk. */
2157 static tree
2159 {
2161 tree virtuals;
2162 tree old_virtuals;
2166 /* A base without a vtable needs no modification, and its bases
2167 are uninteresting. */
2172 /* Don't do the primary vtable, if it's new. */
2176 /* There's no need to modify the vtable for a non-virtual primary
2177 base; we're not going to use that vtable anyhow. We do still
2178 need to do this for virtual primary bases, as they could become
2179 non-primary in a construction vtable. */
2184 /* Now, go through each of the virtual functions in the virtual
2185 function table for BINFO. Find the final overrider, and update
2186 the BINFO_VIRTUALS list appropriately. */
2189 virtuals;
2193 binfo,
2198 }
2200 /* Update all of the primary and secondary vtables for T. Create new
2201 vtables as required, and initialize their RTTI information. Each
2202 of the functions in VIRTUALS is declared in T and may override a
2203 virtual function from a base class; find and modify the appropriate
2204 entries to point to the overriding functions. Returns a list, in
2205 declaration order, of the virtual functions that are declared in T,
2206 but do not appear in the primary base class vtable, and which
2207 should therefore be appended to the end of the vtable for T. */
2209 static tree
2211 {
2215 /* Update all of the vtables. */
2218 /* Add virtual functions not already in our primary vtable. These
2219 will be both those introduced by this class, and those overridden
2220 from secondary bases. It does not include virtuals merely
2221 inherited from secondary bases. */
2223 {
2228 {
2229 /* We don't need to adjust the `this' pointer when
2230 calling this function. */
2234 /* This is a function not already in our vtable. Keep it. */
2236 }
2237 else
2238 /* We've already got an entry for this function. Skip it. */
2240 }
2243 }
2245 /* Get the base virtual function declarations in T that have the
2246 indicated NAME. */
2248 static tree
2250 {
2251 tree methods;
2256 /* Find virtual functions in T with the indicated NAME. */
2260 methods;
2262 {
2268 }
2274 {
2277 base_fndecls);
2278 }
2281 }
2283 /* If this declaration supersedes the declaration of
2284 a method declared virtual in the base class, then
2285 mark this field as being virtual as well. */
2287 static void
2289 {
2291 /* In [temp.mem] we have:
2293 A specialization of a member function template does not
2294 override a virtual function from a base class. */
2301 /* Set DECL_VINDEX to a value that is neither an INTEGER_CST nor
2302 the error_mark_node so that we know it is an overriding
2303 function. */
2307 {
2311 }
2312 }
2314 /* Warn about hidden virtual functions that are not overridden in t.
2315 We know that constructors and destructors don't apply. */
2317 void
2319 {
2321 tree fns;
2324 /* We go through each separately named virtual function. */
2328 {
2329 tree fn;
2330 tree name;
2331 tree fndecl;
2332 tree base_fndecls;
2333 tree base_binfo;
2334 tree binfo;
2337 /* All functions in this slot in the CLASSTYPE_METHOD_VEC will
2338 have the same name. Figure out what name that is. */
2340 /* There are no possibly hidden functions yet. */
2342 /* Iterate through all of the base classes looking for possibly
2343 hidden functions. */
2346 {
2349 base_fndecls);
2350 }
2352 /* If there are no functions to hide, continue. */
2356 /* Remove any overridden functions. */
2358 {
2361 {
2365 /* If the method from the base class has the same
2366 signature as the method from the derived class, it
2367 has been overridden. */
2370 else
2372 }
2373 }
2375 /* Now give a warning for all base functions without overriders,
2376 as they are hidden. */
2378 {
2379 /* Here we know it is a hider, and no overrider exists. */
2383 }
2384 }
2385 }
2387 /* Check for things that are invalid. There are probably plenty of other
2388 things we should check for also. */
2390 static void
2392 {
2393 tree field;
2396 {
2404 {
2407 {
2408 /* We're generally only interested in entities the user
2409 declared, but we also find nested classes by noticing
2410 the TYPE_DECL that we create implicitly. You're
2411 allowed to put one anonymous union inside another,
2412 though, so we explicitly tolerate that. We use
2413 TYPE_ANONYMOUS_P rather than ANON_AGGR_TYPE_P so that
2414 we also allow unnamed types used for defining fields. */
2421 {
2424 elt);
2426 }
2430 elt);
2433 elt);
2437 }
2438 }
2439 }
2440 }
2442 /* Add T to CLASSTYPE_DECL_LIST of current_class_type which
2443 will be used later during class template instantiation.
2444 When FRIEND_P is zero, T can be a static member data (VAR_DECL),
2445 a non-static member data (FIELD_DECL), a member function
2446 (FUNCTION_DECL), a nested type (RECORD_TYPE, ENUM_TYPE),
2447 a typedef (TYPE_DECL) or a member class template (TEMPLATE_DECL)
2448 When FRIEND_P is nonzero, T is either a friend class
2449 (RECORD_TYPE, TEMPLATE_DECL) or a friend function
2450 (FUNCTION_DECL, TEMPLATE_DECL). */
2452 void
2454 {
2455 /* Save some memory by not creating TREE_LIST if TYPE is not template. */
2460 }
2462 /* Create default constructors, assignment operators, and so forth for
2463 the type indicated by T, if they are needed.
2464 CANT_HAVE_DEFAULT_CTOR, CANT_HAVE_CONST_CTOR, and
2465 CANT_HAVE_CONST_ASSIGNMENT are nonzero if, for whatever reason, the
2466 class cannot have a default constructor, copy constructor taking a
2467 const reference argument, or an assignment operator taking a const
2468 reference, respectively. If a virtual destructor is created, its
2469 DECL is returned; otherwise the return value is NULL_TREE. */
2471 static void
2476 {
2477 tree default_fn;
2482 /* Destructor. */
2484 {
2493 }
2494 else
2495 /* Any non-implicit destructor is non-trivial. */
2498 /* Default constructor. */
2500 {
2503 }
2505 /* Copy constructor. */
2507 {
2512 }
2514 /* If there is no assignment operator, one will be created if and
2515 when it is needed. For now, just record whether or not the type
2516 of the parameter to the assignment operator will be a const or
2517 non-const reference. */
2519 {
2523 }
2525 /* Now, hook all of the new functions on to TYPE_METHODS,
2526 and add them to the CLASSTYPE_METHOD_VEC. */
2528 {
2531 }
2533 /* G++ 3.2 put the implicit destructor at the *beginning* of the
2534 list, which cause the destructor to be emitted in an incorrect
2535 location in the vtable. */
2537 else
2538 {
2541 "and may change in a future version of GCC due to implicit "
2543 t);
2546 }
2547 }
2549 /* Subroutine of finish_struct_1. Recursively count the number of fields
2550 in TYPE, including anonymous union members. */
2552 static int
2554 {
2555 tree x;
2558 {
2561 else
2563 }
2565 }
2567 /* Subroutine of finish_struct_1. Recursively add all the fields in the
2568 TREE_LIST FIELDS to the SORTED_FIELDS_TYPE elts, starting at offset IDX. */
2570 static int
2572 {
2573 tree x;
2575 {
2578 else
2580 }
2582 }
2584 /* FIELD is a bit-field. We are finishing the processing for its
2585 enclosing type. Issue any appropriate messages and set appropriate
2586 flags. */
2588 static void
2590 {
2594 /* Detect invalid bit-field type. */
2597 {
2600 }
2602 /* Detect and ignore out of range field width. */
2604 {
2607 /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs. */
2610 /* detect invalid field size. */
2614 {
2616 field);
2618 }
2620 {
2623 }
2625 {
2628 }
2638 min_precision
2643 }
2645 /* Remove the bit-field width indicator so that the rest of the
2646 compiler does not treat that value as an initializer. */
2650 {
2653 }
2654 else
2655 {
2656 /* Non-bit-fields are aligned for their type. */
2659 }
2660 }
2662 /* FIELD is a non bit-field. We are finishing the processing for its
2663 enclosing type T. Issue any appropriate messages and set appropriate
2664 flags. */
2666 static void
2668 tree t,
2673 {
2676 /* An anonymous union cannot contain any fields which would change
2677 the settings of CANT_HAVE_CONST_CTOR and friends. */
2679 ;
2680 /* And, we don't set TYPE_HAS_CONST_INIT_REF, etc., for anonymous
2681 structs. So, we recurse through their fields here. */
2683 {
2684 tree fields;
2690 any_default_members);
2691 }
2692 /* Check members with class type for constructors, destructors,
2693 etc. */
2695 {
2696 /* Never let anything with uninheritable virtuals
2697 make it through without complaint. */
2701 {
2704 field);
2707 field);
2710 field);
2711 }
2712 else
2713 {
2719 }
2730 }
2732 {
2733 /* `build_class_init_list' does not recognize
2734 non-FIELD_DECLs. */
2738 }
2739 }
2741 /* Check the data members (both static and non-static), class-scoped
2742 typedefs, etc., appearing in the declaration of T. Issue
2743 appropriate diagnostics. Sets ACCESS_DECLS to a list (in
2744 declaration order) of access declarations; each TREE_VALUE in this
2745 list is a USING_DECL.
2747 In addition, set the following flags:
2749 EMPTY_P
2750 The class is empty, i.e., contains no non-static data members.
2752 CANT_HAVE_DEFAULT_CTOR_P
2753 This class cannot have an implicitly generated default
2754 constructor.
2756 CANT_HAVE_CONST_CTOR_P
2757 This class cannot have an implicitly generated copy constructor
2758 taking a const reference.
2760 CANT_HAVE_CONST_ASN_REF
2761 This class cannot have an implicitly generated assignment
2762 operator taking a const reference.
2764 All of these flags should be initialized before calling this
2765 function.
2767 Returns a pointer to the end of the TYPE_FIELDs chain; additional
2768 fields can be added by adding to this chain. */
2770 static void
2775 {
2781 /* Assume there are no access declarations. */
2783 /* Assume this class has no pointer members. */
2785 /* Assume none of the members of this class have default
2786 initializations. */
2790 {
2797 {
2799 {
2801 cp_warning_at
2803 x);
2804 else
2806 }
2809 /* We don't treat zero-width bitfields as making a class
2810 non-empty. */
2811 ;
2812 else
2813 {
2814 tree element_type;
2816 /* The class is non-empty. */
2818 /* The class is not even nearly empty. */
2820 /* If one of the data members contains an empty class,
2821 so does T. */
2826 }
2827 }
2830 {
2831 /* Prune the access declaration from the list of fields. */
2834 /* Save the access declarations for our caller. */
2837 /* Since we've reset *FIELD there's no reason to skip to the
2838 next field. */
2841 }
2847 /* If we've gotten this far, it's a data member, possibly static,
2848 or an enumerator. */
2851 /* When this goes into scope, it will be a non-local reference. */
2855 {
2856 /* [class.union]
2858 If a union contains a static data member, or a member of
2859 reference type, the program is ill-formed. */
2861 {
2864 }
2866 {
2871 }
2872 }
2874 /* ``A local class cannot have static data members.'' ARM 9.4 */
2878 /* Perform error checking that did not get done in
2879 grokdeclarator. */
2881 {
2885 }
2887 {
2891 }
2899 /* Now it can only be a FIELD_DECL. */
2904 /* If this is of reference type, check if it needs an init.
2905 Also do a little ANSI jig if necessary. */
2907 {
2912 /* ARM $12.6.2: [A member initializer list] (or, for an
2913 aggregate, initialization by a brace-enclosed list) is the
2914 only way to initialize nonstatic const and reference
2915 members. */
2922 }
2926 /* This is used by -Weffc++ (see below). Warn only for pointers
2927 to members which might hold dynamic memory. So do not warn
2928 for pointers to functions or pointers to members. */
2935 {
2940 }
2946 /* DR 148 now allows pointers to members (which are POD themselves),
2947 to be allowed in POD structs. */
2953 /* If any field is const, the structure type is pseudo-const. */
2955 {
2960 /* ARM $12.6.2: [A member initializer list] (or, for an
2961 aggregate, initialization by a brace-enclosed list) is the
2962 only way to initialize nonstatic const and reference
2963 members. */
2970 }
2971 /* A field that is pseudo-const makes the structure likewise. */
2973 {
2978 }
2980 /* Core issue 80: A nonstatic data member is required to have a
2981 different name from the class iff the class has a
2982 user-defined constructor. */
2986 /* We set DECL_C_BIT_FIELD in grokbitfield.
2987 If the type and width are valid, we'll also set DECL_BIT_FIELD. */
2990 else
2992 cant_have_const_ctor_p,
2993 cant_have_default_ctor_p,
2994 no_const_asn_ref_p,
2996 }
2998 /* Effective C++ rule 11: if a class has dynamic memory held by pointers,
2999 it should also define a copy constructor and an assignment operator to
3000 implement the correct copy semantic (deep vs shallow, etc.). As it is
3001 not feasible to check whether the constructors do allocate dynamic memory
3002 and store it within members, we approximate the warning like this:
3004 -- Warn only if there are members which are pointers
3005 -- Warn only if there is a non-trivial constructor (otherwise,
3006 there cannot be memory allocated).
3007 -- Warn only if there is a non-trivial destructor. We assume that the
3008 user at least implemented the cleanup correctly, and a destructor
3009 is needed to free dynamic memory.
3011 This seems enough for practical purposes. */
3013 && has_pointers
3017 {
3021 {
3025 }
3028 }
3031 /* Check anonymous struct/anonymous union fields. */
3034 /* We've built up the list of access declarations in reverse order.
3035 Fix that now. */
3037 }
3039 /* If TYPE is an empty class type, records its OFFSET in the table of
3040 OFFSETS. */
3042 static int
3044 {
3045 splay_tree_node n;
3050 /* Record the location of this empty object in OFFSETS. */
3058 type,
3062 }
3064 /* Returns nonzero if TYPE is an empty class type and there is
3065 already an entry in OFFSETS for the same TYPE as the same OFFSET. */
3067 static int
3069 {
3070 splay_tree_node n;
3071 tree t;
3076 /* Record the location of this empty object in OFFSETS. */
3086 }
3088 /* Walk through all the subobjects of TYPE (located at OFFSET). Call
3089 F for every subobject, passing it the type, offset, and table of
3090 OFFSETS. If VBASES_P is one, then virtual non-primary bases should
3091 be traversed.
3093 If MAX_OFFSET is non-NULL, then subobjects with an offset greater
3094 than MAX_OFFSET will not be walked.
3096 If F returns a nonzero value, the traversal ceases, and that value
3097 is returned. Otherwise, returns zero. */
3099 static int
3101 subobject_offset_fn f,
3102 tree offset,
3103 splay_tree offsets,
3104 tree max_offset,
3106 {
3110 /* If this OFFSET is bigger than the MAX_OFFSET, then we should
3111 stop. */
3116 {
3120 }
3123 {
3124 tree field;
3125 tree binfo;
3128 /* Avoid recursing into objects that are not interesting. */
3132 /* Record the location of TYPE. */
3137 /* Iterate through the direct base classes of TYPE. */
3141 {
3142 tree binfo_offset;
3155 offset,
3157 else
3158 {
3159 tree orig_binfo;
3160 /* We cannot rely on BINFO_OFFSET being set for the base
3161 class yet, but the offsets for direct non-virtual
3162 bases can be calculated by going back to the TYPE. */
3165 offset,
3167 }
3170 f,
3171 binfo_offset,
3172 offsets,
3173 max_offset,
3178 }
3181 {
3185 /* Iterate through the virtual base classes of TYPE. In G++
3186 3.2, we included virtual bases in the direct base class
3187 loop above, which results in incorrect results; the
3188 correct offsets for virtual bases are only known when
3189 working with the most derived type. */
3193 {
3195 f,
3197 offset,
3199 offsets,
3200 max_offset,
3204 }
3205 else
3206 {
3207 /* We still have to walk the primary base, if it is
3208 virtual. (If it is non-virtual, then it was walked
3209 above.) */
3215 {
3216 r = (walk_subobject_offsets
3221 }
3222 }
3223 }
3225 /* Iterate through the fields of TYPE. */
3228 {
3229 tree field_offset;
3233 else
3234 /* In G++ 3.2, DECL_FIELD_OFFSET was used. */
3238 f,
3240 offset,
3241 field_offset),
3242 offsets,
3243 max_offset,
3247 }
3248 }
3250 {
3253 tree index;
3255 /* Avoid recursing into objects that are not interesting. */
3260 /* Step through each of the elements in the array. */
3262 /* G++ 3.2 had an off-by-one error here. */
3267 {
3269 f,
3270 offset,
3271 offsets,
3272 max_offset,
3278 /* If this new OFFSET is bigger than the MAX_OFFSET, then
3279 there's no point in iterating through the remaining
3280 elements of the array. */
3283 }
3284 }
3287 }
3289 /* Record all of the empty subobjects of TYPE (located at OFFSET) in
3290 OFFSETS. If VBASES_P is nonzero, virtual bases of TYPE are
3291 examined. */
3293 static void
3295 tree offset,
3296 splay_tree offsets,
3298 {
3301 }
3303 /* Returns nonzero if any of the empty subobjects of TYPE (located at
3304 OFFSET) conflict with entries in OFFSETS. If VBASES_P is nonzero,
3305 virtual bases of TYPE are examined. */
3307 static int
3309 tree offset,
3310 splay_tree offsets,
3312 {
3313 splay_tree_node max_node;
3315 /* Get the node in OFFSETS that indicates the maximum offset where
3316 an empty subobject is located. */
3318 /* If there aren't any empty subobjects, then there's no point in
3319 performing this check. */
3325 vbases_p);
3326 }
3328 /* DECL is a FIELD_DECL corresponding either to a base subobject of a
3329 non-static data member of the type indicated by RLI. BINFO is the
3330 binfo corresponding to the base subobject, OFFSETS maps offsets to
3331 types already located at those offsets. This function determines
3332 the position of the DECL. */
3334 static void
3336 tree decl,
3337 tree binfo,
3338 splay_tree offsets)
3339 {
3342 tree type;
3345 {
3346 /* For the purposes of determining layout conflicts, we want to
3347 use the class type of BINFO; TREE_TYPE (DECL) will be the
3348 CLASSTYPE_AS_BASE version, which does not contain entries for
3349 zero-sized bases. */
3352 }
3353 else
3354 {
3357 }
3359 /* Try to place the field. It may take more than one try if we have
3360 a hard time placing the field without putting two objects of the
3361 same type at the same address. */
3363 {
3366 /* Place this field. */
3370 /* We have to check to see whether or not there is already
3371 something of the same type at the offset we're about to use.
3372 For example, consider:
3374 struct S {};
3375 struct T : public S { int i; };
3376 struct U : public S, public T {};
3378 Here, we put S at offset zero in U. Then, we can't put T at
3379 offset zero -- its S component would be at the same address
3380 as the S we already allocated. So, we have to skip ahead.
3381 Since all data members, including those whose type is an
3382 empty class, have nonzero size, any overlap can happen only
3383 with a direct or indirect base-class -- it can't happen with
3384 a data member. */
3385 /* In a union, overlap is permitted; all members are placed at
3386 offset zero. */
3389 /* G++ 3.2 did not check for overlaps when placing a non-empty
3390 virtual base. */
3395 {
3396 /* Strip off the size allocated to this field. That puts us
3397 at the first place we could have put the field with
3398 proper alignment. */
3401 /* Bump up by the alignment required for the type. */
3402 rli->bitpos
3408 }
3409 else
3410 /* There was no conflict. We're done laying out this field. */
3412 }
3414 /* Now that we know where it will be placed, update its
3415 BINFO_OFFSET. */
3417 /* Indirect virtual bases may have a nonzero BINFO_OFFSET at
3418 this point because their BINFO_OFFSET is copied from another
3419 hierarchy. Therefore, we may not need to add the entire
3420 OFFSET. */
3425 }
3427 /* Returns true if TYPE is empty and OFFSET is nonzero. */
3429 static int
3431 tree offset,
3432 splay_tree offsets ATTRIBUTE_UNUSED)
3433 {
3435 }
3437 /* Layout the empty base BINFO. EOC indicates the byte currently just
3438 past the end of the class, and should be correctly aligned for a
3439 class of the type indicated by BINFO; OFFSETS gives the offsets of
3440 the empty bases allocated so far. T is the most derived
3441 type. Return nonzero iff we added it at the end. */
3443 static bool
3445 {
3446 tree alignment;
3450 /* This routine should only be used for empty classes. */
3455 {
3457 propagate_binfo_offsets
3463 }
3465 /* This is an empty base class. We first try to put it at offset
3466 zero. */
3469 offsets,
3471 {
3472 /* That didn't work. Now, we move forward from the next
3473 available spot in the class. */
3477 {
3480 offsets,
3482 /* We finally found a spot where there's no overlap. */
3485 /* There's overlap here, too. Bump along to the next spot. */
3487 }
3488 }
3490 }
3492 /* Layout the the base given by BINFO in the class indicated by RLI.
3493 *BASE_ALIGN is a running maximum of the alignments of
3494 any base class. OFFSETS gives the location of empty base
3495 subobjects. T is the most derived type. Return nonzero if the new
3496 object cannot be nearly-empty. A new FIELD_DECL is inserted at
3497 *NEXT_FIELD, unless BINFO is for an empty base class.
3499 Returns the location at which the next field should be inserted. */
3504 {
3509 /* This error is now reported in xref_tag, thus giving better
3510 location information. */
3513 /* Place the base class. */
3515 {
3516 tree decl;
3518 /* The containing class is non-empty because it has a non-empty
3519 base class. */
3522 /* Create the FIELD_DECL. */
3534 /* Try to place the field. It may take more than one try if we
3535 have a hard time placing the field without putting two
3536 objects of the same type at the same address. */
3538 /* Add the new FIELD_DECL to the list of fields for T. */
3542 }
3543 else
3544 {
3545 tree eoc;
3548 /* On some platforms (ARM), even empty classes will not be
3549 byte-aligned. */
3553 /* A nearly-empty class "has no proper base class that is empty,
3554 not morally virtual, and at an offset other than zero." */
3556 {
3559 /* The check above (used in G++ 3.2) is insufficient because
3560 an empty class placed at offset zero might itself have an
3561 empty base at a nonzero offset. */
3563 empty_base_at_nonzero_offset_p,
3564 size_zero_node,
3568 {
3574 }
3575 }
3577 /* We do not create a FIELD_DECL for empty base classes because
3578 it might overlap some other field. We want to be able to
3579 create CONSTRUCTORs for the class by iterating over the
3580 FIELD_DECLs, and the back end does not handle overlapping
3581 FIELD_DECLs. */
3583 /* An empty virtual base causes a class to be non-empty
3584 -- but in that case we do not need to clear CLASSTYPE_EMPTY_P
3585 here because that was already done when the virtual table
3586 pointer was created. */
3587 }
3589 /* Record the offsets of BINFO and its base subobjects. */
3592 offsets,
3596 }
3598 /* Layout all of the non-virtual base classes. Record empty
3599 subobjects in OFFSETS. T is the most derived type. Return nonzero
3600 if the type cannot be nearly empty. The fields created
3601 corresponding to the base classes will be inserted at
3602 *NEXT_FIELD. */
3604 static void
3607 {
3608 /* Chain to hold all the new FIELD_DECLs which stand in for base class
3609 subobjects. */
3614 /* The primary base class is always allocated first. */
3619 /* Now allocate the rest of the bases. */
3621 {
3622 tree base_binfo;
3626 /* The primary base was already allocated above, so we don't
3627 need to allocate it again here. */
3631 /* Virtual bases are added at the end (a primary virtual base
3632 will have already been added). */
3638 }
3639 }
3641 /* Go through the TYPE_METHODS of T issuing any appropriate
3642 diagnostics, figuring out which methods override which other
3643 methods, and so forth. */
3645 static void
3647 {
3648 tree x;
3651 {
3655 /* The name of the field is the original field name
3656 Save this in auxiliary field for later overloading. */
3658 {
3662 }
3663 }
3664 }
3666 /* FN is a constructor or destructor. Clone the declaration to create
3667 a specialized in-charge or not-in-charge version, as indicated by
3668 NAME. */
3670 static tree
3672 {
3673 tree parms;
3674 tree clone;
3676 /* Copy the function. */
3678 /* Remember where this function came from. */
3681 /* Reset the function name. */
3684 /* There's no pending inline data for this function. */
3687 /* And it hasn't yet been deferred. */
3690 /* The base-class destructor is not virtual. */
3692 {
3696 }
3698 /* If there was an in-charge parameter, drop it from the function
3699 type. */
3701 {
3702 tree basetype;
3703 tree parmtypes;
3704 tree exceptions;
3709 /* Skip the `this' parameter. */
3711 /* Skip the in-charge parameter. */
3713 /* And the VTT parm, in a complete [cd]tor. */
3717 /* If this is subobject constructor or destructor, add the vtt
3718 parameter. */
3722 parmtypes);
3725 exceptions);
3729 }
3731 /* Copy the function parameters. But, DECL_ARGUMENTS on a TEMPLATE_DECL
3732 aren't function parameters; those are the template parameters. */
3734 {
3736 /* Remove the in-charge parameter. */
3738 {
3742 }
3743 /* And the VTT parm, in a complete [cd]tor. */
3745 {
3748 else
3749 {
3753 }
3754 }
3757 {
3760 }
3761 }
3763 /* Create the RTL for this function. */
3767 /* Make it easy to find the CLONE given the FN. */
3771 /* If this is a template, handle the DECL_TEMPLATE_RESULT as well. */
3773 {
3774 tree result;
3781 }
3786 }
3788 /* Produce declarations for all appropriate clones of FN. If
3789 UPDATE_METHOD_VEC_P is nonzero, the clones are added to the
3790 CLASTYPE_METHOD_VEC as well. */
3792 void
3794 {
3795 tree clone;
3797 /* Avoid inappropriate cloning. */
3803 {
3804 /* For each constructor, we need two variants: an in-charge version
3805 and a not-in-charge version. */
3812 }
3813 else
3814 {
3817 /* For each destructor, we need three variants: an in-charge
3818 version, a not-in-charge version, and an in-charge deleting
3819 version. We clone the deleting version first because that
3820 means it will go second on the TYPE_METHODS list -- and that
3821 corresponds to the correct layout order in the virtual
3822 function table.
3824 For a non-virtual destructor, we do not build a deleting
3825 destructor. */
3827 {
3831 }
3838 }
3840 /* Note that this is an abstract function that is never emitted. */
3842 }
3844 /* DECL is an in charge constructor, which is being defined. This will
3845 have had an in class declaration, from whence clones were
3846 declared. An out-of-class definition can specify additional default
3847 arguments. As it is the clones that are involved in overload
3848 resolution, we must propagate the information from the DECL to its
3849 clones. */
3851 void
3853 {
3854 tree clone;
3858 {
3865 /* Skip the 'this' parameter. */
3881 {
3886 {
3887 /* A default parameter has been added. Adjust the
3888 clone's parameters. */
3891 tree type;
3896 {
3899 clone_parms);
3901 }
3904 clone_parms);
3911 }
3912 }
3914 }
3915 }
3917 /* For each of the constructors and destructors in T, create an
3918 in-charge and not-in-charge variant. */
3920 static void
3922 {
3923 tree fns;
3925 /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail
3926 out now. */
3934 }
3936 /* Remove all zero-width bit-fields from T. */
3938 static void
3940 {
3945 {
3950 else
3952 }
3953 }
3955 /* Returns TRUE iff we need a cookie when dynamically allocating an
3956 array whose elements have the indicated class TYPE. */
3958 static bool
3960 {
3961 tree fns;
3966 /* If there's a non-trivial destructor, we need a cookie. In order
3967 to iterate through the array calling the destructor for each
3968 element, we'll have to know how many elements there are. */
3972 /* If the usual deallocation function is a two-argument whose second
3973 argument is of type `size_t', then we have to pass the size of
3974 the array to the deallocation function, so we will need to store
3975 a cookie. */
3979 /* If there are no `operator []' members, or the lookup is
3980 ambiguous, then we don't need a cookie. */
3983 /* Loop through all of the functions. */
3985 {
3986 tree fn;
3987 tree second_parm;
3989 /* Select the current function. */
3991 /* See if this function is a one-argument delete function. If
3992 it is, then it will be the usual deallocation function. */
3996 /* Otherwise, if we have a two-argument function and the second
3997 argument is `size_t', it will be the usual deallocation
3998 function -- unless there is one-argument function, too. */
4002 }
4005 }
4007 /* Check the validity of the bases and members declared in T. Add any
4008 implicitly-generated functions (like copy-constructors and
4009 assignment operators). Compute various flag bits (like
4010 CLASSTYPE_NON_POD_T) for T. This routine works purely at the C++
4011 level: i.e., independently of the ABI in use. */
4013 static void
4015 {
4016 /* Nonzero if we are not allowed to generate a default constructor
4017 for this case. */
4019 /* Nonzero if the implicitly generated copy constructor should take
4020 a non-const reference argument. */
4022 /* Nonzero if the the implicitly generated assignment operator
4023 should take a non-const reference argument. */
4025 tree access_decls;
4027 /* By default, we use const reference arguments and generate default
4028 constructors. */
4033 /* Check all the base-classes. */
4037 /* Check all the data member declarations. */
4043 /* Check all the method declarations. */
4046 /* A nearly-empty class has to be vptr-containing; a nearly empty
4047 class contains just a vptr. */
4051 /* Do some bookkeeping that will guide the generation of implicitly
4052 declared member functions. */
4065 /* Synthesize any needed methods. */
4067 cant_have_const_ctor,
4068 no_const_asn_ref);
4070 /* Create the in-charge and not-in-charge variants of constructors
4071 and destructors. */
4074 /* Process the using-declarations. */
4078 /* Build and sort the CLASSTYPE_METHOD_VEC. */
4081 /* Figure out whether or not we will need a cookie when dynamically
4082 allocating an array of this type. */
4085 }
4087 /* If T needs a pointer to its virtual function table, set TYPE_VFIELD
4088 accordingly. If a new vfield was created (because T doesn't have a
4089 primary base class), then the newly created field is returned. It
4090 is not added to the TYPE_FIELDS list; it is the caller's
4091 responsibility to do that. Accumulate declared virtual functions
4092 on VIRTUALS_P. */
4094 static tree
4096 {
4097 tree fn;
4099 /* Collect the virtual functions declared in T. */
4103 {
4112 }
4114 /* If we couldn't find an appropriate base class, create a new field
4115 here. Even if there weren't any new virtual functions, we might need a
4116 new virtual function table if we're supposed to include vptrs in
4117 all classes that need them. */
4119 {
4120 /* We build this decl with vtbl_ptr_type_node, which is a
4121 `vtable_entry_type*'. It might seem more precise to use
4122 `vtable_entry_type (*)[N]' where N is the number of virtual
4123 functions. However, that would require the vtable pointer in
4124 base classes to have a different type than the vtable pointer
4125 in derived classes. We could make that happen, but that
4126 still wouldn't solve all the problems. In particular, the
4127 type-based alias analysis code would decide that assignments
4128 to the base class vtable pointer can't alias assignments to
4129 the derived class vtable pointer, since they have different
4130 types. Thus, in a derived class destructor, where the base
4131 class constructor was inlined, we could generate bad code for
4132 setting up the vtable pointer.
4134 Therefore, we use one type for all vtable pointers. We still
4135 use a type-correct type; it's just doesn't indicate the array
4136 bounds. That's better than using `void*' or some such; it's
4137 cleaner, and it let's the alias analysis code know that these
4138 stores cannot alias stores to void*! */
4139 tree field;
4150 /* This class is non-empty. */
4154 }
4157 }
4159 /* Fixup the inline function given by INFO now that the class is
4160 complete. */
4162 static void
4164 {
4166 {
4169 {
4172 }
4173 }
4174 }
4176 /* Fixup the inline methods and friends in TYPE now that TYPE is
4177 complete. */
4179 static void
4181 {
4187 {
4192 else
4194 }
4196 /* Do inline member functions. */
4200 /* Do friends. */
4205 }
4207 /* Add OFFSET to all base types of BINFO which is a base in the
4208 hierarchy dominated by T.
4210 OFFSET, which is a type offset, is number of bytes. */
4212 static void
4214 {
4216 tree primary_binfo;
4217 tree base_binfo;
4219 /* Update BINFO's offset. */
4224 offset));
4226 /* Find the primary base class. */
4232 /* Scan all of the bases, pushing the BINFO_OFFSET adjust
4233 downwards. */
4235 {
4236 /* Don't do the primary base twice. */
4244 }
4245 }
4247 /* Set BINFO_OFFSET for all of the virtual bases for RLI->T. Update
4248 TYPE_ALIGN and TYPE_SIZE for T. OFFSETS gives the location of
4249 empty subobjects of T. */
4251 static void
4253 {
4254 tree vbase;
4263 {
4264 /* In G++ 3.2, we incorrectly rounded the size before laying out
4265 the virtual bases. */
4267 #ifdef STRUCTURE_SIZE_BOUNDARY
4268 /* Packed structures don't need to have minimum size. */
4271 #endif
4275 }
4277 /* Find the last field. The artificial fields created for virtual
4278 bases will go after the last extant field to date. */
4283 /* Go through the virtual bases, allocating space for each virtual
4284 base that is not already a primary base class. These are
4285 allocated in inheritance graph order. */
4287 {
4292 {
4295 /* This virtual base is not a primary base of any class in the
4296 hierarchy, so we have to add space for it. */
4300 /* If the first virtual base might have been placed at a
4301 lower address, had we started from CLASSTYPE_SIZE, rather
4302 than TYPE_SIZE, issue a warning. There can be both false
4303 positives and false negatives from this warning in rare
4304 cases; to deal with all the possibilities would probably
4305 require performing both layout algorithms and comparing
4306 the results which is not particularly tractable. */
4308 && first_vbase
4309 && (tree_int_cst_lt
4313 bitsize_unit_node),
4317 basetype);
4320 }
4321 }
4322 }
4324 /* Returns the offset of the byte just past the end of the base class
4325 BINFO. */
4327 static tree
4329 {
4330 tree size;
4333 /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to
4334 allocate some space for it. It cannot have virtual bases, so
4335 TYPE_SIZE_UNIT is fine. */
4337 else
4341 }
4343 /* Returns the offset of the byte just past the end of the base class
4344 with the highest offset in T. If INCLUDE_VIRTUALS_P is zero, then
4345 only non-virtual bases are included. */
4347 static tree
4349 {
4352 tree binfo;
4353 tree base_binfo;
4354 tree offset;
4359 {
4369 }
4371 /* G++ 3.2 did not check indirect virtual bases. */
4375 {
4379 }
4382 }
4384 /* Warn about bases of T that are inaccessible because they are
4385 ambiguous. For example:
4387 struct S {};
4388 struct T : public S {};
4389 struct U : public S, public T {};
4391 Here, `(S*) new U' is not allowed because there are two `S'
4392 subobjects of U. */
4394 static void
4396 {
4399 tree basetype;
4400 tree binfo;
4401 tree base_binfo;
4403 /* If there are no repeated bases, nothing can be ambiguous. */
4407 /* Check direct bases. */
4410 {
4416 }
4418 /* Check for ambiguous virtual bases. */
4422 {
4428 }
4429 }
4431 /* Compare two INTEGER_CSTs K1 and K2. */
4433 static int
4435 {
4437 }
4439 /* Increase the size indicated in RLI to account for empty classes
4440 that are "off the end" of the class. */
4442 static void
4444 {
4445 tree eoc;
4446 tree rli_size;
4448 /* It might be the case that we grew the class to allocate a
4449 zero-sized base class. That won't be reflected in RLI, yet,
4450 because we are willing to overlay multiple bases at the same
4451 offset. However, now we need to make sure that RLI is big enough
4452 to reflect the entire class. */
4458 {
4460 /* In version 1 of the ABI, the size of a class that ends with
4461 a bitfield was not rounded up to a whole multiple of a
4462 byte. Because rli_size_unit_so_far returns only the number
4463 of fully allocated bytes, any extra bits were not included
4464 in the size. */
4466 else
4467 /* The size should have been rounded to a whole byte. */
4470 rli->bitpos
4479 }
4480 }
4482 /* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T. Calculate
4483 BINFO_OFFSETs for all of the base-classes. Position the vtable
4484 pointer. Accumulate declared virtual functions on VIRTUALS_P. */
4486 static void
4488 {
4489 tree non_static_data_members;
4490 tree field;
4491 tree vptr;
4492 record_layout_info rli;
4493 /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of
4494 types that appear at that offset. */
4495 splay_tree empty_base_offsets;
4496 /* True if the last field layed out was a bit-field. */
4498 /* The location at which the next field should be inserted. */
4500 /* T, as a base class. */
4501 tree base_t;
4503 /* Keep track of the first non-static data member. */
4506 /* Start laying out the record. */
4509 /* Mark all the primary bases in the hierarchy. */
4512 /* Create a pointer to our virtual function table. */
4515 /* The vptr is always the first thing in the class. */
4517 {
4522 }
4523 else
4526 /* Build FIELD_DECLs for all of the non-virtual base-types. */
4531 /* Layout the non-static data members. */
4533 {
4534 tree type;
4535 tree padding;
4537 /* We still pass things that aren't non-static data members to
4538 the back-end, in case it wants to do something with them. */
4540 {
4542 /* If the static data member has incomplete type, keep track
4543 of it so that it can be completed later. (The handling
4544 of pending statics in finish_record_layout is
4545 insufficient; consider:
4547 struct S1;
4548 struct S2 { static S1 s1; };
4550 At this point, finish_record_layout will be called, but
4551 S1 is still incomplete.) */
4553 {
4555 /* The visibility of static data members is determined
4556 at their point of declaration, not their point of
4557 definition. */
4559 }
4561 }
4567 /* If this field is a bit-field whose width is greater than its
4568 type, then there are some special rules for allocating
4569 it. */
4572 {
4573 integer_type_kind itk;
4574 tree integer_type;
4576 /* We must allocate the bits as if suitably aligned for the
4577 longest integer type that fits in this many bits. type
4578 of the field. Then, we are supposed to use the left over
4579 bits as additional padding. */
4585 /* ITK now indicates a type that is too large for the
4586 field. We have to back up by one to find the largest
4587 type that fits. */
4590 /* Figure out how much additional padding is required. GCC
4591 3.2 always created a padding field, even if it had zero
4592 width. */
4595 {
4597 /* In a union, the padding field must have the full width
4598 of the bit-field; all fields start at offset zero. */
4600 else
4601 {
4604 "ABI-compliant and may change in a future "
4606 t);
4609 }
4610 }
4611 #ifdef PCC_BITFIELD_TYPE_MATTERS
4612 /* An unnamed bitfield does not normally affect the
4613 alignment of the containing class on a target where
4614 PCC_BITFIELD_TYPE_MATTERS. But, the C++ ABI does not
4615 make any exceptions for unnamed bitfields when the
4616 bitfields are longer than their types. Therefore, we
4617 temporarily give the field a name. */
4619 {
4622 }
4623 #endif
4628 empty_base_offsets);
4631 /* Now that layout has been performed, set the size of the
4632 field to the size of its declared type; the rest of the
4633 field is effectively invisible. */
4635 /* We must also reset the DECL_MODE of the field. */
4640 /* Versions of G++ before G++ 3.4 did not reset the
4641 DECL_MODE. */
4644 }
4645 else
4647 empty_base_offsets);
4649 /* Remember the location of any empty classes in FIELD. */
4653 empty_base_offsets,
4656 /* If a bit-field does not immediately follow another bit-field,
4657 and yet it starts in the middle of a byte, we have failed to
4658 comply with the ABI. */
4661 && !last_field_was_bitfield
4664 bitsize_unit_node)))
4667 field);
4669 /* G++ used to use DECL_FIELD_OFFSET as if it were the byte
4670 offset of the field. */
4676 "classes to be placed at different locations in a "
4678 field);
4680 /* If we needed additional padding after this field, add it
4681 now. */
4683 {
4684 tree padding_field;
4687 NULL_TREE,
4688 char_type_node);
4695 NULL_TREE,
4696 empty_base_offsets);
4697 }
4700 }
4703 {
4704 /* Make sure that we are on a byte boundary so that the size of
4705 the class without virtual bases will always be a round number
4706 of bytes. */
4709 }
4711 /* G++ 3.2 does not allow virtual bases to be overlaid with tail
4712 padding. */
4716 /* Delete all zero-width bit-fields from the list of fields. Now
4717 that the type is laid out they are no longer important. */
4720 /* Create the version of T used for virtual bases. We do not use
4721 make_aggr_type for this version; this is an artificial type. For
4722 a POD type, we just reuse T. */
4724 {
4727 /* Set the size and alignment for the new type. In G++ 3.2, all
4728 empty classes were considered to have size zero when used as
4729 base classes. */
4731 {
4737 t);
4738 }
4739 else
4740 {
4741 tree eoc;
4743 /* If the ABI version is not at least two, and the last
4744 field was a bit-field, RLI may not be on a byte
4745 boundary. In particular, rli_size_unit_so_far might
4746 indicate the last complete byte, while rli_size_so_far
4747 indicates the total number of bits used. Therefore,
4748 rli_size_so_far, rather than rli_size_unit_so_far, is
4749 used to compute TYPE_SIZE_UNIT. */
4757 eoc);
4764 }
4768 /* Copy the fields from T. */
4772 {
4783 }
4785 /* Record the base version of the type. */
4788 }
4789 else
4792 /* Every empty class contains an empty class. */
4796 /* Set the TYPE_DECL for this type to contain the right
4797 value for DECL_OFFSET, so that we can use it as part
4798 of a COMPONENT_REF for multiple inheritance. */
4801 /* Now fix up any virtual base class types that we left lying
4802 around. We must get these done before we try to lay out the
4803 virtual function table. As a side-effect, this will remove the
4804 base subobject fields. */
4807 /* Make sure that empty classes are reflected in RLI at this
4808 point. */
4811 /* Make sure not to create any structures with zero size. */
4816 /* Let the back-end lay out the type. */
4819 /* Warn about bases that can't be talked about due to ambiguity. */
4822 /* Now that we're done with layout, give the base fields the real types. */
4827 /* Clean up. */
4829 }
4831 /* Determine the "key method" for the class type indicated by TYPE,
4832 and set CLASSTYPE_KEY_METHOD accordingly. */
4834 void
4836 {
4837 tree method;
4840 || processing_template_decl
4845 /* The key method is the first non-pure virtual function that is not
4846 inline at the point of class definition. On some targets the
4847 key function may not be inline; those targets should not call
4848 this function until the end of the translation unit. */
4854 {
4857 }
4860 }
4862 /* Perform processing required when the definition of T (a class type)
4863 is complete. */
4865 void
4867 {
4868 tree x;
4869 /* A TREE_LIST. The TREE_VALUE of each node is a FUNCTION_DECL. */
4874 {
4879 }
4881 /* If this type was previously laid out as a forward reference,
4882 make sure we lay it out again. */
4888 /* Make assumptions about the class; we'll reset the flags if
4889 necessary. */
4894 /* Do end-of-class semantic processing: checking the validity of the
4895 bases and members and add implicitly generated methods. */
4898 /* Find the key method. */
4900 {
4901 /* The Itanium C++ ABI permits the key method to be chosen when
4902 the class is defined -- even though the key method so
4903 selected may later turn out to be an inline function. On
4904 some systems (such as ARM Symbian OS) the key method cannot
4905 be determined until the end of the translation unit. On such
4906 systems, we leave CLASSTYPE_KEY_METHOD set to NULL, which
4907 will cause the class to be added to KEYED_CLASSES. Then, in
4908 finish_file we will determine the key method. */
4912 /* If a polymorphic class has no key method, we may emit the vtable
4913 in every translation unit where the class definition appears. */
4916 }
4918 /* Layout the class itself. */
4921 /* We use the base type for trivial assignments, and hence it
4922 needs a mode. */
4927 /* If necessary, create the primary vtable for this class. */
4929 {
4930 /* We must enter these virtuals into the table. */
4934 /* Here we know enough to change the type of our virtual
4935 function table, but we will wait until later this function. */
4937 }
4940 {
4942 tree fn;
4949 /* Add entries for virtual functions introduced by this class. */
4953 /* Set DECL_VINDEX for all functions declared in this class. */
4955 fn;
4957 vindex += (TARGET_VTABLE_USES_DESCRIPTORS
4959 {
4963 /* A thunk. We should never be calling this entry directly
4964 from this vtable -- we'd use the entry for the non
4965 thunk base function. */
4969 }
4970 }
4974 /* Complete the rtl for any static member objects of the type we're
4975 working on. */
4981 /* Done with FIELDS...now decide whether to sort these for
4982 faster lookups later.
4984 We use a small number because most searches fail (succeeding
4985 ultimately as the search bores through the inheritance
4986 hierarchy), and we want this failure to occur quickly. */
4990 {
4997 field_decl_cmp);
5001 }
5003 /* Make the rtl for any new vtables we have created, and unmark
5004 the base types we marked. */
5007 /* Build the VTT for T. */
5013 {
5016 /* Warn only if the dtor is non-private or the class has friends */
5021 }
5032 /* Finish debugging output for this type. */
5034 }
5036 /* When T was built up, the member declarations were added in reverse
5037 order. Rearrange them to declaration order. */
5039 void
5041 {
5042 tree next;
5043 tree prev;
5044 tree x;
5046 /* The following lists are all in reverse order. Put them in
5047 declaration order now. */
5051 /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
5052 reverse order, so we can't just use nreverse. */
5057 {
5061 }
5063 {
5067 }
5068 }
5070 tree
5072 {
5075 /* Now that we've got all the field declarations, reverse everything
5076 as necessary. */
5081 /* Nadger the current location so that diagnostics point to the start of
5082 the struct, not the end. */
5086 {
5087 tree x;
5092 /* We need to emit an error message if this type was used as a parameter
5093 and it is an abstract type, even if it is a template. We construct
5094 a simple CLASSTYPE_PURE_VIRTUALS list without taking bases into
5095 account and we call complete_vars with this type, which will check
5096 the PARM_DECLS. Note that while the type is being defined,
5097 CLASSTYPE_PURE_VIRTUALS contains the list of the inline friends
5098 (see CLASSTYPE_INLINE_FRIENDS) so we need to clear it. */
5104 }
5105 else
5114 else
5121 }
5122 \f
5123 /* Return the dynamic type of INSTANCE, if known.
5124 Used to determine whether the virtual function table is needed
5125 or not.
5127 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5128 of our knowledge of its type. *NONNULL should be initialized
5129 before this function is called. */
5131 static tree
5133 {
5135 {
5139 else
5144 /* This is a call to a constructor, hence it's never zero. */
5146 {
5150 }
5154 /* This is a call to a constructor, hence it's never zero. */
5156 {
5160 }
5168 /* Propagate nonnull. */
5179 {
5180 /* Just because we see an ADDR_EXPR doesn't mean we're dealing
5181 with a real object -- given &p->f, p can still be null. */
5183 /* ??? Probably should check DECL_WEAK here. */
5186 }
5190 /* If this component is really a base class reference, then the field
5191 itself isn't definitive. */
5200 {
5204 }
5205 /* fall through... */
5210 {
5214 }
5216 {
5220 /* if we're in a ctor or dtor, we know our type. */
5224 {
5228 }
5229 }
5231 {
5232 /* Reference variables should be references to objects. */
5236 /* DECL_VAR_MARKED_P is used to prevent recursion; a
5237 variable's initializer may refer to the variable
5238 itself. */
5242 {
5243 tree type;
5249 }
5250 }
5255 }
5256 }
5258 /* Return nonzero if the dynamic type of INSTANCE is known, and
5259 equivalent to the static type. We also handle the case where
5260 INSTANCE is really a pointer. Return negative if this is a
5261 ctor/dtor. There the dynamic type is known, but this might not be
5262 the most derived base of the original object, and hence virtual
5263 bases may not be layed out according to this type.
5265 Used to determine whether the virtual function table is needed
5266 or not.
5268 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5269 of our knowledge of its type. *NONNULL should be initialized
5270 before this function is called. */
5272 int
5274 {
5286 }
5288 \f
5289 void
5291 {
5294 current_class_stack
5301 }
5303 /* Restore the cached PREVIOUS_CLASS_LEVEL. */
5305 static void
5307 {
5308 tree type;
5310 /* We are re-entering the same class we just left, so we don't
5311 have to search the whole inheritance matrix to find all the
5312 decls to bind again. Instead, we install the cached
5313 class_shadowed list and walk through it binding names. */
5316 /* Restore IDENTIFIER_TYPE_VALUE. */
5318 type;
5321 }
5323 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
5324 appropriate for TYPE.
5326 So that we may avoid calls to lookup_name, we cache the _TYPE
5327 nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
5329 For multiple inheritance, we perform a two-pass depth-first search
5330 of the type lattice. */
5332 void
5334 {
5337 /* Make sure there is enough room for the new entry on the stack. */
5339 {
5341 current_class_stack
5343 current_class_stack_size
5345 }
5347 /* Insert a new entry on the class stack. */
5352 current_class_depth++;
5354 /* Now set up the new type. */
5360 /* By default, things in classes are private, while things in
5361 structures or unions are public. */
5363 ? access_private_node
5369 {
5370 /* Forcibly remove any old class remnants. */
5372 }
5378 else
5380 }
5382 /* When we exit a toplevel class scope, we save its binding level so
5383 that we can restore it quickly. Here, we've entered some other
5384 class, so we must invalidate our cache. */
5386 void
5388 {
5390 }
5392 /* Get out of the current class scope. If we were in a class scope
5393 previously, that is the one popped to. */
5395 void
5397 {
5400 current_class_depth--;
5406 }
5408 /* Returns 1 if current_class_type is either T or a nested type of T.
5409 We start looking from 1 because entry 0 is from global scope, and has
5410 no type. */
5412 int
5414 {
5423 }
5425 /* If either current_class_type or one of its enclosing classes are derived
5426 from T, return the appropriate type. Used to determine how we found
5427 something via unqualified lookup. */
5429 tree
5431 {
5434 /* The bases of a dependent type are unknown. */
5449 }
5451 /* When entering a class scope, all enclosing class scopes' names with
5452 static meaning (static variables, static functions, types and
5453 enumerators) have to be visible. This recursive function calls
5454 pushclass for all enclosing class contexts until global or a local
5455 scope is reached. TYPE is the enclosed class. */
5457 void
5459 {
5460 tree context;
5462 /* A namespace might be passed in error cases, like A::B:C. */
5476 }
5478 /* Undoes a push_nested_class call. */
5480 void
5482 {
5488 }
5490 /* Returns the number of extern "LANG" blocks we are nested within. */
5492 int
5494 {
5496 }
5498 /* Set global variables CURRENT_LANG_NAME to appropriate value
5499 so that behavior of name-mangling machinery is correct. */
5501 void
5503 {
5507 {
5509 }
5511 {
5513 /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
5514 (See record_builtin_java_type in decl.c.) However, that causes
5515 incorrect debug entries if these types are actually used.
5516 So we re-enable debug output after extern "Java". */
5525 }
5527 {
5529 }
5530 else
5532 }
5534 /* Get out of the current language scope. */
5536 void
5538 {
5541 }
5542 \f
5543 /* Type instantiation routines. */
5545 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
5546 matches the TARGET_TYPE. If there is no satisfactory match, return
5547 error_mark_node, and issue a error & warning messages under control
5548 of FLAGS. Permit pointers to member function if FLAGS permits. If
5549 TEMPLATE_ONLY, the name of the overloaded function was a
5550 template-id, and EXPLICIT_TARGS are the explicitly provided
5551 template arguments. */
5553 static tree
5555 tree overload,
5556 tsubst_flags_t flags,
5558 tree explicit_targs)
5559 {
5560 /* Here's what the standard says:
5562 [over.over]
5564 If the name is a function template, template argument deduction
5565 is done, and if the argument deduction succeeds, the deduced
5566 arguments are used to generate a single template function, which
5567 is added to the set of overloaded functions considered.
5569 Non-member functions and static member functions match targets of
5570 type "pointer-to-function" or "reference-to-function." Nonstatic
5571 member functions match targets of type "pointer-to-member
5572 function;" the function type of the pointer to member is used to
5573 select the member function from the set of overloaded member
5574 functions. If a nonstatic member function is selected, the
5575 reference to the overloaded function name is required to have the
5576 form of a pointer to member as described in 5.3.1.
5578 If more than one function is selected, any template functions in
5579 the set are eliminated if the set also contains a non-template
5580 function, and any given template function is eliminated if the
5581 set contains a second template function that is more specialized
5582 than the first according to the partial ordering rules 14.5.5.2.
5583 After such eliminations, if any, there shall remain exactly one
5584 selected function. */
5588 /* We store the matches in a TREE_LIST rooted here. The functions
5589 are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
5590 interoperability with most_specialized_instantiation. */
5592 tree fn;
5594 /* By the time we get here, we should be seeing only real
5595 pointer-to-member types, not the internal POINTER_TYPE to
5596 METHOD_TYPE representation. */
5602 /* Check that the TARGET_TYPE is reasonable. */
5606 /* This is OK, too. */
5609 {
5610 /* This is OK, too. This comes from a conversion to reference
5611 type. */
5614 }
5615 else
5616 {
5622 }
5624 /* If we can find a non-template function that matches, we can just
5625 use it. There's no point in generating template instantiations
5626 if we're just going to throw them out anyhow. But, of course, we
5627 can only do this when we don't *need* a template function. */
5629 {
5630 tree fns;
5633 {
5635 tree fntype;
5638 /* We're not looking for templates just yet. */
5643 /* We're looking for a non-static member, and this isn't
5644 one, or vice versa. */
5647 /* Ignore anticipated decls of undeclared builtins. */
5651 /* See if there's a match. */
5660 }
5661 }
5663 /* Now, if we've already got a match (or matches), there's no need
5664 to proceed to the template functions. But, if we don't have a
5665 match we need to look at them, too. */
5667 {
5668 tree target_fn_type;
5669 tree target_arg_types;
5670 tree target_ret_type;
5671 tree fns;
5674 target_fn_type
5676 else
5681 /* Never do unification on the 'this' parameter. */
5686 {
5688 tree instantiation;
5689 tree instantiation_type;
5690 tree targs;
5693 /* We're only looking for templates. */
5698 /* We're not looking for a non-static member, and this is
5699 one, or vice versa. */
5702 /* Try to do argument deduction. */
5707 /* Argument deduction failed. */
5710 /* Instantiate the template. */
5713 /* Instantiation failed. */
5716 /* See if there's a match. */
5719 instantiation_type =
5725 }
5727 /* Now, remove all but the most specialized of the matches. */
5729 {
5734 }
5735 }
5737 /* Now we should have exactly one function in MATCHES. */
5739 {
5740 /* There were *no* matches. */
5742 {
5745 target_type);
5747 /* print_candidates expects a chain with the functions in
5748 TREE_VALUE slots, so we cons one up here (we're losing anyway,
5749 so why be clever?). */
5752 matches);
5755 }
5757 }
5759 {
5760 /* There were too many matches. */
5763 {
5764 tree match;
5768 target_type);
5770 /* Since print_candidates expects the functions in the
5771 TREE_VALUE slot, we flip them here. */
5776 }
5779 }
5781 /* Good, exactly one match. Now, convert it to the correct type. */
5786 {
5794 {
5797 }
5798 }
5800 /* If we're doing overload resolution purely for the purpose of
5801 determining conversion sequences, we should not consider the
5802 function used. If this conversion sequence is selected, the
5803 function will be marked as used at this point. */
5809 else
5810 {
5811 /* The target must be a REFERENCE_TYPE. Above, build_unary_op
5812 will mark the function as addressed, but here we must do it
5813 explicitly. */
5817 }
5818 }
5820 /* This function will instantiate the type of the expression given in
5821 RHS to match the type of LHSTYPE. If errors exist, then return
5822 error_mark_node. FLAGS is a bit mask. If TF_ERROR is set, then
5823 we complain on errors. If we are not complaining, never modify rhs,
5824 as overload resolution wants to try many possible instantiations, in
5825 the hope that at least one will work.
5827 For non-recursive calls, LHSTYPE should be a function, pointer to
5828 function, or a pointer to member function. */
5830 tree
5832 {
5838 {
5842 }
5845 {
5851 /* Microsoft allows `A::f' to be resolved to a
5852 pointer-to-member. */
5853 ;
5854 else
5855 {
5860 }
5861 }
5866 /* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot
5867 deduce any type information. */
5869 {
5873 }
5875 /* We don't overwrite rhs if it is an overloaded function.
5876 Copying it would destroy the tree link. */
5880 /* This should really only be used when attempting to distinguish
5881 what sort of a pointer to function we have. For now, any
5882 arithmetic operation which is not supported on pointers
5883 is rejected as an error. */
5886 {
5895 {
5896 tree new_rhs;
5906 }
5914 {
5920 /* Do not lose object's side effects. */
5924 }
5931 /* This can happen if we are forming a pointer-to-member for a
5932 member template. */
5935 /* Fall through. */
5938 {
5942 return
5945 args);
5946 }
5950 return
5956 /* This is too hard for now. */
6028 {
6032 }
6055 {
6060 }
6067 }
6069 }
6070 \f
6071 /* Return the name of the virtual function pointer field
6072 (as an IDENTIFIER_NODE) for the given TYPE. Note that
6073 this may have to look back through base types to find the
6074 ultimate field name. (For single inheritance, these could
6075 all be the same name. Who knows for multiple inheritance). */
6077 static tree
6079 {
6086 {
6092 }
6099 }
6101 void
6103 {
6104 #ifdef GATHER_STATISTICS
6108 {
6113 }
6114 #endif
6115 }
6117 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
6118 according to [class]:
6119 The class-name is also inserted
6120 into the scope of the class itself. For purposes of access checking,
6121 the inserted class name is treated as if it were a public member name. */
6123 void
6125 {
6128 tree saved_cas;
6142 }
6144 /* Returns 1 if TYPE contains only padding bytes. */
6146 int
6148 {
6155 /* In G++ 3.2, whether or not a class was empty was determined by
6156 looking at its size. */
6159 else
6161 }
6163 /* Returns true if TYPE contains an empty class. */
6165 static bool
6167 {
6171 {
6172 tree field;
6173 tree binfo;
6174 tree base_binfo;
6186 }
6190 }
6192 /* Find the enclosing class of the given NODE. NODE can be a *_DECL or
6193 a *_TYPE node. NODE can also be a local class. */
6195 tree
6197 {
6201 {
6203 {
6216 }
6217 }
6219 }
6221 /* Note that NAME was looked up while the current class was being
6222 defined and that the result of that lookup was DECL. */
6224 void
6226 {
6227 splay_tree names_used;
6229 /* If we're not defining a class, there's nothing to do. */
6234 /* If there's already a binding for this NAME, then we don't have
6235 anything to worry about. */
6248 }
6250 /* Note that NAME was declared (as DECL) in the current class. Check
6251 to see that the declaration is valid. */
6253 void
6255 {
6256 splay_tree names_used;
6257 splay_tree_node n;
6259 /* Look to see if we ever used this name. */
6260 names_used
6267 {
6268 /* [basic.scope.class]
6270 A name N used in a class S shall refer to the same declaration
6271 in its context and when re-evaluated in the completed scope of
6272 S. */
6277 }
6278 }
6280 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
6281 Secondary vtables are merged with primary vtables; this function
6282 will return the VAR_DECL for the primary vtable. */
6284 tree
6286 {
6287 tree decl;
6291 {
6294 }
6298 }
6301 /* Returns the binfo for the primary base of BINFO. If the resulting
6302 BINFO is a virtual base, and it is inherited elsewhere in the
6303 hierarchy, then the returned binfo might not be the primary base of
6304 BINFO in the complete object. Check BINFO_PRIMARY_P or
6305 BINFO_LOST_PRIMARY_P to be sure. */
6307 tree
6309 {
6310 tree primary_base;
6311 tree result;
6319 }
6321 /* If INDENTED_P is zero, indent to INDENT. Return nonzero. */
6323 static int
6325 {
6329 }
6331 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
6332 INDENT should be zero when called from the top level; it is
6333 incremented recursively. IGO indicates the next expected BINFO in
6334 inheritance graph ordering. */
6336 static tree
6339 tree binfo,
6340 tree igo,
6342 {
6344 tree base_binfo;
6352 {
6355 }
6370 {
6374 TFF_PLAIN_IDENTIFIER),
6376 }
6378 {
6381 }
6386 {
6390 {
6394 TFF_PLAIN_IDENTIFIER));
6395 }
6397 {
6401 TFF_PLAIN_IDENTIFIER));
6402 }
6404 {
6408 TFF_PLAIN_IDENTIFIER));
6409 }
6411 {
6415 TFF_PLAIN_IDENTIFIER));
6416 }
6420 }
6426 }
6428 /* Dump the BINFO hierarchy for T. */
6430 static void
6432 {
6444 }
6446 /* Debug interface to hierarchy dumping. */
6450 {
6452 }
6454 static void
6456 {
6461 {
6464 }
6465 }
6467 static void
6469 {
6470 tree inits;
6472 HOST_WIDE_INT elt;
6480 TFF_PLAIN_IDENTIFIER));
6487 }
6489 static void
6491 {
6499 {
6506 {
6510 }
6514 }
6517 }
6519 static void
6521 {
6529 {
6534 }
6537 }
6539 /* Dump a function or thunk and its thunkees. */
6541 static void
6543 {
6546 tree thunks;
6554 {
6564 else
6570 }
6574 }
6576 /* Dump the thunks for FN. */
6580 {
6582 }
6584 /* Virtual function table initialization. */
6586 /* Create all the necessary vtables for T and its base classes. */
6588 static void
6590 {
6591 tree list;
6592 tree vbase;
6594 /* We lay out the primary and secondary vtables in one contiguous
6595 vtable. The primary vtable is first, followed by the non-virtual
6596 secondary vtables in inheritance graph order. */
6601 /* Then come the virtual bases, also in inheritance graph order. */
6603 {
6607 }
6611 }
6613 /* Initialize the vtable for BINFO with the INITS. */
6615 static void
6617 {
6618 tree decl;
6624 }
6626 /* Build the VTT (virtual table table) for T.
6627 A class requires a VTT if it has virtual bases.
6629 This holds
6630 1 - primary virtual pointer for complete object T
6631 2 - secondary VTTs for each direct non-virtual base of T which requires a
6632 VTT
6633 3 - secondary virtual pointers for each direct or indirect base of T which
6634 has virtual bases or is reachable via a virtual path from T.
6635 4 - secondary VTTs for each direct or indirect virtual base of T.
6637 Secondary VTTs look like complete object VTTs without part 4. */
6639 static void
6641 {
6642 tree inits;
6643 tree type;
6644 tree vtt;
6645 tree index;
6647 /* Build up the initializers for the VTT. */
6652 /* If we didn't need a VTT, we're done. */
6656 /* Figure out the type of the VTT. */
6660 /* Now, build the VTT object itself. */
6663 /* Add the VTT to the vtables list. */
6668 }
6670 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
6671 PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
6672 and CHAIN the vtable pointer for this binfo after construction is
6673 complete. VALUE can also be another BINFO, in which case we recurse. */
6675 static tree
6677 {
6678 tree vt;
6681 {
6687 else
6689 }
6692 }
6694 /* Data for secondary VTT initialization. */
6696 {
6697 /* Is this the primary VTT? */
6700 /* Current index into the VTT. */
6701 tree index;
6703 /* TREE_LIST of initializers built up. */
6704 tree inits;
6706 /* The type being constructed by this secondary VTT. */
6707 tree type_being_constructed;
6710 /* Recursively build the VTT-initializer for BINFO (which is in the
6711 hierarchy dominated by T). INITS points to the end of the initializer
6712 list to date. INDEX is the VTT index where the next element will be
6713 replaced. Iff BINFO is the binfo for T, this is the top level VTT (i.e.
6714 not a subvtt for some base of T). When that is so, we emit the sub-VTTs
6715 for virtual bases of T. When it is not so, we build the constructor
6716 vtables for the BINFO-in-T variant. */
6720 {
6722 tree b;
6723 tree init;
6724 tree secondary_vptrs;
6725 secondary_vptr_vtt_init_data data;
6728 /* We only need VTTs for subobjects with virtual bases. */
6732 /* We need to use a construction vtable if this is not the primary
6733 VTT. */
6735 {
6738 /* Record the offset in the VTT where this sub-VTT can be found. */
6740 }
6742 /* Add the address of the primary vtable for the complete object. */
6747 {
6750 }
6753 /* Recursively add the secondary VTTs for non-virtual bases. */
6758 /* Add secondary virtual pointers for all subobjects of BINFO with
6759 either virtual bases or reachable along a virtual path, except
6760 subobjects that are non-virtual primary bases. */
6770 /* The secondary vptrs come back in reverse order. After we reverse
6771 them, and add the INITS, the last init will be the first element
6772 of the chain. */
6775 {
6779 }
6782 /* Add the secondary VTTs for virtual bases in inheritance graph
6783 order. */
6785 {
6790 }
6791 else
6792 /* Remove the ctor vtables we created. */
6796 }
6798 /* Called from build_vtt_inits via dfs_walk. BINFO is the binfo for the base
6799 in most derived. DATA is a SECONDARY_VPTR_VTT_INIT_DATA structure. */
6801 static tree
6803 {
6806 /* We don't care about bases that don't have vtables. */
6810 /* We're only interested in proper subobjects of the type being
6811 constructed. */
6815 /* We're only interested in bases with virtual bases or reachable
6816 via a virtual path from the type being constructed. */
6821 /* We're not interested in non-virtual primary bases. */
6825 /* Record the index where this secondary vptr can be found. */
6827 {
6832 {
6833 /* It's a primary virtual base, and this is not a
6834 construction vtable. Find the base this is primary of in
6835 the inheritance graph, and use that base's vtable
6836 now. */
6839 }
6840 }
6842 /* Add the initializer for the secondary vptr itself. */
6845 /* Advance the vtt index. */
6850 }
6852 /* Called from build_vtt_inits via dfs_walk. After building
6853 constructor vtables and generating the sub-vtt from them, we need
6854 to restore the BINFO_VTABLES that were scribbled on. DATA is the
6855 binfo of the base whose sub vtt was generated. */
6857 static tree
6859 {
6863 /* If this class has no vtable, none of its bases do. */
6867 /* This might be a primary base, so have no vtable in this
6868 hierarchy. */
6871 /* If we scribbled the construction vtable vptr into BINFO, clear it
6872 out now. */
6878 }
6880 /* Build the construction vtable group for BINFO which is in the
6881 hierarchy dominated by T. */
6883 static void
6885 {
6886 tree list;
6887 tree type;
6888 tree vtbl;
6889 tree inits;
6890 tree id;
6891 tree vbase;
6893 /* See if we've already created this construction vtable group. */
6899 /* Build a version of VTBL (with the wrong type) for use in
6900 constructing the addresses of secondary vtables in the
6901 construction vtable group. */
6908 /* Add the vtables for each of our virtual bases using the vbase in T
6909 binfo. */
6911 vbase;
6913 {
6914 tree b;
6921 }
6924 /* Figure out the type of the construction vtable. */
6929 /* Initialize the construction vtable. */
6933 }
6935 /* Add the vtbl initializers for BINFO (and its bases other than
6936 non-virtual primaries) to the list of INITS. BINFO is in the
6937 hierarchy dominated by T. RTTI_BINFO is the binfo within T of
6938 the constructor the vtbl inits should be accumulated for. (If this
6939 is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
6940 ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
6941 BINFO is the active base equivalent of ORIG_BINFO in the inheritance
6942 graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
6943 but are not necessarily the same in terms of layout. */
6945 static void
6947 tree orig_binfo,
6948 tree rtti_binfo,
6949 tree t,
6950 tree inits)
6951 {
6953 tree base_binfo;
6958 /* If it doesn't have a vptr, we don't do anything. */
6962 /* If we're building a construction vtable, we're not interested in
6963 subobjects that don't require construction vtables. */
6969 /* Build the initializers for the BINFO-in-T vtable. */
6975 /* Walk the BINFO and its bases. We walk in preorder so that as we
6976 initialize each vtable we can figure out at what offset the
6977 secondary vtable lies from the primary vtable. We can't use
6978 dfs_walk here because we need to iterate through bases of BINFO
6979 and RTTI_BINFO simultaneously. */
6981 {
6982 /* Skip virtual bases. */
6988 inits);
6989 }
6990 }
6992 /* Called from accumulate_vtbl_inits. Returns the initializers for
6993 the BINFO vtable. */
6995 static tree
6997 tree orig_binfo,
6998 tree rtti_binfo,
6999 tree t,
7000 tree l)
7001 {
7008 {
7009 /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
7010 primary virtual base. If it is not the same primary in
7011 the hierarchy of T, we'll need to generate a ctor vtable
7012 for it, to place at its location in T. If it is the same
7013 primary, we still need a VTT entry for the vtable, but it
7014 should point to the ctor vtable for the base it is a
7015 primary for within the sub-hierarchy of RTTI_BINFO.
7017 There are three possible cases:
7019 1) We are in the same place.
7020 2) We are a primary base within a lost primary virtual base of
7021 RTTI_BINFO.
7022 3) We are primary to something not a base of RTTI_BINFO. */
7024 tree b;
7027 /* First, look through the bases we are primary to for RTTI_BINFO
7028 or a virtual base. */
7031 {
7036 }
7037 /* If we run out of primary links, keep looking down our
7038 inheritance chain; we might be an indirect primary. */
7042 found:
7044 /* If we found RTTI_BINFO, this is case 1. If we found a virtual
7045 base B and it is a base of RTTI_BINFO, this is case 2. In
7046 either case, we share our vtable with LAST, i.e. the
7047 derived-most base within B of which we are a primary. */
7050 /* Just set our BINFO_VTABLE to point to LAST, as we may not have
7051 set LAST's BINFO_VTABLE yet. We'll extract the actual vptr in
7052 binfo_ctor_vtable after everything's been set up. */
7055 /* Otherwise, this is case 3 and we get our own. */
7056 }
7061 {
7062 tree index;
7065 /* Compute the initializer for this vtable. */
7069 /* Figure out the position to which the VPTR should point. */
7077 index);
7079 }
7082 /* For a construction vtable, we can't overwrite BINFO_VTABLE.
7083 So, we make a TREE_LIST. Later, dfs_fixup_binfo_vtbls will
7084 straighten this out. */
7088 else
7089 /* For an ordinary vtable, set BINFO_VTABLE. */
7093 }
7095 /* Construct the initializer for BINFO's virtual function table. BINFO
7096 is part of the hierarchy dominated by T. If we're building a
7097 construction vtable, the ORIG_BINFO is the binfo we should use to
7098 find the actual function pointers to put in the vtable - but they
7099 can be overridden on the path to most-derived in the graph that
7100 ORIG_BINFO belongs. Otherwise,
7101 ORIG_BINFO should be the same as BINFO. The RTTI_BINFO is the
7102 BINFO that should be indicated by the RTTI information in the
7103 vtable; it will be a base class of T, rather than T itself, if we
7104 are building a construction vtable.
7106 The value returned is a TREE_LIST suitable for wrapping in a
7107 CONSTRUCTOR to use as the DECL_INITIAL for a vtable. If
7108 NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
7109 number of non-function entries in the vtable.
7111 It might seem that this function should never be called with a
7112 BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
7113 base is always subsumed by a derived class vtable. However, when
7114 we are building construction vtables, we do build vtables for
7115 primary bases; we need these while the primary base is being
7116 constructed. */
7118 static tree
7120 tree orig_binfo,
7121 tree t,
7122 tree rtti_binfo,
7124 {
7126 tree vfun_inits;
7127 vtbl_init_data vid;
7129 tree vbinfo;
7132 /* Initialize VID. */
7141 /* The first vbase or vcall offset is at index -3 in the vtable. */
7144 /* Add entries to the vtable for RTTI. */
7147 /* Create an array for keeping track of the functions we've
7148 processed. When we see multiple functions with the same
7149 signature, we share the vcall offsets. */
7151 /* Add the vcall and vbase offset entries. */
7154 /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
7155 build_vbase_offset_vtbl_entries. */
7160 /* If the target requires padding between data entries, add that now. */
7162 {
7166 {
7173 null_pointer_node),
7174 add);
7176 }
7177 }
7182 /* Go through all the ordinary virtual functions, building up
7183 initializers. */
7186 {
7187 tree delta;
7188 tree vcall_index;
7195 {
7199 {
7202 }
7204 }
7206 /* If the only definition of this function signature along our
7207 primary base chain is from a lost primary, this vtable slot will
7208 never be used, so just zero it out. This is important to avoid
7209 requiring extra thunks which cannot be generated with the function.
7211 We first check this in update_vtable_entry_for_fn, so we handle
7212 restored primary bases properly; we also need to do it here so we
7213 zero out unused slots in ctor vtables, rather than filling themff
7214 with erroneous values (though harmless, apart from relocation
7215 costs). */
7217 {
7218 /* We found a defn before a lost primary; go ahead as normal. */
7222 /* The nearest definition is from a lost primary; clear the
7223 slot. */
7225 {
7228 }
7229 }
7232 {
7233 /* Pull the offset for `this', and the function to call, out of
7234 the list. */
7241 /* You can't call an abstract virtual function; it's abstract.
7242 So, we replace these functions with __pure_virtual. */
7246 {
7250 }
7251 /* Take the address of the function, considering it to be of an
7252 appropriate generic type. */
7254 }
7256 /* And add it to the chain of initializers. */
7258 {
7263 else
7265 {
7273 }
7274 }
7275 else
7277 }
7279 /* The initializers for virtual functions were built up in reverse
7280 order; straighten them out now. */
7283 /* The negative offset initializers are also in reverse order. */
7286 /* Chain the two together. */
7288 }
7290 /* Adds to vid->inits the initializers for the vbase and vcall
7291 offsets in BINFO, which is in the hierarchy dominated by T. */
7293 static void
7295 {
7296 tree b;
7298 /* If this is a derived class, we must first create entries
7299 corresponding to the primary base class. */
7304 /* Add the vbase entries for this base. */
7306 /* Add the vcall entries for this base. */
7308 }
7310 /* Returns the initializers for the vbase offset entries in the vtable
7311 for BINFO (which is part of the class hierarchy dominated by T), in
7312 reverse order. VBASE_OFFSET_INDEX gives the vtable index
7313 where the next vbase offset will go. */
7315 static void
7317 {
7318 tree vbase;
7319 tree t;
7320 tree non_primary_binfo;
7322 /* If there are no virtual baseclasses, then there is nothing to
7323 do. */
7329 /* We might be a primary base class. Go up the inheritance hierarchy
7330 until we find the most derived class of which we are a primary base:
7331 it is the offset of that which we need to use. */
7334 {
7335 tree b;
7337 /* If we have reached a virtual base, then it must be a primary
7338 base (possibly multi-level) of vid->binfo, or we wouldn't
7339 have called build_vcall_and_vbase_vtbl_entries for it. But it
7340 might be a lost primary, so just skip down to vid->binfo. */
7342 {
7345 }
7351 }
7353 /* Go through the virtual bases, adding the offsets. */
7355 vbase;
7357 {
7358 tree b;
7359 tree delta;
7364 /* Find the instance of this virtual base in the complete
7365 object. */
7368 /* If we've already got an offset for this virtual base, we
7369 don't need another one. */
7374 /* Figure out where we can find this vbase offset. */
7383 /* The vbase offset had better be the same. */
7386 /* The next vbase will come at a more negative offset. */
7390 /* The initializer is the delta from BINFO to this virtual base.
7391 The vbase offsets go in reverse inheritance-graph order, and
7392 we are walking in inheritance graph order so these end up in
7393 the right order. */
7399 vtable_entry_type,
7400 delta)));
7402 }
7403 }
7405 /* Adds the initializers for the vcall offset entries in the vtable
7406 for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
7407 to VID->INITS. */
7409 static void
7411 {
7412 /* We only need these entries if this base is a virtual base. We
7413 compute the indices -- but do not add to the vtable -- when
7414 building the main vtable for a class. */
7416 {
7417 /* We need a vcall offset for each of the virtual functions in this
7418 vtable. For example:
7420 class A { virtual void f (); };
7421 class B1 : virtual public A { virtual void f (); };
7422 class B2 : virtual public A { virtual void f (); };
7423 class C: public B1, public B2 { virtual void f (); };
7425 A C object has a primary base of B1, which has a primary base of A. A
7426 C also has a secondary base of B2, which no longer has a primary base
7427 of A. So the B2-in-C construction vtable needs a secondary vtable for
7428 A, which will adjust the A* to a B2* to call f. We have no way of
7429 knowing what (or even whether) this offset will be when we define B2,
7430 so we store this "vcall offset" in the A sub-vtable and look it up in
7431 a "virtual thunk" for B2::f.
7433 We need entries for all the functions in our primary vtable and
7434 in our non-virtual bases' secondary vtables. */
7436 /* If we are just computing the vcall indices -- but do not need
7437 the actual entries -- not that. */
7440 /* Now, walk through the non-virtual bases, adding vcall offsets. */
7442 }
7443 }
7445 /* Build vcall offsets, starting with those for BINFO. */
7447 static void
7449 {
7451 tree primary_binfo;
7452 tree base_binfo;
7454 /* Don't walk into virtual bases -- except, of course, for the
7455 virtual base for which we are building vcall offsets. Any
7456 primary virtual base will have already had its offsets generated
7457 through the recursion in build_vcall_and_vbase_vtbl_entries. */
7461 /* If BINFO has a primary base, process it first. */
7466 /* Add BINFO itself to the list. */
7469 /* Scan the non-primary bases of BINFO. */
7473 }
7475 /* Called from build_vcall_offset_vtbl_entries_r. */
7477 static void
7479 {
7480 /* Make entries for the rest of the virtuals. */
7482 {
7483 tree orig_fn;
7485 /* The ABI requires that the methods be processed in declaration
7486 order. G++ 3.2 used the order in the vtable. */
7488 orig_fn;
7492 }
7493 else
7494 {
7495 tree derived_virtuals;
7496 tree base_virtuals;
7497 tree orig_virtuals;
7498 /* If BINFO is a primary base, the most derived class which has
7499 BINFO as a primary base; otherwise, just BINFO. */
7500 tree non_primary_binfo;
7502 /* We might be a primary base class. Go up the inheritance hierarchy
7503 until we find the most derived class of which we are a primary base:
7504 it is the BINFO_VIRTUALS there that we need to consider. */
7507 {
7508 tree b;
7510 /* If we have reached a virtual base, then it must be vid->vbase,
7511 because we ignore other virtual bases in
7512 add_vcall_offset_vtbl_entries_r. In turn, it must be a primary
7513 base (possibly multi-level) of vid->binfo, or we wouldn't
7514 have called build_vcall_and_vbase_vtbl_entries for it. But it
7515 might be a lost primary, so just skip down to vid->binfo. */
7517 {
7521 }
7527 }
7530 /* For a ctor vtable we need the equivalent binfo within the hierarchy
7531 where rtti_binfo is the most derived type. */
7532 non_primary_binfo
7538 base_virtuals;
7542 {
7543 tree orig_fn;
7545 /* Find the declaration that originally caused this function to
7546 be present in BINFO_TYPE (binfo). */
7549 /* When processing BINFO, we only want to generate vcall slots for
7550 function slots introduced in BINFO. So don't try to generate
7551 one if the function isn't even defined in BINFO. */
7556 }
7557 }
7558 }
7560 /* Add a vcall offset entry for ORIG_FN to the vtable. */
7562 static void
7564 {
7566 tree vcall_offset;
7568 /* If there is already an entry for a function with the same
7569 signature as FN, then we do not need a second vcall offset.
7570 Check the list of functions already present in the derived
7571 class vtable. */
7573 {
7574 tree derived_entry;
7578 /* We only use one vcall offset for virtual destructors,
7579 even though there are two virtual table entries. */
7583 }
7585 /* If we are building these vcall offsets as part of building
7586 the vtable for the most derived class, remember the vcall
7587 offset. */
7589 {
7592 NULL);
7595 }
7597 /* The next vcall offset will be found at a more negative
7598 offset. */
7602 /* Keep track of this function. */
7606 {
7607 tree base;
7608 tree fn;
7610 /* Find the overriding function. */
7614 integer_zero_node);
7615 else
7616 {
7619 /* The vbase we're working on is a primary base of
7620 vid->binfo. But it might be a lost primary, so its
7621 BINFO_OFFSET might be wrong, so we just use the
7622 BINFO_OFFSET from vid->binfo. */
7626 vcall_offset));
7627 }
7628 /* Add the initializer to the vtable. */
7631 }
7632 }
7634 /* Return vtbl initializers for the RTTI entries corresponding to the
7635 BINFO's vtable. The RTTI entries should indicate the object given
7636 by VID->rtti_binfo. */
7638 static void
7640 {
7641 tree b;
7642 tree t;
7643 tree basetype;
7644 tree offset;
7645 tree decl;
7646 tree init;
7651 /* To find the complete object, we will first convert to our most
7652 primary base, and then add the offset in the vtbl to that value. */
7656 {
7657 tree primary_base;
7663 }
7666 /* The second entry is the address of the typeinfo object. */
7669 else
7672 /* Convert the declaration to a type that can be stored in the
7673 vtable. */
7678 /* Add the offset-to-top entry. It comes earlier in the vtable that
7679 the the typeinfo entry. Convert the offset to look like a
7680 function pointer, so that we can put it in the vtable. */
7684 }
7686 /* Fold a OBJ_TYPE_REF expression to the address of a function.
7687 KNOWN_TYPE carries the true type of OBJ_TYPE_REF_OBJECT(REF). */
7689 tree
7691 {
7695 tree fndecl;
7698 {
7699 i += (TARGET_VTABLE_USES_DESCRIPTORS
7702 }
7706 #ifdef ENABLE_CHECKING
7709 #endif
7712 }