| blob | 8a0da05899eb7d36350de78aa5e8d40131cd0b3e |
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 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. */
301 /* If this is a simple base reference, express it as a COMPONENT_REF. */
303 /* We don't build base fields for empty bases, and they aren't very
304 interesting to the optimizers anyway. */
306 {
313 }
316 {
317 /* Going via virtual base V_BINFO. We need the static offset
318 from V_BINFO to BINFO, and the dynamic offset from D_BINFO to
319 V_BINFO. That offset is an entry in D_BINFO's vtable. */
320 tree v_offset;
323 {
324 /* In a base member initializer, we cannot rely on
325 the vtable being set up. We have to use the vtt_parm. */
327 tree t;
335 }
336 else
344 v_offset);
357 /* Negative fixed_type_p means this is a constructor or destructor;
358 virtual base layout is fixed in in-charge [cd]tors, but not in
359 base [cd]tors. */
363 v_offset,
365 else
367 }
371 target_type = cp_build_qualified_type
381 else
387 out:
391 integer_zero_node))));
394 }
396 /* Subroutine of build_base_path; EXPR and BINFO are as in that function.
397 Perform a derived-to-base conversion by recursively building up a
398 sequence of COMPONENT_REFs to the appropriate base fields. */
400 static tree
402 {
405 tree field;
408 {
411 }
413 /* Recurse. */
418 /* Is this the base field created by build_base_field? */
425 /* Didn't find the base field?!? */
427 }
429 /* Convert OBJECT to the base TYPE. OBJECT is an expression whose
430 type is a class type or a pointer to a class type. In the former
431 case, TYPE is also a class type; in the latter it is another
432 pointer type. If CHECK_ACCESS is true, an error message is emitted
433 if TYPE is inaccessible. If OBJECT has pointer type, the value is
434 assumed to be non-NULL. */
436 tree
438 {
439 tree binfo;
440 tree object_type;
443 {
446 }
447 else
452 NULL);
457 }
459 /* EXPR is an expression with unqualified class type. BASE is a base
460 binfo of that class type. Returns EXPR, converted to the BASE
461 type. This function assumes that EXPR is the most derived class;
462 therefore virtual bases can be found at their static offsets. */
464 tree
466 {
467 tree expr_type;
471 {
472 tree pointer_type;
481 }
484 }
486 \f
487 tree
489 {
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. */
663 /* Mark the VAR_DECL node representing the vtable itself as a
664 "gratuitous" one, thereby forcing dwarfout.c to ignore it. It
665 is rather important that such things be ignored because any
666 effort to actually generate DWARF for them will run into
667 trouble when/if we encounter code like:
669 #pragma interface
670 struct S { virtual void member (); };
672 because the artificial declaration of the vtable itself (as
673 manufactured by the g++ front end) will say that the vtable is
674 a static member of `S' but only *after* the debug output for
675 the definition of `S' has already been output. This causes
676 grief because the DWARF entry for the definition of the vtable
677 will try to refer back to an earlier *declaration* of the
678 vtable as a static member of `S' and there won't be one. We
679 might be able to arrange to have the "vtable static member"
680 attached to the member list for `S' before the debug info for
681 `S' get written (which would solve the problem) but that would
682 require more intrusive changes to the g++ front end. */
686 }
688 /* Get the VAR_DECL of the vtable for TYPE. TYPE need not be polymorphic,
689 or even complete. If this does not exist, create it. If COMPLETE is
690 nonzero, then complete the definition of it -- that will render it
691 impossible to actually build the vtable, but is useful to get at those
692 which are known to exist in the runtime. */
694 tree
696 {
697 tree decl;
706 {
709 }
712 }
714 /* Build the primary virtual function table for TYPE. If BINFO is
715 non-NULL, build the vtable starting with the initial approximation
716 that it is the same as the one which is the head of the association
717 list. Returns a nonzero value if a new vtable is actually
718 created. */
720 static int
722 {
723 tree decl;
724 tree virtuals;
729 {
731 /* We have already created a vtable for this base, so there's
732 no need to do it again. */
739 }
740 else
741 {
744 }
746 #ifdef GATHER_STATISTICS
749 #endif
751 /* Initialize the association list for this type, based
752 on our first approximation. */
757 }
759 /* Give BINFO a new virtual function table which is initialized
760 with a skeleton-copy of its original initialization. The only
761 entry that changes is the `delta' entry, so we can really
762 share a lot of structure.
764 FOR_TYPE is the most derived type which caused this table to
765 be needed.
767 Returns nonzero if we haven't met BINFO before.
769 The order in which vtables are built (by calling this function) for
770 an object must remain the same, otherwise a binary incompatibility
771 can result. */
773 static int
775 {
777 /* We already created a vtable for this base. There's no need to
778 do it again. */
781 /* Remember that we've created a vtable for this BINFO, so that we
782 don't try to do so again. */
785 /* Make fresh virtual list, so we can smash it later. */
788 /* Secondary vtables are laid out as part of the same structure as
789 the primary vtable. */
792 }
794 /* Create a new vtable for BINFO which is the hierarchy dominated by
795 T. Return nonzero if we actually created a new vtable. */
797 static int
799 {
801 /* In this case, it is *type*'s vtable we are modifying. We start
802 with the approximation that its vtable is that of the
803 immediate base class. */
805 else
806 /* This is our very own copy of `basetype' to play with. Later,
807 we will fill in all the virtual functions that override the
808 virtual functions in these base classes which are not defined
809 by the current type. */
811 }
813 /* Make *VIRTUALS, an entry on the BINFO_VIRTUALS list for BINFO
814 (which is in the hierarchy dominated by T) list FNDECL as its
815 BV_FN. DELTA is the required constant adjustment from the `this'
816 pointer where the vtable entry appears to the `this' required when
817 the function is actually called. */
819 static void
821 tree binfo,
822 tree fndecl,
823 tree delta,
825 {
826 tree v;
832 {
833 /* We need a new vtable for BINFO. */
835 {
836 /* If we really did make a new vtable, we also made a copy
837 of the BINFO_VIRTUALS list. Now, we have to find the
838 corresponding entry in that list. */
843 }
848 }
849 }
851 \f
852 /* Add method METHOD to class TYPE. */
854 void
856 {
859 tree overload;
864 tree current_fns;
876 {
877 /* Make a new method vector. We start with 8 entries. We must
878 allocate at least two (for constructors and destructors), and
879 we're going to end up with an assignment operator at some
880 point as well. */
882 /* Create slots for constructors and destructors. */
886 }
888 /* Constructors and destructors go in special slots. */
892 {
901 }
902 else
903 {
905 tree m;
908 /* See if we already have an entry with this name. */
912 {
915 {
920 }
924 {
927 }
932 }
933 }
937 /* TYPE is a template class. Don't issue any errors now; wait
938 until instantiation time to complain. */
939 ;
940 else
941 {
942 tree fns;
944 /* Check to see if we've already got this method. */
946 {
948 tree parms1;
949 tree parms2;
955 /* [over.load] Member function declarations with the
956 same name and the same parameter types cannot be
957 overloaded if any of them is a static member
958 function declaration.
960 [namespace.udecl] When a using-declaration brings names
961 from a base class into a derived class scope, member
962 functions in the derived class override and/or hide member
963 functions with the same name and parameter types in a base
964 class (rather than conflicting). */
968 /* Compare the quals on the 'this' parm. Don't compare
969 the whole types, as used functions are treated as
970 coming from the using class in overload resolution. */
977 /* For templates, the template parms must be identical. */
992 {
994 /* Defer to the local function. */
996 else
997 {
1001 /* We don't call duplicate_decls here to merge
1002 the declarations because that will confuse
1003 things if the methods have inline
1004 definitions. In particular, we will crash
1005 while processing the definitions. */
1007 }
1008 }
1009 }
1010 }
1012 /* Add the new binding. */
1019 {
1020 /* We only expect to add few methods in the COMPLETE_P case, so
1021 just make room for one more method in that case. */
1026 else
1028 }
1029 else
1030 /* Replace the current slot. */
1032 }
1034 /* Subroutines of finish_struct. */
1036 /* Change the access of FDECL to ACCESS in T. Return 1 if change was
1037 legit, otherwise return 0. */
1039 static int
1041 {
1042 tree elem;
1051 {
1053 {
1057 else
1060 }
1061 else
1062 {
1063 /* They're changing the access to the same thing they changed
1064 it to before. That's OK. */
1065 ;
1066 }
1067 }
1068 else
1069 {
1073 }
1075 }
1077 /* Process the USING_DECL, which is a member of T. */
1079 static void
1081 {
1084 tree access
1090 tree old_value;
1097 {
1104 }
1107 {
1110 }
1112 {
1115 }
1120 {
1123 }
1126 /* Ignore base type this came from. */
1131 {
1137 else
1139 }
1145 ;
1147 {
1149 /* It's OK to use functions from a base when there are functions with
1151 else
1152 {
1157 }
1158 }
1160 {
1164 }
1166 /* Make type T see field decl FDECL with access ACCESS. */
1169 {
1172 }
1173 else
1175 }
1176 \f
1177 /* Run through the base classes of T, updating
1178 CANT_HAVE_DEFAULT_CTOR_P, CANT_HAVE_CONST_CTOR_P, and
1179 NO_CONST_ASN_REF_P. Also set flag bits in T based on properties of
1180 the bases. */
1182 static void
1187 {
1190 tree base_binfo;
1191 tree binfo;
1197 {
1202 /* Effective C++ rule 14. We only need to check TYPE_POLYMORPHIC_P
1203 here because the case of virtual functions but non-virtual
1204 dtor is handled in finish_struct_1. */
1209 /* If the base class doesn't have copy constructors or
1210 assignment operators that take const references, then the
1211 derived class cannot have such a member automatically
1212 generated. */
1218 /* Similarly, if the base class doesn't have a default
1219 constructor, then the derived class won't have an
1220 automatically generated default constructor. */
1223 {
1228 basetype);
1229 }
1232 /* A virtual base does not effect nearly emptiness. */
1233 ;
1235 {
1237 /* And if there is more than one nearly empty base, then the
1238 derived class is not nearly empty either. */
1240 else
1241 /* Remember we've seen one. */
1243 }
1245 /* If the base class is not empty or nearly empty, then this
1246 class cannot be nearly empty. */
1249 /* A lot of properties from the bases also apply to the derived
1250 class. */
1260 }
1261 }
1263 /* Determine all the primary bases within T. Sets BINFO_PRIMARY_BASE_P for
1264 those that are primaries. Sets BINFO_LOST_PRIMARY_P for those
1265 that have had a nearly-empty virtual primary base stolen by some
1266 other base in the hierarchy. Determines CLASSTYPE_PRIMARY_BASE for
1267 T. */
1269 static void
1271 {
1275 tree base_binfo;
1277 /* Determine the primary bases of our bases. */
1280 {
1283 /* See if we're the non-virtual primary of our inheritance
1284 chain. */
1286 {
1293 /* We are the primary binfo. */
1295 }
1296 /* Determine if we have a virtual primary base, and mark it so.
1297 */
1299 {
1303 /* Someone already claimed this base. */
1305 else
1306 {
1307 tree delta;
1312 /* A virtual binfo might have been copied from within
1313 another hierarchy. As we're about to use it as a
1314 primary base, make sure the offsets match. */
1321 }
1322 }
1323 }
1325 /* First look for a dynamic direct non-virtual base. */
1327 {
1331 {
1334 }
1335 }
1337 /* A "nearly-empty" virtual base class can be the primary base
1338 class, if no non-virtual polymorphic base can be found. Look for
1339 a nearly-empty virtual dynamic base that is not already a primary
1340 base of something in the hierarchy. If there is no such base,
1341 just pick the first nearly-empty virtual base. */
1347 {
1349 {
1350 /* Found one that is not primary. */
1353 }
1355 /* Remember the first candidate. */
1357 }
1359 found:
1360 /* If we've got a primary base, use it. */
1362 {
1367 /* We are stealing a primary base. */
1371 {
1372 tree delta;
1375 /* A virtual binfo might have been copied from within
1376 another hierarchy. As we're about to use it as a primary
1377 base, make sure the offsets match. */
1382 }
1389 }
1390 }
1391 \f
1392 /* Set memoizing fields and bits of T (and its variants) for later
1393 use. */
1395 static void
1397 {
1398 tree variants;
1400 /* Fix up variants (if any). */
1402 variants;
1404 {
1405 /* These fields are in the _TYPE part of the node, not in
1406 the TYPE_LANG_SPECIFIC component, so they are not shared. */
1417 /* Copy whatever these are holding today. */
1423 }
1426 /* For a class w/o baseclasses, 'finish_struct' has set
1427 CLASSTYPE_PURE_VIRTUALS correctly (by definition).
1428 Similarly for a class whose base classes do not have vtables.
1429 When neither of these is true, we might have removed abstract
1430 virtuals (by providing a definition), added some (by declaring
1431 new ones), or redeclared ones from a base class. We need to
1432 recalculate what's really an abstract virtual at this point (by
1433 looking in the vtables). */
1436 /* If this type has a copy constructor or a destructor, force its
1437 mode to be BLKmode, and force its TREE_ADDRESSABLE bit to be
1438 nonzero. This will cause it to be passed by invisible reference
1439 and prevent it from being returned in a register. */
1441 {
1442 tree variants;
1445 {
1448 }
1449 }
1450 }
1452 /* Issue warnings about T having private constructors, but no friends,
1453 and so forth.
1455 HAS_NONPRIVATE_METHOD is nonzero if T has any non-private methods or
1456 static members. HAS_NONPRIVATE_STATIC_FN is nonzero if T has any
1457 non-private static member functions. */
1459 static void
1461 {
1464 tree fn;
1467 /* If the class has friends, those entities might create and
1468 access instances, so we should not warn. */
1471 /* We will have warned when the template was declared; there's
1472 no need to warn on every instantiation. */
1474 /* There's no reason to even consider warning about this
1475 class. */
1478 /* We only issue one warning, if more than one applies, because
1479 otherwise, on code like:
1481 class A {
1482 // Oops - forgot `public:'
1483 A();
1484 A(const A&);
1485 ~A();
1486 };
1488 we warn several times about essentially the same problem. */
1490 /* Check to see if all (non-constructor, non-destructor) member
1491 functions are private. (Since there are no friends or
1492 non-private statics, we can't ever call any of the private member
1493 functions.) */
1495 /* We're not interested in compiler-generated methods; they don't
1496 provide any way to call private members. */
1498 {
1500 {
1502 /* A non-private static member function is just like a
1503 friend; it can create and invoke private member
1504 functions, and be accessed without a class
1505 instance. */
1509 /* Keep searching for a static member function. */
1510 }
1513 }
1516 {
1517 /* There are no non-private methods, and there's at least one
1518 private member function that isn't a constructor or
1519 destructor. (If all the private members are
1520 constructors/destructors we want to use the code below that
1521 issues error messages specifically referring to
1522 constructors/destructors.) */
1528 {
1531 }
1533 {
1536 }
1537 }
1539 /* Even if some of the member functions are non-private, the class
1540 won't be useful for much if all the constructors or destructors
1541 are private: such an object can never be created or destroyed. */
1544 {
1546 t);
1548 }
1551 {
1554 /* If a non-template class does not define a copy
1555 constructor, one is defined for it, enabling it to avoid
1556 this warning. For a template class, this does not
1557 happen, and so we would normally get a warning on:
1559 template <class T> class C { private: C(); };
1561 To avoid this asymmetry, we check TYPE_HAS_INIT_REF. All
1562 complete non-template or fully instantiated classes have this
1563 flag set. */
1566 else
1568 {
1570 /* Ideally, we wouldn't count copy constructors (or, in
1571 fact, any constructor that takes an argument of the
1572 class type as a parameter) because such things cannot
1573 be used to construct an instance of the class unless
1574 you already have one. But, for now at least, we're
1575 more generous. */
1577 {
1580 }
1581 }
1584 {
1586 t);
1588 }
1589 }
1590 }
1593 gt_pointer_operator new_value;
1597 /* Comparison function to compare two TYPE_METHOD_VEC entries by name. */
1599 static int
1601 {
1614 }
1616 /* This routine compares two fields like method_name_cmp but using the
1617 pointer operator in resort_field_decl_data. */
1619 static int
1621 {
1630 {
1637 }
1639 }
1641 /* Resort TYPE_METHOD_VEC because pointers have been reordered. */
1643 void
1646 gt_pointer_operator new_value,
1648 {
1652 tree fn;
1654 /* The type conversion ops have to live at the front of the vec, so we
1655 can't sort them. */
1663 {
1667 resort_method_name_cmp);
1668 }
1669 }
1671 /* Warn about duplicate methods in fn_fields.
1673 Sort methods that are not special (i.e., constructors, destructors,
1674 and type conversion operators) so that we can find them faster in
1675 search. */
1677 static void
1679 {
1680 tree fn_fields;
1690 /* Clear DECL_IN_AGGR_P for all functions. */
1696 /* We thought there was a destructor, but there wasn't. Some
1697 parse errors cause this anomalous situation. */
1700 /* Issue warnings about private constructors and such. If there are
1701 no methods, then some public defaults are generated. */
1704 /* The type conversion ops have to live at the front of the vec, so we
1705 can't sort them. */
1714 }
1716 /* Make BINFO's vtable have N entries, including RTTI entries,
1717 vbase and vcall offsets, etc. Set its type and call the backend
1718 to lay it out. */
1720 static void
1722 {
1723 tree atype;
1724 tree vtable;
1730 /* We may have to grow the vtable. */
1733 {
1737 }
1738 }
1740 /* True iff FNDECL and BASE_FNDECL (both non-static member functions)
1741 have the same signature. */
1743 int
1745 {
1746 /* One destructor overrides another if they are the same kind of
1747 destructor. */
1751 /* But a non-destructor never overrides a destructor, nor vice
1752 versa, nor do different kinds of destructors override
1753 one-another. For example, a complete object destructor does not
1754 override a deleting destructor. */
1763 {
1771 }
1773 }
1775 /* Returns TRUE if DERIVED is a binfo containing the binfo BASE as a
1776 subobject. */
1778 static bool
1780 {
1781 tree probe;
1784 {
1788 /* If we meet a virtual base, we can't follow the inheritance
1789 any more. See if the complete type of DERIVED contains
1790 such a virtual base. */
1793 }
1795 }
1798 /* The function for which we are trying to find a final overrider. */
1799 tree fn;
1800 /* The base class in which the function was declared. */
1801 tree declaring_base;
1802 /* The candidate overriders. */
1803 tree candidates;
1804 /* Path to most derived. */
1808 /* Add the overrider along the current path to FFOD->CANDIDATES.
1809 Returns true if an overrider was found; false otherwise. */
1811 static bool
1815 {
1816 tree method;
1818 /* If BINFO is not the most derived type, try a more derived class.
1819 A definition there will overrider a definition here. */
1821 {
1822 depth--;
1826 }
1830 {
1833 /* Remove any candidates overridden by this new function. */
1835 {
1836 /* If *CANDIDATE overrides METHOD, then METHOD
1837 cannot override anything else on the list. */
1840 /* If METHOD overrides *CANDIDATE, remove *CANDIDATE. */
1843 else
1845 }
1847 /* Add the new function. */
1850 }
1853 }
1855 /* Called from find_final_overrider via dfs_walk. */
1857 static tree
1859 {
1867 }
1869 static tree
1871 {
1876 }
1878 /* Returns a TREE_LIST whose TREE_PURPOSE is the final overrider for
1879 FN and whose TREE_VALUE is the binfo for the base where the
1880 overriding occurs. BINFO (in the hierarchy dominated by the binfo
1881 DERIVED) is the base object in which FN is declared. */
1883 static tree
1885 {
1886 find_final_overrider_data ffod;
1888 /* Getting this right is a little tricky. This is valid:
1890 struct S { virtual void f (); };
1891 struct T { virtual void f (); };
1892 struct U : public S, public T { };
1894 even though calling `f' in `U' is ambiguous. But,
1896 struct R { virtual void f(); };
1897 struct S : virtual public R { virtual void f (); };
1898 struct T : virtual public R { virtual void f (); };
1899 struct U : public S, public T { };
1901 is not -- there's no way to decide whether to put `S::f' or
1902 `T::f' in the vtable for `R'.
1904 The solution is to look at all paths to BINFO. If we find
1905 different overriders along any two, then there is a problem. */
1909 /* Determine the depth of the hierarchy. */
1920 /* If there was no winner, issue an error message. */
1922 {
1926 }
1929 }
1931 /* Return the index of the vcall offset for FN when TYPE is used as a
1932 virtual base. */
1934 static tree
1936 {
1938 tree_pair_p p;
1946 /* There should always be an appropriate index. */
1948 }
1950 /* Update an entry in the vtable for BINFO, which is in the hierarchy
1951 dominated by T. FN has been overridden in BINFO; VIRTUALS points to the
1952 corresponding position in the BINFO_VIRTUALS list. */
1954 static void
1957 {
1958 tree b;
1959 tree overrider;
1960 tree delta;
1961 tree virtual_base;
1962 tree first_defn;
1968 /* Find the nearest primary base (possibly binfo itself) which defines
1969 this function; this is the class the caller will convert to when
1970 calling FN through BINFO. */
1972 {
1977 /* The nearest definition is from a lost primary. */
1980 }
1983 /* Find the final overrider. */
1989 /* Check for adjusting covariant return types. */
1997 {
1998 /* If FN is a covariant thunk, we must figure out the adjustment
1999 to the final base FN was converting to. As OVERRIDER_TARGET might
2000 also be converting to the return type of FN, we have to
2001 combine the two conversions here. */
2005 {
2009 }
2010 else
2014 /* Find the equivalent binfo within the return type of the
2015 overriding function. We will want the vbase offset from
2016 there. */
2021 {
2022 /* There was no existing virtual thunk (which takes
2023 precedence). */
2024 tree thunk_binfo;
2025 base_kind kind;
2033 {
2037 {
2038 /* We convert via virtual base. Find the virtual
2039 base and adjust the fixed offset to be from there. */
2044 offset = size_diffop
2047 }
2049 /* There was an existing fixed offset, this must be
2050 from the base just converted to, and the base the
2051 FN was thunking to. */
2053 else
2055 }
2056 }
2059 /* Replace the overriding function with a covariant thunk. We
2060 will emit the overriding function in its own slot as
2061 well. */
2064 }
2065 else
2068 /* Assume that we will produce a thunk that convert all the way to
2069 the final overrider, and not to an intermediate virtual base. */
2072 /* See if we can convert to an intermediate virtual base first, and then
2073 use the vcall offset located there to finish the conversion. */
2075 {
2076 /* If we find the final overrider, then we can stop
2077 walking. */
2082 /* If we find a virtual base, and we haven't yet found the
2083 overrider, then there is a virtual base between the
2084 declaring base (first_defn) and the final overrider. */
2086 {
2089 }
2090 }
2093 {
2094 /* The ABI specifies that a covariant thunk includes a mangling
2095 for a this pointer adjustment. This-adjusting thunks that
2096 override a function from a virtual base have a vcall
2097 adjustment. When the virtual base in question is a primary
2098 virtual base, we know the adjustments are zero, (and in the
2099 non-covariant case, we would not use the thunk).
2100 Unfortunately we didn't notice this could happen, when
2101 designing the ABI and so never mandated that such a covariant
2102 thunk should be emitted. Because we must use the ABI mandated
2103 name, we must continue searching from the binfo where we
2104 found the most recent definition of the function, towards the
2105 primary binfo which first introduced the function into the
2106 vtable. If that enters a virtual base, we must use a vcall
2107 this-adjusting thunk. Bleah! */
2116 /* Even if we find a virtual base, the correct delta is
2117 between the overrider and the binfo we're building a vtable
2118 for. */
2120 }
2122 /* Compute the constant adjustment to the `this' pointer. The
2123 `this' pointer, when this function is called, will point at BINFO
2124 (or one of its primary bases, which are at the same offset). */
2126 /* The `this' pointer needs to be adjusted from the declaration to
2127 the nearest virtual base. */
2131 /* If the nearest definition is in a lost primary, we don't need an
2132 entry in our vtable. Except possibly in a constructor vtable,
2133 if we happen to get our primary back. In that case, the offset
2134 will be zero, as it will be a primary base. */
2136 else
2137 /* The `this' pointer needs to be adjusted from pointing to
2138 BINFO to pointing at the base where the final overrider
2139 appears. */
2140 virtual_covariant:
2150 else
2152 }
2154 /* Called from modify_all_vtables via dfs_walk. */
2156 static tree
2158 {
2160 tree virtuals;
2161 tree old_virtuals;
2165 /* A base without a vtable needs no modification, and its bases
2166 are uninteresting. */
2171 /* Don't do the primary vtable, if it's new. */
2175 /* There's no need to modify the vtable for a non-virtual primary
2176 base; we're not going to use that vtable anyhow. We do still
2177 need to do this for virtual primary bases, as they could become
2178 non-primary in a construction vtable. */
2183 /* Now, go through each of the virtual functions in the virtual
2184 function table for BINFO. Find the final overrider, and update
2185 the BINFO_VIRTUALS list appropriately. */
2188 virtuals;
2192 binfo,
2197 }
2199 /* Update all of the primary and secondary vtables for T. Create new
2200 vtables as required, and initialize their RTTI information. Each
2201 of the functions in VIRTUALS is declared in T and may override a
2202 virtual function from a base class; find and modify the appropriate
2203 entries to point to the overriding functions. Returns a list, in
2204 declaration order, of the virtual functions that are declared in T,
2205 but do not appear in the primary base class vtable, and which
2206 should therefore be appended to the end of the vtable for T. */
2208 static tree
2210 {
2214 /* Update all of the vtables. */
2217 /* Add virtual functions not already in our primary vtable. These
2218 will be both those introduced by this class, and those overridden
2219 from secondary bases. It does not include virtuals merely
2220 inherited from secondary bases. */
2222 {
2227 {
2228 /* We don't need to adjust the `this' pointer when
2229 calling this function. */
2233 /* This is a function not already in our vtable. Keep it. */
2235 }
2236 else
2237 /* We've already got an entry for this function. Skip it. */
2239 }
2242 }
2244 /* Get the base virtual function declarations in T that have the
2245 indicated NAME. */
2247 static tree
2249 {
2250 tree methods;
2255 /* Find virtual functions in T with the indicated NAME. */
2259 methods;
2261 {
2267 }
2273 {
2276 base_fndecls);
2277 }
2280 }
2282 /* If this declaration supersedes the declaration of
2283 a method declared virtual in the base class, then
2284 mark this field as being virtual as well. */
2286 static void
2288 {
2290 /* In [temp.mem] we have:
2292 A specialization of a member function template does not
2293 override a virtual function from a base class. */
2300 /* Set DECL_VINDEX to a value that is neither an INTEGER_CST nor
2301 the error_mark_node so that we know it is an overriding
2302 function. */
2306 {
2310 }
2311 }
2313 /* Warn about hidden virtual functions that are not overridden in t.
2314 We know that constructors and destructors don't apply. */
2316 void
2318 {
2320 tree fns;
2323 /* We go through each separately named virtual function. */
2327 {
2328 tree fn;
2329 tree name;
2330 tree fndecl;
2331 tree base_fndecls;
2332 tree base_binfo;
2333 tree binfo;
2336 /* All functions in this slot in the CLASSTYPE_METHOD_VEC will
2337 have the same name. Figure out what name that is. */
2339 /* There are no possibly hidden functions yet. */
2341 /* Iterate through all of the base classes looking for possibly
2342 hidden functions. */
2345 {
2348 base_fndecls);
2349 }
2351 /* If there are no functions to hide, continue. */
2355 /* Remove any overridden functions. */
2357 {
2360 {
2364 /* If the method from the base class has the same
2365 signature as the method from the derived class, it
2366 has been overridden. */
2369 else
2371 }
2372 }
2374 /* Now give a warning for all base functions without overriders,
2375 as they are hidden. */
2377 {
2378 /* Here we know it is a hider, and no overrider exists. */
2382 }
2383 }
2384 }
2386 /* Check for things that are invalid. There are probably plenty of other
2387 things we should check for also. */
2389 static void
2391 {
2392 tree field;
2395 {
2403 {
2406 {
2407 /* We're generally only interested in entities the user
2408 declared, but we also find nested classes by noticing
2409 the TYPE_DECL that we create implicitly. You're
2410 allowed to put one anonymous union inside another,
2411 though, so we explicitly tolerate that. We use
2412 TYPE_ANONYMOUS_P rather than ANON_AGGR_TYPE_P so that
2413 we also allow unnamed types used for defining fields. */
2420 {
2423 elt);
2425 }
2429 elt);
2432 elt);
2436 }
2437 }
2438 }
2439 }
2441 /* Add T to CLASSTYPE_DECL_LIST of current_class_type which
2442 will be used later during class template instantiation.
2443 When FRIEND_P is zero, T can be a static member data (VAR_DECL),
2444 a non-static member data (FIELD_DECL), a member function
2445 (FUNCTION_DECL), a nested type (RECORD_TYPE, ENUM_TYPE),
2446 a typedef (TYPE_DECL) or a member class template (TEMPLATE_DECL)
2447 When FRIEND_P is nonzero, T is either a friend class
2448 (RECORD_TYPE, TEMPLATE_DECL) or a friend function
2449 (FUNCTION_DECL, TEMPLATE_DECL). */
2451 void
2453 {
2454 /* Save some memory by not creating TREE_LIST if TYPE is not template. */
2459 }
2461 /* Create default constructors, assignment operators, and so forth for
2462 the type indicated by T, if they are needed.
2463 CANT_HAVE_DEFAULT_CTOR, CANT_HAVE_CONST_CTOR, and
2464 CANT_HAVE_CONST_ASSIGNMENT are nonzero if, for whatever reason, the
2465 class cannot have a default constructor, copy constructor taking a
2466 const reference argument, or an assignment operator taking a const
2467 reference, respectively. If a virtual destructor is created, its
2468 DECL is returned; otherwise the return value is NULL_TREE. */
2470 static void
2475 {
2476 tree default_fn;
2481 /* Destructor. */
2483 {
2487 /* If we couldn't make it work, then pretend we didn't need it. */
2490 else
2491 {
2497 }
2498 }
2499 else
2500 /* Any non-implicit destructor is non-trivial. */
2503 /* Default constructor. */
2505 {
2508 }
2510 /* Copy constructor. */
2512 {
2517 }
2519 /* If there is no assignment operator, one will be created if and
2520 when it is needed. For now, just record whether or not the type
2521 of the parameter to the assignment operator will be a const or
2522 non-const reference. */
2524 {
2528 }
2530 /* Now, hook all of the new functions on to TYPE_METHODS,
2531 and add them to the CLASSTYPE_METHOD_VEC. */
2533 {
2536 }
2538 /* G++ 3.2 put the implicit destructor at the *beginning* of the
2539 list, which cause the destructor to be emitted in an incorrect
2540 location in the vtable. */
2542 else
2543 {
2546 "and may change in a future version of GCC due to implicit "
2548 t);
2551 }
2552 }
2554 /* Subroutine of finish_struct_1. Recursively count the number of fields
2555 in TYPE, including anonymous union members. */
2557 static int
2559 {
2560 tree x;
2563 {
2566 else
2568 }
2570 }
2572 /* Subroutine of finish_struct_1. Recursively add all the fields in the
2573 TREE_LIST FIELDS to the SORTED_FIELDS_TYPE elts, starting at offset IDX. */
2575 static int
2577 {
2578 tree x;
2580 {
2583 else
2585 }
2587 }
2589 /* FIELD is a bit-field. We are finishing the processing for its
2590 enclosing type. Issue any appropriate messages and set appropriate
2591 flags. */
2593 static void
2595 {
2599 /* Detect invalid bit-field type. */
2602 {
2605 }
2607 /* Detect and ignore out of range field width. */
2609 {
2612 /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs. */
2615 /* detect invalid field size. */
2618 else
2622 {
2624 field);
2626 }
2628 {
2631 }
2633 {
2636 }
2646 min_precision
2651 }
2653 /* Remove the bit-field width indicator so that the rest of the
2654 compiler does not treat that value as an initializer. */
2658 {
2661 }
2662 else
2663 {
2664 /* Non-bit-fields are aligned for their type. */
2667 }
2668 }
2670 /* FIELD is a non bit-field. We are finishing the processing for its
2671 enclosing type T. Issue any appropriate messages and set appropriate
2672 flags. */
2674 static void
2676 tree t,
2681 {
2684 /* An anonymous union cannot contain any fields which would change
2685 the settings of CANT_HAVE_CONST_CTOR and friends. */
2687 ;
2688 /* And, we don't set TYPE_HAS_CONST_INIT_REF, etc., for anonymous
2689 structs. So, we recurse through their fields here. */
2691 {
2692 tree fields;
2698 any_default_members);
2699 }
2700 /* Check members with class type for constructors, destructors,
2701 etc. */
2703 {
2704 /* Never let anything with uninheritable virtuals
2705 make it through without complaint. */
2709 {
2712 field);
2715 field);
2718 field);
2719 }
2720 else
2721 {
2727 }
2738 }
2740 {
2741 /* `build_class_init_list' does not recognize
2742 non-FIELD_DECLs. */
2746 }
2747 }
2749 /* Check the data members (both static and non-static), class-scoped
2750 typedefs, etc., appearing in the declaration of T. Issue
2751 appropriate diagnostics. Sets ACCESS_DECLS to a list (in
2752 declaration order) of access declarations; each TREE_VALUE in this
2753 list is a USING_DECL.
2755 In addition, set the following flags:
2757 EMPTY_P
2758 The class is empty, i.e., contains no non-static data members.
2760 CANT_HAVE_DEFAULT_CTOR_P
2761 This class cannot have an implicitly generated default
2762 constructor.
2764 CANT_HAVE_CONST_CTOR_P
2765 This class cannot have an implicitly generated copy constructor
2766 taking a const reference.
2768 CANT_HAVE_CONST_ASN_REF
2769 This class cannot have an implicitly generated assignment
2770 operator taking a const reference.
2772 All of these flags should be initialized before calling this
2773 function.
2775 Returns a pointer to the end of the TYPE_FIELDs chain; additional
2776 fields can be added by adding to this chain. */
2778 static void
2783 {
2789 /* Assume there are no access declarations. */
2791 /* Assume this class has no pointer members. */
2793 /* Assume none of the members of this class have default
2794 initializations. */
2798 {
2805 {
2807 {
2809 cp_warning_at
2811 x);
2812 else
2814 }
2817 /* We don't treat zero-width bitfields as making a class
2818 non-empty. */
2819 ;
2820 else
2821 {
2822 tree element_type;
2824 /* The class is non-empty. */
2826 /* The class is not even nearly empty. */
2828 /* If one of the data members contains an empty class,
2829 so does T. */
2834 }
2835 }
2838 {
2839 /* Prune the access declaration from the list of fields. */
2842 /* Save the access declarations for our caller. */
2845 /* Since we've reset *FIELD there's no reason to skip to the
2846 next field. */
2849 }
2855 /* If we've gotten this far, it's a data member, possibly static,
2856 or an enumerator. */
2859 /* When this goes into scope, it will be a non-local reference. */
2863 {
2864 /* [class.union]
2866 If a union contains a static data member, or a member of
2867 reference type, the program is ill-formed. */
2869 {
2872 }
2874 {
2879 }
2880 }
2882 /* ``A local class cannot have static data members.'' ARM 9.4 */
2886 /* Perform error checking that did not get done in
2887 grokdeclarator. */
2889 {
2893 }
2895 {
2899 }
2907 /* Now it can only be a FIELD_DECL. */
2912 /* If this is of reference type, check if it needs an init.
2913 Also do a little ANSI jig if necessary. */
2915 {
2920 /* ARM $12.6.2: [A member initializer list] (or, for an
2921 aggregate, initialization by a brace-enclosed list) is the
2922 only way to initialize nonstatic const and reference
2923 members. */
2930 }
2934 /* This is used by -Weffc++ (see below). Warn only for pointers
2935 to members which might hold dynamic memory. So do not warn
2936 for pointers to functions or pointers to members. */
2943 {
2948 }
2954 /* DR 148 now allows pointers to members (which are POD themselves),
2955 to be allowed in POD structs. */
2961 /* If any field is const, the structure type is pseudo-const. */
2963 {
2968 /* ARM $12.6.2: [A member initializer list] (or, for an
2969 aggregate, initialization by a brace-enclosed list) is the
2970 only way to initialize nonstatic const and reference
2971 members. */
2978 }
2979 /* A field that is pseudo-const makes the structure likewise. */
2981 {
2986 }
2988 /* Core issue 80: A nonstatic data member is required to have a
2989 different name from the class iff the class has a
2990 user-defined constructor. */
2994 /* We set DECL_C_BIT_FIELD in grokbitfield.
2995 If the type and width are valid, we'll also set DECL_BIT_FIELD. */
2998 else
3000 cant_have_const_ctor_p,
3001 cant_have_default_ctor_p,
3002 no_const_asn_ref_p,
3004 }
3006 /* Effective C++ rule 11: if a class has dynamic memory held by pointers,
3007 it should also define a copy constructor and an assignment operator to
3008 implement the correct copy semantic (deep vs shallow, etc.). As it is
3009 not feasible to check whether the constructors do allocate dynamic memory
3010 and store it within members, we approximate the warning like this:
3012 -- Warn only if there are members which are pointers
3013 -- Warn only if there is a non-trivial constructor (otherwise,
3014 there cannot be memory allocated).
3015 -- Warn only if there is a non-trivial destructor. We assume that the
3016 user at least implemented the cleanup correctly, and a destructor
3017 is needed to free dynamic memory.
3019 This seems enough for practical purposes. */
3021 && has_pointers
3025 {
3029 {
3033 }
3036 }
3039 /* Check anonymous struct/anonymous union fields. */
3042 /* We've built up the list of access declarations in reverse order.
3043 Fix that now. */
3045 }
3047 /* If TYPE is an empty class type, records its OFFSET in the table of
3048 OFFSETS. */
3050 static int
3052 {
3053 splay_tree_node n;
3058 /* Record the location of this empty object in OFFSETS. */
3066 type,
3070 }
3072 /* Returns nonzero if TYPE is an empty class type and there is
3073 already an entry in OFFSETS for the same TYPE as the same OFFSET. */
3075 static int
3077 {
3078 splay_tree_node n;
3079 tree t;
3084 /* Record the location of this empty object in OFFSETS. */
3094 }
3096 /* Walk through all the subobjects of TYPE (located at OFFSET). Call
3097 F for every subobject, passing it the type, offset, and table of
3098 OFFSETS. If VBASES_P is one, then virtual non-primary bases should
3099 be traversed.
3101 If MAX_OFFSET is non-NULL, then subobjects with an offset greater
3102 than MAX_OFFSET will not be walked.
3104 If F returns a nonzero value, the traversal ceases, and that value
3105 is returned. Otherwise, returns zero. */
3107 static int
3109 subobject_offset_fn f,
3110 tree offset,
3111 splay_tree offsets,
3112 tree max_offset,
3114 {
3118 /* If this OFFSET is bigger than the MAX_OFFSET, then we should
3119 stop. */
3124 {
3128 }
3131 {
3132 tree field;
3133 tree binfo;
3136 /* Avoid recursing into objects that are not interesting. */
3140 /* Record the location of TYPE. */
3145 /* Iterate through the direct base classes of TYPE. */
3149 {
3150 tree binfo_offset;
3163 offset,
3165 else
3166 {
3167 tree orig_binfo;
3168 /* We cannot rely on BINFO_OFFSET being set for the base
3169 class yet, but the offsets for direct non-virtual
3170 bases can be calculated by going back to the TYPE. */
3173 offset,
3175 }
3178 f,
3179 binfo_offset,
3180 offsets,
3181 max_offset,
3186 }
3189 {
3193 /* Iterate through the virtual base classes of TYPE. In G++
3194 3.2, we included virtual bases in the direct base class
3195 loop above, which results in incorrect results; the
3196 correct offsets for virtual bases are only known when
3197 working with the most derived type. */
3201 {
3203 f,
3205 offset,
3207 offsets,
3208 max_offset,
3212 }
3213 else
3214 {
3215 /* We still have to walk the primary base, if it is
3216 virtual. (If it is non-virtual, then it was walked
3217 above.) */
3223 {
3224 r = (walk_subobject_offsets
3229 }
3230 }
3231 }
3233 /* Iterate through the fields of TYPE. */
3236 {
3237 tree field_offset;
3241 else
3242 /* In G++ 3.2, DECL_FIELD_OFFSET was used. */
3246 f,
3248 offset,
3249 field_offset),
3250 offsets,
3251 max_offset,
3255 }
3256 }
3258 {
3261 tree index;
3263 /* Avoid recursing into objects that are not interesting. */
3268 /* Step through each of the elements in the array. */
3270 /* G++ 3.2 had an off-by-one error here. */
3275 {
3277 f,
3278 offset,
3279 offsets,
3280 max_offset,
3286 /* If this new OFFSET is bigger than the MAX_OFFSET, then
3287 there's no point in iterating through the remaining
3288 elements of the array. */
3291 }
3292 }
3295 }
3297 /* Record all of the empty subobjects of TYPE (located at OFFSET) in
3298 OFFSETS. If VBASES_P is nonzero, virtual bases of TYPE are
3299 examined. */
3301 static void
3303 tree offset,
3304 splay_tree offsets,
3306 {
3309 }
3311 /* Returns nonzero if any of the empty subobjects of TYPE (located at
3312 OFFSET) conflict with entries in OFFSETS. If VBASES_P is nonzero,
3313 virtual bases of TYPE are examined. */
3315 static int
3317 tree offset,
3318 splay_tree offsets,
3320 {
3321 splay_tree_node max_node;
3323 /* Get the node in OFFSETS that indicates the maximum offset where
3324 an empty subobject is located. */
3326 /* If there aren't any empty subobjects, then there's no point in
3327 performing this check. */
3333 vbases_p);
3334 }
3336 /* DECL is a FIELD_DECL corresponding either to a base subobject of a
3337 non-static data member of the type indicated by RLI. BINFO is the
3338 binfo corresponding to the base subobject, OFFSETS maps offsets to
3339 types already located at those offsets. This function determines
3340 the position of the DECL. */
3342 static void
3344 tree decl,
3345 tree binfo,
3346 splay_tree offsets)
3347 {
3350 tree type;
3353 {
3354 /* For the purposes of determining layout conflicts, we want to
3355 use the class type of BINFO; TREE_TYPE (DECL) will be the
3356 CLASSTYPE_AS_BASE version, which does not contain entries for
3357 zero-sized bases. */
3360 }
3361 else
3362 {
3365 }
3367 /* Try to place the field. It may take more than one try if we have
3368 a hard time placing the field without putting two objects of the
3369 same type at the same address. */
3371 {
3374 /* Place this field. */
3378 /* We have to check to see whether or not there is already
3379 something of the same type at the offset we're about to use.
3380 For example, consider:
3382 struct S {};
3383 struct T : public S { int i; };
3384 struct U : public S, public T {};
3386 Here, we put S at offset zero in U. Then, we can't put T at
3387 offset zero -- its S component would be at the same address
3388 as the S we already allocated. So, we have to skip ahead.
3389 Since all data members, including those whose type is an
3390 empty class, have nonzero size, any overlap can happen only
3391 with a direct or indirect base-class -- it can't happen with
3392 a data member. */
3393 /* In a union, overlap is permitted; all members are placed at
3394 offset zero. */
3397 /* G++ 3.2 did not check for overlaps when placing a non-empty
3398 virtual base. */
3403 {
3404 /* Strip off the size allocated to this field. That puts us
3405 at the first place we could have put the field with
3406 proper alignment. */
3409 /* Bump up by the alignment required for the type. */
3410 rli->bitpos
3416 }
3417 else
3418 /* There was no conflict. We're done laying out this field. */
3420 }
3422 /* Now that we know where it will be placed, update its
3423 BINFO_OFFSET. */
3425 /* Indirect virtual bases may have a nonzero BINFO_OFFSET at
3426 this point because their BINFO_OFFSET is copied from another
3427 hierarchy. Therefore, we may not need to add the entire
3428 OFFSET. */
3433 }
3435 /* Returns true if TYPE is empty and OFFSET is nonzero. */
3437 static int
3439 tree offset,
3440 splay_tree offsets ATTRIBUTE_UNUSED)
3441 {
3443 }
3445 /* Layout the empty base BINFO. EOC indicates the byte currently just
3446 past the end of the class, and should be correctly aligned for a
3447 class of the type indicated by BINFO; OFFSETS gives the offsets of
3448 the empty bases allocated so far. T is the most derived
3449 type. Return nonzero iff we added it at the end. */
3451 static bool
3453 {
3454 tree alignment;
3458 /* This routine should only be used for empty classes. */
3463 {
3465 propagate_binfo_offsets
3471 }
3473 /* This is an empty base class. We first try to put it at offset
3474 zero. */
3477 offsets,
3479 {
3480 /* That didn't work. Now, we move forward from the next
3481 available spot in the class. */
3485 {
3488 offsets,
3490 /* We finally found a spot where there's no overlap. */
3493 /* There's overlap here, too. Bump along to the next spot. */
3495 }
3496 }
3498 }
3500 /* Layout the the base given by BINFO in the class indicated by RLI.
3501 *BASE_ALIGN is a running maximum of the alignments of
3502 any base class. OFFSETS gives the location of empty base
3503 subobjects. T is the most derived type. Return nonzero if the new
3504 object cannot be nearly-empty. A new FIELD_DECL is inserted at
3505 *NEXT_FIELD, unless BINFO is for an empty base class.
3507 Returns the location at which the next field should be inserted. */
3512 {
3517 /* This error is now reported in xref_tag, thus giving better
3518 location information. */
3521 /* Place the base class. */
3523 {
3524 tree decl;
3526 /* The containing class is non-empty because it has a non-empty
3527 base class. */
3530 /* Create the FIELD_DECL. */
3542 /* Try to place the field. It may take more than one try if we
3543 have a hard time placing the field without putting two
3544 objects of the same type at the same address. */
3546 /* Add the new FIELD_DECL to the list of fields for T. */
3550 }
3551 else
3552 {
3553 tree eoc;
3556 /* On some platforms (ARM), even empty classes will not be
3557 byte-aligned. */
3561 /* A nearly-empty class "has no proper base class that is empty,
3562 not morally virtual, and at an offset other than zero." */
3564 {
3567 /* The check above (used in G++ 3.2) is insufficient because
3568 an empty class placed at offset zero might itself have an
3569 empty base at a nonzero offset. */
3571 empty_base_at_nonzero_offset_p,
3572 size_zero_node,
3576 {
3582 }
3583 }
3585 /* We do not create a FIELD_DECL for empty base classes because
3586 it might overlap some other field. We want to be able to
3587 create CONSTRUCTORs for the class by iterating over the
3588 FIELD_DECLs, and the back end does not handle overlapping
3589 FIELD_DECLs. */
3591 /* An empty virtual base causes a class to be non-empty
3592 -- but in that case we do not need to clear CLASSTYPE_EMPTY_P
3593 here because that was already done when the virtual table
3594 pointer was created. */
3595 }
3597 /* Record the offsets of BINFO and its base subobjects. */
3600 offsets,
3604 }
3606 /* Layout all of the non-virtual base classes. Record empty
3607 subobjects in OFFSETS. T is the most derived type. Return nonzero
3608 if the type cannot be nearly empty. The fields created
3609 corresponding to the base classes will be inserted at
3610 *NEXT_FIELD. */
3612 static void
3615 {
3616 /* Chain to hold all the new FIELD_DECLs which stand in for base class
3617 subobjects. */
3622 /* The primary base class is always allocated first. */
3627 /* Now allocate the rest of the bases. */
3629 {
3630 tree base_binfo;
3634 /* The primary base was already allocated above, so we don't
3635 need to allocate it again here. */
3639 /* Virtual bases are added at the end (a primary virtual base
3640 will have already been added). */
3646 }
3647 }
3649 /* Go through the TYPE_METHODS of T issuing any appropriate
3650 diagnostics, figuring out which methods override which other
3651 methods, and so forth. */
3653 static void
3655 {
3656 tree x;
3659 {
3663 /* The name of the field is the original field name
3664 Save this in auxiliary field for later overloading. */
3666 {
3670 }
3671 }
3672 }
3674 /* FN is a constructor or destructor. Clone the declaration to create
3675 a specialized in-charge or not-in-charge version, as indicated by
3676 NAME. */
3678 static tree
3680 {
3681 tree parms;
3682 tree clone;
3684 /* Copy the function. */
3686 /* Remember where this function came from. */
3689 /* Reset the function name. */
3692 /* There's no pending inline data for this function. */
3695 /* And it hasn't yet been deferred. */
3698 /* The base-class destructor is not virtual. */
3700 {
3704 }
3706 /* If there was an in-charge parameter, drop it from the function
3707 type. */
3709 {
3710 tree basetype;
3711 tree parmtypes;
3712 tree exceptions;
3717 /* Skip the `this' parameter. */
3719 /* Skip the in-charge parameter. */
3721 /* And the VTT parm, in a complete [cd]tor. */
3725 /* If this is subobject constructor or destructor, add the vtt
3726 parameter. */
3730 parmtypes);
3733 exceptions);
3737 }
3739 /* Copy the function parameters. But, DECL_ARGUMENTS on a TEMPLATE_DECL
3740 aren't function parameters; those are the template parameters. */
3742 {
3744 /* Remove the in-charge parameter. */
3746 {
3750 }
3751 /* And the VTT parm, in a complete [cd]tor. */
3753 {
3756 else
3757 {
3761 }
3762 }
3765 {
3768 }
3769 }
3771 /* Create the RTL for this function. */
3775 /* Make it easy to find the CLONE given the FN. */
3779 /* If this is a template, handle the DECL_TEMPLATE_RESULT as well. */
3781 {
3782 tree result;
3789 }
3792 }
3794 /* Produce declarations for all appropriate clones of FN. If
3795 UPDATE_METHOD_VEC_P is nonzero, the clones are added to the
3796 CLASTYPE_METHOD_VEC as well. */
3798 void
3800 {
3801 tree clone;
3803 /* Avoid inappropriate cloning. */
3809 {
3810 /* For each constructor, we need two variants: an in-charge version
3811 and a not-in-charge version. */
3818 }
3819 else
3820 {
3823 /* For each destructor, we need three variants: an in-charge
3824 version, a not-in-charge version, and an in-charge deleting
3825 version. We clone the deleting version first because that
3826 means it will go second on the TYPE_METHODS list -- and that
3827 corresponds to the correct layout order in the virtual
3828 function table.
3830 For a non-virtual destructor, we do not build a deleting
3831 destructor. */
3833 {
3837 }
3844 }
3846 /* Note that this is an abstract function that is never emitted. */
3848 }
3850 /* DECL is an in charge constructor, which is being defined. This will
3851 have had an in class declaration, from whence clones were
3852 declared. An out-of-class definition can specify additional default
3853 arguments. As it is the clones that are involved in overload
3854 resolution, we must propagate the information from the DECL to its
3855 clones. */
3857 void
3859 {
3860 tree clone;
3864 {
3871 /* Skip the 'this' parameter. */
3887 {
3892 {
3893 /* A default parameter has been added. Adjust the
3894 clone's parameters. */
3897 tree type;
3902 {
3905 clone_parms);
3907 }
3910 clone_parms);
3917 }
3918 }
3920 }
3921 }
3923 /* For each of the constructors and destructors in T, create an
3924 in-charge and not-in-charge variant. */
3926 static void
3928 {
3929 tree fns;
3931 /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail
3932 out now. */
3940 }
3942 /* Remove all zero-width bit-fields from T. */
3944 static void
3946 {
3951 {
3956 else
3958 }
3959 }
3961 /* Returns TRUE iff we need a cookie when dynamically allocating an
3962 array whose elements have the indicated class TYPE. */
3964 static bool
3966 {
3967 tree fns;
3972 /* If there's a non-trivial destructor, we need a cookie. In order
3973 to iterate through the array calling the destructor for each
3974 element, we'll have to know how many elements there are. */
3978 /* If the usual deallocation function is a two-argument whose second
3979 argument is of type `size_t', then we have to pass the size of
3980 the array to the deallocation function, so we will need to store
3981 a cookie. */
3985 /* If there are no `operator []' members, or the lookup is
3986 ambiguous, then we don't need a cookie. */
3989 /* Loop through all of the functions. */
3991 {
3992 tree fn;
3993 tree second_parm;
3995 /* Select the current function. */
3997 /* See if this function is a one-argument delete function. If
3998 it is, then it will be the usual deallocation function. */
4002 /* Otherwise, if we have a two-argument function and the second
4003 argument is `size_t', it will be the usual deallocation
4004 function -- unless there is one-argument function, too. */
4008 }
4011 }
4013 /* Check the validity of the bases and members declared in T. Add any
4014 implicitly-generated functions (like copy-constructors and
4015 assignment operators). Compute various flag bits (like
4016 CLASSTYPE_NON_POD_T) for T. This routine works purely at the C++
4017 level: i.e., independently of the ABI in use. */
4019 static void
4021 {
4022 /* Nonzero if we are not allowed to generate a default constructor
4023 for this case. */
4025 /* Nonzero if the implicitly generated copy constructor should take
4026 a non-const reference argument. */
4028 /* Nonzero if the the implicitly generated assignment operator
4029 should take a non-const reference argument. */
4031 tree access_decls;
4033 /* By default, we use const reference arguments and generate default
4034 constructors. */
4039 /* Check all the base-classes. */
4043 /* Check all the data member declarations. */
4049 /* Check all the method declarations. */
4052 /* A nearly-empty class has to be vptr-containing; a nearly empty
4053 class contains just a vptr. */
4057 /* Do some bookkeeping that will guide the generation of implicitly
4058 declared member functions. */
4071 /* Synthesize any needed methods. */
4073 cant_have_const_ctor,
4074 no_const_asn_ref);
4076 /* Create the in-charge and not-in-charge variants of constructors
4077 and destructors. */
4080 /* Process the using-declarations. */
4084 /* Build and sort the CLASSTYPE_METHOD_VEC. */
4087 /* Figure out whether or not we will need a cookie when dynamically
4088 allocating an array of this type. */
4091 }
4093 /* If T needs a pointer to its virtual function table, set TYPE_VFIELD
4094 accordingly. If a new vfield was created (because T doesn't have a
4095 primary base class), then the newly created field is returned. It
4096 is not added to the TYPE_FIELDS list; it is the caller's
4097 responsibility to do that. Accumulate declared virtual functions
4098 on VIRTUALS_P. */
4100 static tree
4102 {
4103 tree fn;
4105 /* Collect the virtual functions declared in T. */
4109 {
4118 }
4120 /* If we couldn't find an appropriate base class, create a new field
4121 here. Even if there weren't any new virtual functions, we might need a
4122 new virtual function table if we're supposed to include vptrs in
4123 all classes that need them. */
4125 {
4126 /* We build this decl with vtbl_ptr_type_node, which is a
4127 `vtable_entry_type*'. It might seem more precise to use
4128 `vtable_entry_type (*)[N]' where N is the number of virtual
4129 functions. However, that would require the vtable pointer in
4130 base classes to have a different type than the vtable pointer
4131 in derived classes. We could make that happen, but that
4132 still wouldn't solve all the problems. In particular, the
4133 type-based alias analysis code would decide that assignments
4134 to the base class vtable pointer can't alias assignments to
4135 the derived class vtable pointer, since they have different
4136 types. Thus, in a derived class destructor, where the base
4137 class constructor was inlined, we could generate bad code for
4138 setting up the vtable pointer.
4140 Therefore, we use one type for all vtable pointers. We still
4141 use a type-correct type; it's just doesn't indicate the array
4142 bounds. That's better than using `void*' or some such; it's
4143 cleaner, and it let's the alias analysis code know that these
4144 stores cannot alias stores to void*! */
4145 tree field;
4156 /* This class is non-empty. */
4160 }
4163 }
4165 /* Fixup the inline function given by INFO now that the class is
4166 complete. */
4168 static void
4170 {
4172 {
4175 {
4178 }
4179 }
4180 }
4182 /* Fixup the inline methods and friends in TYPE now that TYPE is
4183 complete. */
4185 static void
4187 {
4193 {
4198 else
4200 }
4202 /* Do inline member functions. */
4206 /* Do friends. */
4211 }
4213 /* Add OFFSET to all base types of BINFO which is a base in the
4214 hierarchy dominated by T.
4216 OFFSET, which is a type offset, is number of bytes. */
4218 static void
4220 {
4222 tree primary_binfo;
4223 tree base_binfo;
4225 /* Update BINFO's offset. */
4230 offset));
4232 /* Find the primary base class. */
4238 /* Scan all of the bases, pushing the BINFO_OFFSET adjust
4239 downwards. */
4241 {
4242 /* Don't do the primary base twice. */
4250 }
4251 }
4253 /* Set BINFO_OFFSET for all of the virtual bases for RLI->T. Update
4254 TYPE_ALIGN and TYPE_SIZE for T. OFFSETS gives the location of
4255 empty subobjects of T. */
4257 static void
4259 {
4260 tree vbase;
4269 {
4270 /* In G++ 3.2, we incorrectly rounded the size before laying out
4271 the virtual bases. */
4273 #ifdef STRUCTURE_SIZE_BOUNDARY
4274 /* Packed structures don't need to have minimum size. */
4277 #endif
4281 }
4283 /* Find the last field. The artificial fields created for virtual
4284 bases will go after the last extant field to date. */
4289 /* Go through the virtual bases, allocating space for each virtual
4290 base that is not already a primary base class. These are
4291 allocated in inheritance graph order. */
4293 {
4298 {
4301 /* This virtual base is not a primary base of any class in the
4302 hierarchy, so we have to add space for it. */
4306 /* If the first virtual base might have been placed at a
4307 lower address, had we started from CLASSTYPE_SIZE, rather
4308 than TYPE_SIZE, issue a warning. There can be both false
4309 positives and false negatives from this warning in rare
4310 cases; to deal with all the possibilities would probably
4311 require performing both layout algorithms and comparing
4312 the results which is not particularly tractable. */
4314 && first_vbase
4315 && (tree_int_cst_lt
4319 bitsize_unit_node),
4323 basetype);
4326 }
4327 }
4328 }
4330 /* Returns the offset of the byte just past the end of the base class
4331 BINFO. */
4333 static tree
4335 {
4336 tree size;
4339 /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to
4340 allocate some space for it. It cannot have virtual bases, so
4341 TYPE_SIZE_UNIT is fine. */
4343 else
4347 }
4349 /* Returns the offset of the byte just past the end of the base class
4350 with the highest offset in T. If INCLUDE_VIRTUALS_P is zero, then
4351 only non-virtual bases are included. */
4353 static tree
4355 {
4358 tree binfo;
4359 tree base_binfo;
4360 tree offset;
4365 {
4375 }
4377 /* G++ 3.2 did not check indirect virtual bases. */
4381 {
4385 }
4388 }
4390 /* Warn about bases of T that are inaccessible because they are
4391 ambiguous. For example:
4393 struct S {};
4394 struct T : public S {};
4395 struct U : public S, public T {};
4397 Here, `(S*) new U' is not allowed because there are two `S'
4398 subobjects of U. */
4400 static void
4402 {
4405 tree basetype;
4406 tree binfo;
4407 tree base_binfo;
4409 /* If there are no repeated bases, nothing can be ambiguous. */
4413 /* Check direct bases. */
4416 {
4422 }
4424 /* Check for ambiguous virtual bases. */
4428 {
4434 }
4435 }
4437 /* Compare two INTEGER_CSTs K1 and K2. */
4439 static int
4441 {
4443 }
4445 /* Increase the size indicated in RLI to account for empty classes
4446 that are "off the end" of the class. */
4448 static void
4450 {
4451 tree eoc;
4452 tree rli_size;
4454 /* It might be the case that we grew the class to allocate a
4455 zero-sized base class. That won't be reflected in RLI, yet,
4456 because we are willing to overlay multiple bases at the same
4457 offset. However, now we need to make sure that RLI is big enough
4458 to reflect the entire class. */
4464 {
4466 /* In version 1 of the ABI, the size of a class that ends with
4467 a bitfield was not rounded up to a whole multiple of a
4468 byte. Because rli_size_unit_so_far returns only the number
4469 of fully allocated bytes, any extra bits were not included
4470 in the size. */
4472 else
4473 /* The size should have been rounded to a whole byte. */
4476 rli->bitpos
4485 }
4486 }
4488 /* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T. Calculate
4489 BINFO_OFFSETs for all of the base-classes. Position the vtable
4490 pointer. Accumulate declared virtual functions on VIRTUALS_P. */
4492 static void
4494 {
4495 tree non_static_data_members;
4496 tree field;
4497 tree vptr;
4498 record_layout_info rli;
4499 /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of
4500 types that appear at that offset. */
4501 splay_tree empty_base_offsets;
4502 /* True if the last field layed out was a bit-field. */
4504 /* The location at which the next field should be inserted. */
4506 /* T, as a base class. */
4507 tree base_t;
4509 /* Keep track of the first non-static data member. */
4512 /* Start laying out the record. */
4515 /* Mark all the primary bases in the hierarchy. */
4518 /* Create a pointer to our virtual function table. */
4521 /* The vptr is always the first thing in the class. */
4523 {
4528 }
4529 else
4532 /* Build FIELD_DECLs for all of the non-virtual base-types. */
4537 /* Layout the non-static data members. */
4539 {
4540 tree type;
4541 tree padding;
4543 /* We still pass things that aren't non-static data members to
4544 the back-end, in case it wants to do something with them. */
4546 {
4548 /* If the static data member has incomplete type, keep track
4549 of it so that it can be completed later. (The handling
4550 of pending statics in finish_record_layout is
4551 insufficient; consider:
4553 struct S1;
4554 struct S2 { static S1 s1; };
4556 At this point, finish_record_layout will be called, but
4557 S1 is still incomplete.) */
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);
4694 NULL_TREE,
4695 empty_base_offsets);
4696 }
4699 }
4702 {
4703 /* Make sure that we are on a byte boundary so that the size of
4704 the class without virtual bases will always be a round number
4705 of bytes. */
4708 }
4710 /* G++ 3.2 does not allow virtual bases to be overlaid with tail
4711 padding. */
4715 /* Delete all zero-width bit-fields from the list of fields. Now
4716 that the type is laid out they are no longer important. */
4719 /* Create the version of T used for virtual bases. We do not use
4720 make_aggr_type for this version; this is an artificial type. For
4721 a POD type, we just reuse T. */
4723 {
4726 /* Set the size and alignment for the new type. In G++ 3.2, all
4727 empty classes were considered to have size zero when used as
4728 base classes. */
4730 {
4736 t);
4737 }
4738 else
4739 {
4740 tree eoc;
4742 /* If the ABI version is not at least two, and the last
4743 field was a bit-field, RLI may not be on a byte
4744 boundary. In particular, rli_size_unit_so_far might
4745 indicate the last complete byte, while rli_size_so_far
4746 indicates the total number of bits used. Therefore,
4747 rli_size_so_far, rather than rli_size_unit_so_far, is
4748 used to compute TYPE_SIZE_UNIT. */
4756 eoc);
4763 }
4767 /* Copy the fields from T. */
4771 {
4782 }
4784 /* Record the base version of the type. */
4787 }
4788 else
4791 /* Every empty class contains an empty class. */
4795 /* Set the TYPE_DECL for this type to contain the right
4796 value for DECL_OFFSET, so that we can use it as part
4797 of a COMPONENT_REF for multiple inheritance. */
4800 /* Now fix up any virtual base class types that we left lying
4801 around. We must get these done before we try to lay out the
4802 virtual function table. As a side-effect, this will remove the
4803 base subobject fields. */
4806 /* Make sure that empty classes are reflected in RLI at this
4807 point. */
4810 /* Make sure not to create any structures with zero size. */
4815 /* Let the back-end lay out the type. */
4818 /* Warn about bases that can't be talked about due to ambiguity. */
4821 /* Now that we're done with layout, give the base fields the real types. */
4826 /* Clean up. */
4828 }
4830 /* Determine the "key method" for the class type indicated by TYPE,
4831 and set CLASSTYPE_KEY_METHOD accordingly. */
4833 void
4835 {
4836 tree method;
4839 || processing_template_decl
4844 /* The key method is the first non-pure virtual function that is not
4845 inline at the point of class definition. On some targets the
4846 key function may not be inline; those targets should not call
4847 this function until the end of the translation unit. */
4853 {
4856 }
4859 }
4861 /* Perform processing required when the definition of T (a class type)
4862 is complete. */
4864 void
4866 {
4867 tree x;
4868 /* A TREE_LIST. The TREE_VALUE of each node is a FUNCTION_DECL. */
4873 {
4878 }
4880 /* If this type was previously laid out as a forward reference,
4881 make sure we lay it out again. */
4887 /* Make assumptions about the class; we'll reset the flags if
4888 necessary. */
4893 /* Do end-of-class semantic processing: checking the validity of the
4894 bases and members and add implicitly generated methods. */
4897 /* Find the key method. */
4899 {
4900 /* The Itanium C++ ABI permits the key method to be chosen when
4901 the class is defined -- even though the key method so
4902 selected may later turn out to be an inline function. On
4903 some systems (such as ARM Symbian OS) the key method cannot
4904 be determined until the end of the translation unit. On such
4905 systems, we leave CLASSTYPE_KEY_METHOD set to NULL, which
4906 will cause the class to be added to KEYED_CLASSES. Then, in
4907 finish_file we will determine the key method. */
4911 /* If a polymorphic class has no key method, we may emit the vtable
4912 in every translation unit where the class definition appears. */
4915 }
4917 /* Layout the class itself. */
4920 /* We use the base type for trivial assignments, and hence it
4921 needs a mode. */
4926 /* If necessary, create the primary vtable for this class. */
4928 {
4929 /* We must enter these virtuals into the table. */
4933 /* Here we know enough to change the type of our virtual
4934 function table, but we will wait until later this function. */
4936 }
4939 {
4941 tree fn;
4948 /* Add entries for virtual functions introduced by this class. */
4952 /* Set DECL_VINDEX for all functions declared in this class. */
4954 fn;
4956 vindex += (TARGET_VTABLE_USES_DESCRIPTORS
4958 {
4962 /* A thunk. We should never be calling this entry directly
4963 from this vtable -- we'd use the entry for the non
4964 thunk base function. */
4968 }
4969 }
4973 /* Complete the rtl for any static member objects of the type we're
4974 working on. */
4980 /* Done with FIELDS...now decide whether to sort these for
4981 faster lookups later.
4983 We use a small number because most searches fail (succeeding
4984 ultimately as the search bores through the inheritance
4985 hierarchy), and we want this failure to occur quickly. */
4989 {
4996 field_decl_cmp);
5000 }
5002 /* Make the rtl for any new vtables we have created, and unmark
5003 the base types we marked. */
5006 /* Build the VTT for T. */
5012 {
5015 /* Warn only if the dtor is non-private or the class has friends */
5020 }
5031 /* Finish debugging output for this type. */
5033 }
5035 /* When T was built up, the member declarations were added in reverse
5036 order. Rearrange them to declaration order. */
5038 void
5040 {
5041 tree next;
5042 tree prev;
5043 tree x;
5045 /* The following lists are all in reverse order. Put them in
5046 declaration order now. */
5050 /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
5051 reverse order, so we can't just use nreverse. */
5056 {
5060 }
5062 {
5066 }
5067 }
5069 tree
5071 {
5074 /* Now that we've got all the field declarations, reverse everything
5075 as necessary. */
5080 /* Nadger the current location so that diagnostics point to the start of
5081 the struct, not the end. */
5085 {
5086 tree x;
5091 /* We need to emit an error message if this type was used as a parameter
5092 and it is an abstract type, even if it is a template. We construct
5093 a simple CLASSTYPE_PURE_VIRTUALS list without taking bases into
5094 account and we call complete_vars with this type, which will check
5095 the PARM_DECLS. Note that while the type is being defined,
5096 CLASSTYPE_PURE_VIRTUALS contains the list of the inline friends
5097 (see CLASSTYPE_INLINE_FRIENDS) so we need to clear it. */
5103 }
5104 else
5113 else
5120 }
5121 \f
5122 /* Return the dynamic type of INSTANCE, if known.
5123 Used to determine whether the virtual function table is needed
5124 or not.
5126 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5127 of our knowledge of its type. *NONNULL should be initialized
5128 before this function is called. */
5130 static tree
5132 {
5134 {
5138 else
5143 /* This is a call to a constructor, hence it's never zero. */
5145 {
5149 }
5153 /* This is a call to a constructor, hence it's never zero. */
5155 {
5159 }
5167 /* Propagate nonnull. */
5178 {
5179 /* Just because we see an ADDR_EXPR doesn't mean we're dealing
5180 with a real object -- given &p->f, p can still be null. */
5182 /* ??? Probably should check DECL_WEAK here. */
5185 }
5189 /* If this component is really a base class reference, then the field
5190 itself isn't definitive. */
5199 {
5203 }
5204 /* fall through... */
5209 {
5213 }
5215 {
5219 /* if we're in a ctor or dtor, we know our type. */
5223 {
5227 }
5228 }
5230 {
5231 /* Reference variables should be references to objects. */
5235 /* DECL_VAR_MARKED_P is used to prevent recursion; a
5236 variable's initializer may refer to the variable
5237 itself. */
5241 {
5242 tree type;
5248 }
5249 }
5254 }
5255 }
5257 /* Return nonzero if the dynamic type of INSTANCE is known, and
5258 equivalent to the static type. We also handle the case where
5259 INSTANCE is really a pointer. Return negative if this is a
5260 ctor/dtor. There the dynamic type is known, but this might not be
5261 the most derived base of the original object, and hence virtual
5262 bases may not be layed out according to this type.
5264 Used to determine whether the virtual function table is needed
5265 or not.
5267 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
5268 of our knowledge of its type. *NONNULL should be initialized
5269 before this function is called. */
5271 int
5273 {
5285 }
5287 \f
5288 void
5290 {
5293 current_class_stack
5300 }
5302 /* Restore the cached PREVIOUS_CLASS_LEVEL. */
5304 static void
5306 {
5307 tree type;
5309 /* We are re-entering the same class we just left, so we don't
5310 have to search the whole inheritance matrix to find all the
5311 decls to bind again. Instead, we install the cached
5312 class_shadowed list and walk through it binding names. */
5315 /* Restore IDENTIFIER_TYPE_VALUE. */
5317 type;
5320 }
5322 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
5323 appropriate for TYPE.
5325 So that we may avoid calls to lookup_name, we cache the _TYPE
5326 nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
5328 For multiple inheritance, we perform a two-pass depth-first search
5329 of the type lattice. */
5331 void
5333 {
5336 /* Make sure there is enough room for the new entry on the stack. */
5338 {
5340 current_class_stack
5342 current_class_stack_size
5344 }
5346 /* Insert a new entry on the class stack. */
5351 current_class_depth++;
5353 /* Now set up the new type. */
5359 /* By default, things in classes are private, while things in
5360 structures or unions are public. */
5362 ? access_private_node
5368 {
5369 /* Forcibly remove any old class remnants. */
5371 }
5377 else
5379 }
5381 /* When we exit a toplevel class scope, we save its binding level so
5382 that we can restore it quickly. Here, we've entered some other
5383 class, so we must invalidate our cache. */
5385 void
5387 {
5389 }
5391 /* Get out of the current class scope. If we were in a class scope
5392 previously, that is the one popped to. */
5394 void
5396 {
5399 current_class_depth--;
5405 }
5407 /* Returns 1 if current_class_type is either T or a nested type of T.
5408 We start looking from 1 because entry 0 is from global scope, and has
5409 no type. */
5411 int
5413 {
5422 }
5424 /* If either current_class_type or one of its enclosing classes are derived
5425 from T, return the appropriate type. Used to determine how we found
5426 something via unqualified lookup. */
5428 tree
5430 {
5433 /* The bases of a dependent type are unknown. */
5448 }
5450 /* When entering a class scope, all enclosing class scopes' names with
5451 static meaning (static variables, static functions, types and
5452 enumerators) have to be visible. This recursive function calls
5453 pushclass for all enclosing class contexts until global or a local
5454 scope is reached. TYPE is the enclosed class. */
5456 void
5458 {
5459 tree context;
5461 /* A namespace might be passed in error cases, like A::B:C. */
5475 }
5477 /* Undoes a push_nested_class call. */
5479 void
5481 {
5487 }
5489 /* Returns the number of extern "LANG" blocks we are nested within. */
5491 int
5493 {
5495 }
5497 /* Set global variables CURRENT_LANG_NAME to appropriate value
5498 so that behavior of name-mangling machinery is correct. */
5500 void
5502 {
5506 {
5508 }
5510 {
5512 /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
5513 (See record_builtin_java_type in decl.c.) However, that causes
5514 incorrect debug entries if these types are actually used.
5515 So we re-enable debug output after extern "Java". */
5524 }
5526 {
5528 }
5529 else
5531 }
5533 /* Get out of the current language scope. */
5535 void
5537 {
5540 }
5541 \f
5542 /* Type instantiation routines. */
5544 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
5545 matches the TARGET_TYPE. If there is no satisfactory match, return
5546 error_mark_node, and issue a error & warning messages under control
5547 of FLAGS. Permit pointers to member function if FLAGS permits. If
5548 TEMPLATE_ONLY, the name of the overloaded function was a
5549 template-id, and EXPLICIT_TARGS are the explicitly provided
5550 template arguments. */
5552 static tree
5554 tree overload,
5555 tsubst_flags_t flags,
5557 tree explicit_targs)
5558 {
5559 /* Here's what the standard says:
5561 [over.over]
5563 If the name is a function template, template argument deduction
5564 is done, and if the argument deduction succeeds, the deduced
5565 arguments are used to generate a single template function, which
5566 is added to the set of overloaded functions considered.
5568 Non-member functions and static member functions match targets of
5569 type "pointer-to-function" or "reference-to-function." Nonstatic
5570 member functions match targets of type "pointer-to-member
5571 function;" the function type of the pointer to member is used to
5572 select the member function from the set of overloaded member
5573 functions. If a nonstatic member function is selected, the
5574 reference to the overloaded function name is required to have the
5575 form of a pointer to member as described in 5.3.1.
5577 If more than one function is selected, any template functions in
5578 the set are eliminated if the set also contains a non-template
5579 function, and any given template function is eliminated if the
5580 set contains a second template function that is more specialized
5581 than the first according to the partial ordering rules 14.5.5.2.
5582 After such eliminations, if any, there shall remain exactly one
5583 selected function. */
5587 /* We store the matches in a TREE_LIST rooted here. The functions
5588 are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
5589 interoperability with most_specialized_instantiation. */
5591 tree fn;
5593 /* By the time we get here, we should be seeing only real
5594 pointer-to-member types, not the internal POINTER_TYPE to
5595 METHOD_TYPE representation. */
5601 /* Check that the TARGET_TYPE is reasonable. */
5605 /* This is OK, too. */
5608 {
5609 /* This is OK, too. This comes from a conversion to reference
5610 type. */
5613 }
5614 else
5615 {
5621 }
5623 /* If we can find a non-template function that matches, we can just
5624 use it. There's no point in generating template instantiations
5625 if we're just going to throw them out anyhow. But, of course, we
5626 can only do this when we don't *need* a template function. */
5628 {
5629 tree fns;
5632 {
5634 tree fntype;
5637 /* We're not looking for templates just yet. */
5642 /* We're looking for a non-static member, and this isn't
5643 one, or vice versa. */
5646 /* Ignore anticipated decls of undeclared builtins. */
5650 /* See if there's a match. */
5659 }
5660 }
5662 /* Now, if we've already got a match (or matches), there's no need
5663 to proceed to the template functions. But, if we don't have a
5664 match we need to look at them, too. */
5666 {
5667 tree target_fn_type;
5668 tree target_arg_types;
5669 tree target_ret_type;
5670 tree fns;
5673 target_fn_type
5675 else
5680 /* Never do unification on the 'this' parameter. */
5685 {
5687 tree instantiation;
5688 tree instantiation_type;
5689 tree targs;
5692 /* We're only looking for templates. */
5697 /* We're not looking for a non-static member, and this is
5698 one, or vice versa. */
5701 /* Try to do argument deduction. */
5706 /* Argument deduction failed. */
5709 /* Instantiate the template. */
5712 /* Instantiation failed. */
5715 /* See if there's a match. */
5718 instantiation_type =
5724 }
5726 /* Now, remove all but the most specialized of the matches. */
5728 {
5733 }
5734 }
5736 /* Now we should have exactly one function in MATCHES. */
5738 {
5739 /* There were *no* matches. */
5741 {
5744 target_type);
5746 /* print_candidates expects a chain with the functions in
5747 TREE_VALUE slots, so we cons one up here (we're losing anyway,
5748 so why be clever?). */
5751 matches);
5754 }
5756 }
5758 {
5759 /* There were too many matches. */
5762 {
5763 tree match;
5767 target_type);
5769 /* Since print_candidates expects the functions in the
5770 TREE_VALUE slot, we flip them here. */
5775 }
5778 }
5780 /* Good, exactly one match. Now, convert it to the correct type. */
5785 {
5793 {
5796 }
5797 }
5799 /* If we're doing overload resolution purely for the purpose of
5800 determining conversion sequences, we should not consider the
5801 function used. If this conversion sequence is selected, the
5802 function will be marked as used at this point. */
5808 else
5809 {
5810 /* The target must be a REFERENCE_TYPE. Above, build_unary_op
5811 will mark the function as addressed, but here we must do it
5812 explicitly. */
5816 }
5817 }
5819 /* This function will instantiate the type of the expression given in
5820 RHS to match the type of LHSTYPE. If errors exist, then return
5821 error_mark_node. FLAGS is a bit mask. If TF_ERROR is set, then
5822 we complain on errors. If we are not complaining, never modify rhs,
5823 as overload resolution wants to try many possible instantiations, in
5824 the hope that at least one will work.
5826 For non-recursive calls, LHSTYPE should be a function, pointer to
5827 function, or a pointer to member function. */
5829 tree
5831 {
5837 {
5841 }
5844 {
5850 /* Microsoft allows `A::f' to be resolved to a
5851 pointer-to-member. */
5852 ;
5853 else
5854 {
5859 }
5860 }
5865 /* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot
5866 deduce any type information. */
5868 {
5872 }
5874 /* We don't overwrite rhs if it is an overloaded function.
5875 Copying it would destroy the tree link. */
5879 /* This should really only be used when attempting to distinguish
5880 what sort of a pointer to function we have. For now, any
5881 arithmetic operation which is not supported on pointers
5882 is rejected as an error. */
5885 {
5894 {
5895 tree new_rhs;
5905 }
5913 {
5919 /* Do not lose object's side effects. */
5923 }
5930 /* This can happen if we are forming a pointer-to-member for a
5931 member template. */
5934 /* Fall through. */
5937 {
5941 return
5944 args);
5945 }
5949 return
5955 /* This is too hard for now. */
6027 {
6031 }
6054 {
6059 }
6066 }
6068 }
6069 \f
6070 /* Return the name of the virtual function pointer field
6071 (as an IDENTIFIER_NODE) for the given TYPE. Note that
6072 this may have to look back through base types to find the
6073 ultimate field name. (For single inheritance, these could
6074 all be the same name. Who knows for multiple inheritance). */
6076 static tree
6078 {
6085 {
6091 }
6098 }
6100 void
6102 {
6103 #ifdef GATHER_STATISTICS
6107 {
6112 }
6113 #endif
6114 }
6116 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
6117 according to [class]:
6118 The class-name is also inserted
6119 into the scope of the class itself. For purposes of access checking,
6120 the inserted class name is treated as if it were a public member name. */
6122 void
6124 {
6127 tree saved_cas;
6141 }
6143 /* Returns 1 if TYPE contains only padding bytes. */
6145 int
6147 {
6154 /* In G++ 3.2, whether or not a class was empty was determined by
6155 looking at its size. */
6158 else
6160 }
6162 /* Returns true if TYPE contains an empty class. */
6164 static bool
6166 {
6170 {
6171 tree field;
6172 tree binfo;
6173 tree base_binfo;
6185 }
6189 }
6191 /* Find the enclosing class of the given NODE. NODE can be a *_DECL or
6192 a *_TYPE node. NODE can also be a local class. */
6194 tree
6196 {
6200 {
6202 {
6215 }
6216 }
6218 }
6220 /* Note that NAME was looked up while the current class was being
6221 defined and that the result of that lookup was DECL. */
6223 void
6225 {
6226 splay_tree names_used;
6228 /* If we're not defining a class, there's nothing to do. */
6233 /* If there's already a binding for this NAME, then we don't have
6234 anything to worry about. */
6247 }
6249 /* Note that NAME was declared (as DECL) in the current class. Check
6250 to see that the declaration is valid. */
6252 void
6254 {
6255 splay_tree names_used;
6256 splay_tree_node n;
6258 /* Look to see if we ever used this name. */
6259 names_used
6266 {
6267 /* [basic.scope.class]
6269 A name N used in a class S shall refer to the same declaration
6270 in its context and when re-evaluated in the completed scope of
6271 S. */
6276 }
6277 }
6279 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
6280 Secondary vtables are merged with primary vtables; this function
6281 will return the VAR_DECL for the primary vtable. */
6283 tree
6285 {
6286 tree decl;
6290 {
6293 }
6297 }
6300 /* Returns the binfo for the primary base of BINFO. If the resulting
6301 BINFO is a virtual base, and it is inherited elsewhere in the
6302 hierarchy, then the returned binfo might not be the primary base of
6303 BINFO in the complete object. Check BINFO_PRIMARY_P or
6304 BINFO_LOST_PRIMARY_P to be sure. */
6306 tree
6308 {
6309 tree primary_base;
6310 tree result;
6318 }
6320 /* If INDENTED_P is zero, indent to INDENT. Return nonzero. */
6322 static int
6324 {
6328 }
6330 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
6331 INDENT should be zero when called from the top level; it is
6332 incremented recursively. IGO indicates the next expected BINFO in
6333 inheritance graph ordering. */
6335 static tree
6338 tree binfo,
6339 tree igo,
6341 {
6343 tree base_binfo;
6351 {
6354 }
6369 {
6373 TFF_PLAIN_IDENTIFIER),
6375 }
6377 {
6380 }
6385 {
6389 {
6393 TFF_PLAIN_IDENTIFIER));
6394 }
6396 {
6400 TFF_PLAIN_IDENTIFIER));
6401 }
6403 {
6407 TFF_PLAIN_IDENTIFIER));
6408 }
6410 {
6414 TFF_PLAIN_IDENTIFIER));
6415 }
6419 }
6425 }
6427 /* Dump the BINFO hierarchy for T. */
6429 static void
6431 {
6443 }
6445 /* Debug interface to hierarchy dumping. */
6449 {
6451 }
6453 static void
6455 {
6460 {
6463 }
6464 }
6466 static void
6468 {
6469 tree inits;
6471 HOST_WIDE_INT elt;
6479 TFF_PLAIN_IDENTIFIER));
6486 }
6488 static void
6490 {
6498 {
6505 {
6509 }
6513 }
6516 }
6518 static void
6520 {
6528 {
6533 }
6536 }
6538 /* Dump a function or thunk and its thunkees. */
6540 static void
6542 {
6545 tree thunks;
6553 {
6563 else
6569 }
6573 }
6575 /* Dump the thunks for FN. */
6579 {
6581 }
6583 /* Virtual function table initialization. */
6585 /* Create all the necessary vtables for T and its base classes. */
6587 static void
6589 {
6590 tree list;
6591 tree vbase;
6593 /* We lay out the primary and secondary vtables in one contiguous
6594 vtable. The primary vtable is first, followed by the non-virtual
6595 secondary vtables in inheritance graph order. */
6600 /* Then come the virtual bases, also in inheritance graph order. */
6602 {
6606 }
6610 }
6612 /* Initialize the vtable for BINFO with the INITS. */
6614 static void
6616 {
6617 tree decl;
6623 }
6625 /* Build the VTT (virtual table table) for T.
6626 A class requires a VTT if it has virtual bases.
6628 This holds
6629 1 - primary virtual pointer for complete object T
6630 2 - secondary VTTs for each direct non-virtual base of T which requires a
6631 VTT
6632 3 - secondary virtual pointers for each direct or indirect base of T which
6633 has virtual bases or is reachable via a virtual path from T.
6634 4 - secondary VTTs for each direct or indirect virtual base of T.
6636 Secondary VTTs look like complete object VTTs without part 4. */
6638 static void
6640 {
6641 tree inits;
6642 tree type;
6643 tree vtt;
6644 tree index;
6646 /* Build up the initializers for the VTT. */
6651 /* If we didn't need a VTT, we're done. */
6655 /* Figure out the type of the VTT. */
6659 /* Now, build the VTT object itself. */
6662 /* Add the VTT to the vtables list. */
6667 }
6669 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
6670 PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
6671 and CHAIN the vtable pointer for this binfo after construction is
6672 complete. VALUE can also be another BINFO, in which case we recurse. */
6674 static tree
6676 {
6677 tree vt;
6680 {
6686 else
6688 }
6691 }
6693 /* Data for secondary VTT initialization. */
6695 {
6696 /* Is this the primary VTT? */
6699 /* Current index into the VTT. */
6700 tree index;
6702 /* TREE_LIST of initializers built up. */
6703 tree inits;
6705 /* The type being constructed by this secondary VTT. */
6706 tree type_being_constructed;
6709 /* Recursively build the VTT-initializer for BINFO (which is in the
6710 hierarchy dominated by T). INITS points to the end of the initializer
6711 list to date. INDEX is the VTT index where the next element will be
6712 replaced. Iff BINFO is the binfo for T, this is the top level VTT (i.e.
6713 not a subvtt for some base of T). When that is so, we emit the sub-VTTs
6714 for virtual bases of T. When it is not so, we build the constructor
6715 vtables for the BINFO-in-T variant. */
6719 {
6721 tree b;
6722 tree init;
6723 tree secondary_vptrs;
6724 secondary_vptr_vtt_init_data data;
6727 /* We only need VTTs for subobjects with virtual bases. */
6731 /* We need to use a construction vtable if this is not the primary
6732 VTT. */
6734 {
6737 /* Record the offset in the VTT where this sub-VTT can be found. */
6739 }
6741 /* Add the address of the primary vtable for the complete object. */
6746 {
6749 }
6752 /* Recursively add the secondary VTTs for non-virtual bases. */
6757 /* Add secondary virtual pointers for all subobjects of BINFO with
6758 either virtual bases or reachable along a virtual path, except
6759 subobjects that are non-virtual primary bases. */
6769 /* The secondary vptrs come back in reverse order. After we reverse
6770 them, and add the INITS, the last init will be the first element
6771 of the chain. */
6774 {
6778 }
6781 /* Add the secondary VTTs for virtual bases in inheritance graph
6782 order. */
6784 {
6789 }
6790 else
6791 /* Remove the ctor vtables we created. */
6795 }
6797 /* Called from build_vtt_inits via dfs_walk. BINFO is the binfo for the base
6798 in most derived. DATA is a SECONDARY_VPTR_VTT_INIT_DATA structure. */
6800 static tree
6802 {
6805 /* We don't care about bases that don't have vtables. */
6809 /* We're only interested in proper subobjects of the type being
6810 constructed. */
6814 /* We're only interested in bases with virtual bases or reachable
6815 via a virtual path from the type being constructed. */
6820 /* We're not interested in non-virtual primary bases. */
6824 /* Record the index where this secondary vptr can be found. */
6826 {
6831 {
6832 /* It's a primary virtual base, and this is not a
6833 construction vtable. Find the base this is primary of in
6834 the inheritance graph, and use that base's vtable
6835 now. */
6838 }
6839 }
6841 /* Add the initializer for the secondary vptr itself. */
6844 /* Advance the vtt index. */
6849 }
6851 /* Called from build_vtt_inits via dfs_walk. After building
6852 constructor vtables and generating the sub-vtt from them, we need
6853 to restore the BINFO_VTABLES that were scribbled on. DATA is the
6854 binfo of the base whose sub vtt was generated. */
6856 static tree
6858 {
6862 /* If this class has no vtable, none of its bases do. */
6866 /* This might be a primary base, so have no vtable in this
6867 hierarchy. */
6870 /* If we scribbled the construction vtable vptr into BINFO, clear it
6871 out now. */
6877 }
6879 /* Build the construction vtable group for BINFO which is in the
6880 hierarchy dominated by T. */
6882 static void
6884 {
6885 tree list;
6886 tree type;
6887 tree vtbl;
6888 tree inits;
6889 tree id;
6890 tree vbase;
6892 /* See if we've already created this construction vtable group. */
6898 /* Build a version of VTBL (with the wrong type) for use in
6899 constructing the addresses of secondary vtables in the
6900 construction vtable group. */
6907 /* Add the vtables for each of our virtual bases using the vbase in T
6908 binfo. */
6910 vbase;
6912 {
6913 tree b;
6920 }
6923 /* Figure out the type of the construction vtable. */
6928 /* Initialize the construction vtable. */
6932 }
6934 /* Add the vtbl initializers for BINFO (and its bases other than
6935 non-virtual primaries) to the list of INITS. BINFO is in the
6936 hierarchy dominated by T. RTTI_BINFO is the binfo within T of
6937 the constructor the vtbl inits should be accumulated for. (If this
6938 is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
6939 ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
6940 BINFO is the active base equivalent of ORIG_BINFO in the inheritance
6941 graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
6942 but are not necessarily the same in terms of layout. */
6944 static void
6946 tree orig_binfo,
6947 tree rtti_binfo,
6948 tree t,
6949 tree inits)
6950 {
6952 tree base_binfo;
6957 /* If it doesn't have a vptr, we don't do anything. */
6961 /* If we're building a construction vtable, we're not interested in
6962 subobjects that don't require construction vtables. */
6968 /* Build the initializers for the BINFO-in-T vtable. */
6974 /* Walk the BINFO and its bases. We walk in preorder so that as we
6975 initialize each vtable we can figure out at what offset the
6976 secondary vtable lies from the primary vtable. We can't use
6977 dfs_walk here because we need to iterate through bases of BINFO
6978 and RTTI_BINFO simultaneously. */
6980 {
6981 /* Skip virtual bases. */
6987 inits);
6988 }
6989 }
6991 /* Called from accumulate_vtbl_inits. Returns the initializers for
6992 the BINFO vtable. */
6994 static tree
6996 tree orig_binfo,
6997 tree rtti_binfo,
6998 tree t,
6999 tree l)
7000 {
7007 {
7008 /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
7009 primary virtual base. If it is not the same primary in
7010 the hierarchy of T, we'll need to generate a ctor vtable
7011 for it, to place at its location in T. If it is the same
7012 primary, we still need a VTT entry for the vtable, but it
7013 should point to the ctor vtable for the base it is a
7014 primary for within the sub-hierarchy of RTTI_BINFO.
7016 There are three possible cases:
7018 1) We are in the same place.
7019 2) We are a primary base within a lost primary virtual base of
7020 RTTI_BINFO.
7021 3) We are primary to something not a base of RTTI_BINFO. */
7023 tree b;
7026 /* First, look through the bases we are primary to for RTTI_BINFO
7027 or a virtual base. */
7030 {
7035 }
7036 /* If we run out of primary links, keep looking down our
7037 inheritance chain; we might be an indirect primary. */
7041 found:
7043 /* If we found RTTI_BINFO, this is case 1. If we found a virtual
7044 base B and it is a base of RTTI_BINFO, this is case 2. In
7045 either case, we share our vtable with LAST, i.e. the
7046 derived-most base within B of which we are a primary. */
7049 /* Just set our BINFO_VTABLE to point to LAST, as we may not have
7050 set LAST's BINFO_VTABLE yet. We'll extract the actual vptr in
7051 binfo_ctor_vtable after everything's been set up. */
7054 /* Otherwise, this is case 3 and we get our own. */
7055 }
7060 {
7061 tree index;
7064 /* Compute the initializer for this vtable. */
7068 /* Figure out the position to which the VPTR should point. */
7076 index);
7078 }
7081 /* For a construction vtable, we can't overwrite BINFO_VTABLE.
7082 So, we make a TREE_LIST. Later, dfs_fixup_binfo_vtbls will
7083 straighten this out. */
7087 else
7088 /* For an ordinary vtable, set BINFO_VTABLE. */
7092 }
7094 /* Construct the initializer for BINFO's virtual function table. BINFO
7095 is part of the hierarchy dominated by T. If we're building a
7096 construction vtable, the ORIG_BINFO is the binfo we should use to
7097 find the actual function pointers to put in the vtable - but they
7098 can be overridden on the path to most-derived in the graph that
7099 ORIG_BINFO belongs. Otherwise,
7100 ORIG_BINFO should be the same as BINFO. The RTTI_BINFO is the
7101 BINFO that should be indicated by the RTTI information in the
7102 vtable; it will be a base class of T, rather than T itself, if we
7103 are building a construction vtable.
7105 The value returned is a TREE_LIST suitable for wrapping in a
7106 CONSTRUCTOR to use as the DECL_INITIAL for a vtable. If
7107 NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
7108 number of non-function entries in the vtable.
7110 It might seem that this function should never be called with a
7111 BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
7112 base is always subsumed by a derived class vtable. However, when
7113 we are building construction vtables, we do build vtables for
7114 primary bases; we need these while the primary base is being
7115 constructed. */
7117 static tree
7119 tree orig_binfo,
7120 tree t,
7121 tree rtti_binfo,
7123 {
7125 tree vfun_inits;
7126 vtbl_init_data vid;
7128 tree vbinfo;
7131 /* Initialize VID. */
7140 /* The first vbase or vcall offset is at index -3 in the vtable. */
7143 /* Add entries to the vtable for RTTI. */
7146 /* Create an array for keeping track of the functions we've
7147 processed. When we see multiple functions with the same
7148 signature, we share the vcall offsets. */
7150 /* Add the vcall and vbase offset entries. */
7153 /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
7154 build_vbase_offset_vtbl_entries. */
7159 /* If the target requires padding between data entries, add that now. */
7161 {
7165 {
7172 null_pointer_node),
7173 add);
7175 }
7176 }
7181 /* Go through all the ordinary virtual functions, building up
7182 initializers. */
7185 {
7186 tree delta;
7187 tree vcall_index;
7194 {
7198 {
7201 }
7203 }
7205 /* If the only definition of this function signature along our
7206 primary base chain is from a lost primary, this vtable slot will
7207 never be used, so just zero it out. This is important to avoid
7208 requiring extra thunks which cannot be generated with the function.
7210 We first check this in update_vtable_entry_for_fn, so we handle
7211 restored primary bases properly; we also need to do it here so we
7212 zero out unused slots in ctor vtables, rather than filling themff
7213 with erroneous values (though harmless, apart from relocation
7214 costs). */
7216 {
7217 /* We found a defn before a lost primary; go ahead as normal. */
7221 /* The nearest definition is from a lost primary; clear the
7222 slot. */
7224 {
7227 }
7228 }
7231 {
7232 /* Pull the offset for `this', and the function to call, out of
7233 the list. */
7240 /* You can't call an abstract virtual function; it's abstract.
7241 So, we replace these functions with __pure_virtual. */
7245 {
7249 }
7250 /* Take the address of the function, considering it to be of an
7251 appropriate generic type. */
7253 }
7255 /* And add it to the chain of initializers. */
7257 {
7262 else
7264 {
7272 }
7273 }
7274 else
7276 }
7278 /* The initializers for virtual functions were built up in reverse
7279 order; straighten them out now. */
7282 /* The negative offset initializers are also in reverse order. */
7285 /* Chain the two together. */
7287 }
7289 /* Adds to vid->inits the initializers for the vbase and vcall
7290 offsets in BINFO, which is in the hierarchy dominated by T. */
7292 static void
7294 {
7295 tree b;
7297 /* If this is a derived class, we must first create entries
7298 corresponding to the primary base class. */
7303 /* Add the vbase entries for this base. */
7305 /* Add the vcall entries for this base. */
7307 }
7309 /* Returns the initializers for the vbase offset entries in the vtable
7310 for BINFO (which is part of the class hierarchy dominated by T), in
7311 reverse order. VBASE_OFFSET_INDEX gives the vtable index
7312 where the next vbase offset will go. */
7314 static void
7316 {
7317 tree vbase;
7318 tree t;
7319 tree non_primary_binfo;
7321 /* If there are no virtual baseclasses, then there is nothing to
7322 do. */
7328 /* We might be a primary base class. Go up the inheritance hierarchy
7329 until we find the most derived class of which we are a primary base:
7330 it is the offset of that which we need to use. */
7333 {
7334 tree b;
7336 /* If we have reached a virtual base, then it must be a primary
7337 base (possibly multi-level) of vid->binfo, or we wouldn't
7338 have called build_vcall_and_vbase_vtbl_entries for it. But it
7339 might be a lost primary, so just skip down to vid->binfo. */
7341 {
7344 }
7350 }
7352 /* Go through the virtual bases, adding the offsets. */
7354 vbase;
7356 {
7357 tree b;
7358 tree delta;
7363 /* Find the instance of this virtual base in the complete
7364 object. */
7367 /* If we've already got an offset for this virtual base, we
7368 don't need another one. */
7373 /* Figure out where we can find this vbase offset. */
7382 /* The vbase offset had better be the same. */
7385 /* The next vbase will come at a more negative offset. */
7389 /* The initializer is the delta from BINFO to this virtual base.
7390 The vbase offsets go in reverse inheritance-graph order, and
7391 we are walking in inheritance graph order so these end up in
7392 the right order. */
7398 vtable_entry_type,
7399 delta)));
7401 }
7402 }
7404 /* Adds the initializers for the vcall offset entries in the vtable
7405 for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
7406 to VID->INITS. */
7408 static void
7410 {
7411 /* We only need these entries if this base is a virtual base. We
7412 compute the indices -- but do not add to the vtable -- when
7413 building the main vtable for a class. */
7415 {
7416 /* We need a vcall offset for each of the virtual functions in this
7417 vtable. For example:
7419 class A { virtual void f (); };
7420 class B1 : virtual public A { virtual void f (); };
7421 class B2 : virtual public A { virtual void f (); };
7422 class C: public B1, public B2 { virtual void f (); };
7424 A C object has a primary base of B1, which has a primary base of A. A
7425 C also has a secondary base of B2, which no longer has a primary base
7426 of A. So the B2-in-C construction vtable needs a secondary vtable for
7427 A, which will adjust the A* to a B2* to call f. We have no way of
7428 knowing what (or even whether) this offset will be when we define B2,
7429 so we store this "vcall offset" in the A sub-vtable and look it up in
7430 a "virtual thunk" for B2::f.
7432 We need entries for all the functions in our primary vtable and
7433 in our non-virtual bases' secondary vtables. */
7435 /* If we are just computing the vcall indices -- but do not need
7436 the actual entries -- not that. */
7439 /* Now, walk through the non-virtual bases, adding vcall offsets. */
7441 }
7442 }
7444 /* Build vcall offsets, starting with those for BINFO. */
7446 static void
7448 {
7450 tree primary_binfo;
7451 tree base_binfo;
7453 /* Don't walk into virtual bases -- except, of course, for the
7454 virtual base for which we are building vcall offsets. Any
7455 primary virtual base will have already had its offsets generated
7456 through the recursion in build_vcall_and_vbase_vtbl_entries. */
7460 /* If BINFO has a primary base, process it first. */
7465 /* Add BINFO itself to the list. */
7468 /* Scan the non-primary bases of BINFO. */
7472 }
7474 /* Called from build_vcall_offset_vtbl_entries_r. */
7476 static void
7478 {
7479 /* Make entries for the rest of the virtuals. */
7481 {
7482 tree orig_fn;
7484 /* The ABI requires that the methods be processed in declaration
7485 order. G++ 3.2 used the order in the vtable. */
7487 orig_fn;
7491 }
7492 else
7493 {
7494 tree derived_virtuals;
7495 tree base_virtuals;
7496 tree orig_virtuals;
7497 /* If BINFO is a primary base, the most derived class which has
7498 BINFO as a primary base; otherwise, just BINFO. */
7499 tree non_primary_binfo;
7501 /* We might be a primary base class. Go up the inheritance hierarchy
7502 until we find the most derived class of which we are a primary base:
7503 it is the BINFO_VIRTUALS there that we need to consider. */
7506 {
7507 tree b;
7509 /* If we have reached a virtual base, then it must be vid->vbase,
7510 because we ignore other virtual bases in
7511 add_vcall_offset_vtbl_entries_r. In turn, it must be a primary
7512 base (possibly multi-level) of vid->binfo, or we wouldn't
7513 have called build_vcall_and_vbase_vtbl_entries for it. But it
7514 might be a lost primary, so just skip down to vid->binfo. */
7516 {
7520 }
7526 }
7529 /* For a ctor vtable we need the equivalent binfo within the hierarchy
7530 where rtti_binfo is the most derived type. */
7531 non_primary_binfo
7537 base_virtuals;
7541 {
7542 tree orig_fn;
7544 /* Find the declaration that originally caused this function to
7545 be present in BINFO_TYPE (binfo). */
7548 /* When processing BINFO, we only want to generate vcall slots for
7549 function slots introduced in BINFO. So don't try to generate
7550 one if the function isn't even defined in BINFO. */
7555 }
7556 }
7557 }
7559 /* Add a vcall offset entry for ORIG_FN to the vtable. */
7561 static void
7563 {
7565 tree vcall_offset;
7567 /* If there is already an entry for a function with the same
7568 signature as FN, then we do not need a second vcall offset.
7569 Check the list of functions already present in the derived
7570 class vtable. */
7572 {
7573 tree derived_entry;
7577 /* We only use one vcall offset for virtual destructors,
7578 even though there are two virtual table entries. */
7582 }
7584 /* If we are building these vcall offsets as part of building
7585 the vtable for the most derived class, remember the vcall
7586 offset. */
7588 {
7591 NULL);
7594 }
7596 /* The next vcall offset will be found at a more negative
7597 offset. */
7601 /* Keep track of this function. */
7605 {
7606 tree base;
7607 tree fn;
7609 /* Find the overriding function. */
7613 integer_zero_node);
7614 else
7615 {
7618 /* The vbase we're working on is a primary base of
7619 vid->binfo. But it might be a lost primary, so its
7620 BINFO_OFFSET might be wrong, so we just use the
7621 BINFO_OFFSET from vid->binfo. */
7625 vcall_offset));
7626 }
7627 /* Add the initializer to the vtable. */
7630 }
7631 }
7633 /* Return vtbl initializers for the RTTI entries corresponding to the
7634 BINFO's vtable. The RTTI entries should indicate the object given
7635 by VID->rtti_binfo. */
7637 static void
7639 {
7640 tree b;
7641 tree t;
7642 tree basetype;
7643 tree offset;
7644 tree decl;
7645 tree init;
7650 /* To find the complete object, we will first convert to our most
7651 primary base, and then add the offset in the vtbl to that value. */
7655 {
7656 tree primary_base;
7662 }
7665 /* The second entry is the address of the typeinfo object. */
7668 else
7671 /* Convert the declaration to a type that can be stored in the
7672 vtable. */
7677 /* Add the offset-to-top entry. It comes earlier in the vtable that
7678 the the typeinfo entry. Convert the offset to look like a
7679 function pointer, so that we can put it in the vtable. */
7683 }
7685 /* Fold a OBJ_TYPE_REF expression to the address of a function.
7686 KNOWN_TYPE carries the true type of OBJ_TYPE_REF_OBJECT(REF). */
7688 tree
7690 {
7694 tree fndecl;
7697 {
7698 i += (TARGET_VTABLE_USES_DESCRIPTORS
7701 }
7705 #ifdef ENABLE_CHECKING
7708 #endif
7711 }