| blob | 4bb9dd2c1684a627fe58e3024195717190ab4efc |
1 /* Functions related to building classes and their related objects.
2 Copyright (C) 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011,
4 2012
5 Free Software Foundation, Inc.
6 Contributed by Michael Tiemann (tiemann@cygnus.com)
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
13 any later version.
15 GCC is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
25 /* High-level class interface. */
42 /* The number of nested classes being processed. If we are not in the
43 scope of any class, this is zero. */
47 /* In order to deal with nested classes, we keep a stack of classes.
48 The topmost entry is the innermost class, and is the entry at index
49 CURRENT_CLASS_DEPTH */
52 /* The name of the class. */
53 tree name;
55 /* The _TYPE node for the class. */
56 tree type;
58 /* The access specifier pending for new declarations in the scope of
59 this class. */
60 tree access;
62 /* If were defining TYPE, the names used in this class. */
63 splay_tree names_used;
65 /* Nonzero if this class is no longer open, because of a call to
66 push_to_top_level. */
71 {
72 /* The base for which we're building initializers. */
73 tree binfo;
74 /* The type of the most-derived type. */
75 tree derived;
76 /* The binfo for the dynamic type. This will be TYPE_BINFO (derived),
77 unless ctor_vtbl_p is true. */
78 tree rtti_binfo;
79 /* The negative-index vtable initializers built up so far. These
80 are in order from least negative index to most negative index. */
82 /* The binfo for the virtual base for which we're building
83 vcall offset initializers. */
84 tree vbase;
85 /* The functions in vbase for which we have already provided vcall
86 offsets. */
88 /* The vtable index of the next vcall or vbase offset. */
89 tree index;
90 /* Nonzero if we are building the initializer for the primary
91 vtable. */
93 /* Nonzero if we are building the initializer for a construction
94 vtable. */
96 /* True when adding vcall offset entries to the vtable. False when
97 merely computing the indices. */
101 /* The type of a function passed to walk_subobject_offsets. */
104 /* The stack itself. This is a dynamically resized array. The
105 number of elements allocated is CURRENT_CLASS_STACK_SIZE. */
109 /* The size of the largest empty class seen in this translation unit. */
112 /* An array of all local classes present in this translation unit, in
113 declaration order. */
204 splay_tree_key k2);
213 /* Variables shared between class.c and call.c. */
215 #ifdef GATHER_STATISTICS
223 #endif
225 /* Convert to or from a base subobject. EXPR is an expression of type
226 `A' or `A*', an expression of type `B' or `B*' is returned. To
227 convert A to a base B, CODE is PLUS_EXPR and BINFO is the binfo for
228 the B base instance within A. To convert base A to derived B, CODE
229 is MINUS_EXPR and BINFO is the binfo for the A instance within B.
230 In this latter case, A must not be a morally virtual base of B.
231 NONNULL is true if EXPR is known to be non-NULL (this is only
232 needed when EXPR is of pointer type). CV qualifiers are preserved
233 from EXPR. */
235 tree
237 tree expr,
238 tree binfo,
240 tsubst_flags_t complain)
241 {
244 tree probe;
245 tree offset;
246 tree target_type;
248 tree ptr_target_type;
258 {
264 }
272 {
273 /* This can happen when adjust_result_of_qualified_name_lookup can't
274 find a unique base binfo in a call to a member function. We
275 couldn't give the diagnostic then since we might have been calling
276 a static member function, so we do it now. */
278 {
282 }
284 }
291 /* Nothing to do. */
295 {
301 }
304 /* This must happen before the call to save_expr. */
306 else
312 /* TARGET_TYPE has been extracted from BINFO, and, is therefore always
313 cv-unqualified. Extract the cv-qualifiers from EXPR so that the
314 expression returned matches the input. */
315 target_type = cp_build_qualified_type
319 /* Do we need to look in the vtable for the real offset? */
322 /* Don't bother with the calculations inside sizeof; they'll ICE if the
323 source type is incomplete and the pointer value doesn't matter. In a
324 template (even in fold_non_dependent_expr), we don't have vtables set
325 up properly yet, and the value doesn't matter there either; we're just
326 interested in the result of overload resolution. */
328 || (current_function_decl
330 {
335 }
337 /* If we're in an NSDMI, we don't have the full constructor context yet
338 that we need for converting to a virtual base, so just build a stub
339 CONVERT_EXPR and expand it later in bot_replace. */
342 {
348 }
350 /* Do we need to check for a null pointer? */
352 {
353 /* If we know the conversion will not actually change the value
354 of EXPR, then we can avoid testing the expression for NULL.
355 We have to avoid generating a COMPONENT_REF for a base class
356 field, because other parts of the compiler know that such
357 expressions are always non-NULL. */
361 }
363 /* Protect against multiple evaluation if necessary. */
367 /* Now that we've saved expr, build the real null test. */
369 {
373 }
375 /* If this is a simple base reference, express it as a COMPONENT_REF. */
377 /* We don't build base fields for empty bases, and they aren't very
378 interesting to the optimizers anyway. */
380 {
387 }
390 {
391 /* Going via virtual base V_BINFO. We need the static offset
392 from V_BINFO to BINFO, and the dynamic offset from D_BINFO to
393 V_BINFO. That offset is an entry in D_BINFO's vtable. */
394 tree v_offset;
397 {
398 /* In a base member initializer, we cannot rely on the
399 vtable being set up. We have to indirect via the
400 vtt_parm. */
401 tree t;
407 }
408 else
410 complain),
416 v_offset);
428 /* Negative fixed_type_p means this is a constructor or destructor;
429 virtual base layout is fixed in in-charge [cd]tors, but not in
430 base [cd]tors. */
434 v_offset,
437 else
439 }
447 {
452 }
453 else
459 out:
465 }
467 /* Subroutine of build_base_path; EXPR and BINFO are as in that function.
468 Perform a derived-to-base conversion by recursively building up a
469 sequence of COMPONENT_REFs to the appropriate base fields. */
471 static tree
473 {
476 tree field;
479 {
480 tree temp;
484 /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x'
485 into `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only
486 an lvalue in the front end; only _DECLs and _REFs are lvalues
487 in the back end. */
493 }
495 /* Recurse. */
500 /* Is this the base field created by build_base_field? */
504 /* If we're looking for a field in the most-derived class,
505 also check the field offset; we can have two base fields
506 of the same type if one is an indirect virtual base and one
507 is a direct non-virtual base. */
511 {
512 /* We don't use build_class_member_access_expr here, as that
513 has unnecessary checks, and more importantly results in
514 recursive calls to dfs_walk_once. */
522 /* Mark the expression const or volatile, as appropriate.
523 Even though we've dealt with the type above, we still have
524 to mark the expression itself. */
531 }
533 /* Didn't find the base field?!? */
535 }
537 /* Convert OBJECT to the base TYPE. OBJECT is an expression whose
538 type is a class type or a pointer to a class type. In the former
539 case, TYPE is also a class type; in the latter it is another
540 pointer type. If CHECK_ACCESS is true, an error message is emitted
541 if TYPE is inaccessible. If OBJECT has pointer type, the value is
542 assumed to be non-NULL. */
544 tree
546 tsubst_flags_t complain)
547 {
548 tree binfo;
549 tree object_type;
550 base_access access;
553 {
556 }
557 else
564 access,
565 NULL);
570 }
572 /* EXPR is an expression with unqualified class type. BASE is a base
573 binfo of that class type. Returns EXPR, converted to the BASE
574 type. This function assumes that EXPR is the most derived class;
575 therefore virtual bases can be found at their static offsets. */
577 tree
579 {
580 tree expr_type;
584 {
585 /* If this is a non-empty base, use a COMPONENT_REF. */
589 /* We use fold_build2 and fold_convert below to simplify the trees
590 provided to the optimizers. It is not safe to call these functions
591 when processing a template because they do not handle C++-specific
592 trees. */
600 }
603 }
605 \f
606 tree
608 {
614 /* First, convert to the requested type. */
619 /* Second, the requested type may not be the owner of its own vptr.
620 If not, convert to the base class that owns it. We cannot use
621 convert_to_base here, because VCONTEXT may appear more than once
622 in the inheritance hierarchy of TYPE, and thus direct conversion
623 between the types may be ambiguous. Following the path back up
624 one step at a time via primary bases avoids the problem. */
628 {
631 }
634 }
636 /* Given an object INSTANCE, return an expression which yields the
637 vtable element corresponding to INDEX. There are many special
638 cases for INSTANCE which we take care of here, mainly to avoid
639 creating extra tree nodes when we don't have to. */
641 static tree
643 {
644 tree aref;
647 /* Try to figure out what a reference refers to, and
648 access its virtual function table directly. */
656 {
661 }
670 }
672 tree
674 {
678 }
680 /* Given a stable object pointer INSTANCE_PTR, return an expression which
681 yields a function pointer corresponding to vtable element INDEX. */
683 tree
685 {
686 tree aref;
689 tf_warning_or_error),
690 idx);
692 /* When using function descriptors, the address of the
693 vtable entry is treated as a function pointer. */
698 /* Remember this as a method reference, for later devirtualization. */
702 }
704 /* Return the name of the virtual function table (as an IDENTIFIER_NODE)
705 for the given TYPE. */
707 static tree
709 {
711 }
713 /* DECL is an entity associated with TYPE, like a virtual table or an
714 implicitly generated constructor. Determine whether or not DECL
715 should have external or internal linkage at the object file
716 level. This routine does not deal with COMDAT linkage and other
717 similar complexities; it simply sets TREE_PUBLIC if it possible for
718 entities in other translation units to contain copies of DECL, in
719 the abstract. */
721 void
723 {
726 }
728 /* Create a VAR_DECL for a primary or secondary vtable for CLASS_TYPE.
729 (For a secondary vtable for B-in-D, CLASS_TYPE should be D, not B.)
730 Use NAME for the name of the vtable, and VTABLE_TYPE for its type. */
732 static tree
734 {
735 tree decl;
738 /* vtable names are already mangled; give them their DECL_ASSEMBLER_NAME
739 now to avoid confusion in mangle_decl. */
748 /* At one time the vtable info was grabbed 2 words at a time. This
749 fails on sparc unless you have 8-byte alignment. (tiemann) */
753 /* The vtable has not been defined -- yet. */
757 /* Mark the VAR_DECL node representing the vtable itself as a
758 "gratuitous" one, thereby forcing dwarfout.c to ignore it. It
759 is rather important that such things be ignored because any
760 effort to actually generate DWARF for them will run into
761 trouble when/if we encounter code like:
763 #pragma interface
764 struct S { virtual void member (); };
766 because the artificial declaration of the vtable itself (as
767 manufactured by the g++ front end) will say that the vtable is
768 a static member of `S' but only *after* the debug output for
769 the definition of `S' has already been output. This causes
770 grief because the DWARF entry for the definition of the vtable
771 will try to refer back to an earlier *declaration* of the
772 vtable as a static member of `S' and there won't be one. We
773 might be able to arrange to have the "vtable static member"
774 attached to the member list for `S' before the debug info for
775 `S' get written (which would solve the problem) but that would
776 require more intrusive changes to the g++ front end. */
780 }
782 /* Get the VAR_DECL of the vtable for TYPE. TYPE need not be polymorphic,
783 or even complete. If this does not exist, create it. If COMPLETE is
784 nonzero, then complete the definition of it -- that will render it
785 impossible to actually build the vtable, but is useful to get at those
786 which are known to exist in the runtime. */
788 tree
790 {
791 tree decl;
800 {
803 }
806 }
808 /* Build the primary virtual function table for TYPE. If BINFO is
809 non-NULL, build the vtable starting with the initial approximation
810 that it is the same as the one which is the head of the association
811 list. Returns a nonzero value if a new vtable is actually
812 created. */
814 static int
816 {
817 tree decl;
818 tree virtuals;
823 {
825 /* We have already created a vtable for this base, so there's
826 no need to do it again. */
833 }
834 else
835 {
838 }
840 #ifdef GATHER_STATISTICS
843 #endif
845 /* Initialize the association list for this type, based
846 on our first approximation. */
851 }
853 /* Give BINFO a new virtual function table which is initialized
854 with a skeleton-copy of its original initialization. The only
855 entry that changes is the `delta' entry, so we can really
856 share a lot of structure.
858 FOR_TYPE is the most derived type which caused this table to
859 be needed.
861 Returns nonzero if we haven't met BINFO before.
863 The order in which vtables are built (by calling this function) for
864 an object must remain the same, otherwise a binary incompatibility
865 can result. */
867 static int
869 {
871 /* We already created a vtable for this base. There's no need to
872 do it again. */
875 /* Remember that we've created a vtable for this BINFO, so that we
876 don't try to do so again. */
879 /* Make fresh virtual list, so we can smash it later. */
882 /* Secondary vtables are laid out as part of the same structure as
883 the primary vtable. */
886 }
888 /* Create a new vtable for BINFO which is the hierarchy dominated by
889 T. Return nonzero if we actually created a new vtable. */
891 static int
893 {
895 /* In this case, it is *type*'s vtable we are modifying. We start
896 with the approximation that its vtable is that of the
897 immediate base class. */
899 else
900 /* This is our very own copy of `basetype' to play with. Later,
901 we will fill in all the virtual functions that override the
902 virtual functions in these base classes which are not defined
903 by the current type. */
905 }
907 /* Make *VIRTUALS, an entry on the BINFO_VIRTUALS list for BINFO
908 (which is in the hierarchy dominated by T) list FNDECL as its
909 BV_FN. DELTA is the required constant adjustment from the `this'
910 pointer where the vtable entry appears to the `this' required when
911 the function is actually called. */
913 static void
915 tree binfo,
916 tree fndecl,
917 tree delta,
919 {
920 tree v;
926 {
927 /* We need a new vtable for BINFO. */
929 {
930 /* If we really did make a new vtable, we also made a copy
931 of the BINFO_VIRTUALS list. Now, we have to find the
932 corresponding entry in that list. */
937 }
942 }
943 }
945 \f
946 /* Add method METHOD to class TYPE. If USING_DECL is non-null, it is
947 the USING_DECL naming METHOD. Returns true if the method could be
948 added to the method vec. */
950 bool
952 {
954 tree overload;
960 tree current_fns;
961 tree fns;
974 {
975 /* Make a new method vector. We start with 8 entries. We must
976 allocate at least two (for constructors and destructors), and
977 we're going to end up with an assignment operator at some
978 point as well. */
980 /* Create slots for constructors and destructors. */
984 }
986 /* Maintain TYPE_HAS_USER_CONSTRUCTOR, etc. */
989 /* Constructors and destructors go in special slots. */
993 {
997 {
1003 type);
1004 }
1005 }
1006 else
1007 {
1008 tree m;
1011 /* See if we already have an entry with this name. */
1015 {
1018 {
1023 }
1027 {
1030 }
1035 }
1036 }
1039 /* Check to see if we've already got this method. */
1041 {
1043 tree fn_type;
1044 tree method_type;
1045 tree parms1;
1046 tree parms2;
1051 /* [over.load] Member function declarations with the
1052 same name and the same parameter types cannot be
1053 overloaded if any of them is a static member
1054 function declaration.
1056 [namespace.udecl] When a using-declaration brings names
1057 from a base class into a derived class scope, member
1058 functions in the derived class override and/or hide member
1059 functions with the same name and parameter types in a base
1060 class (rather than conflicting). */
1066 /* Compare the quals on the 'this' parm. Don't compare
1067 the whole types, as used functions are treated as
1068 coming from the using class in overload resolution. */
1077 /* For templates, the return type and template parameters
1078 must be identical. */
1095 {
1097 {
1099 /* Defer to the local function. */
1101 }
1102 else
1103 {
1106 }
1108 /* We don't call duplicate_decls here to merge the
1109 declarations because that will confuse things if the
1110 methods have inline definitions. In particular, we
1111 will crash while processing the definitions. */
1113 }
1114 }
1116 /* A class should never have more than one destructor. */
1120 /* Add the new binding. */
1122 {
1125 }
1126 else
1135 {
1138 /* We only expect to add few methods in the COMPLETE_P case, so
1139 just make room for one more method in that case. */
1142 else
1148 else
1150 }
1151 else
1152 /* Replace the current slot. */
1155 }
1157 /* Subroutines of finish_struct. */
1159 /* Change the access of FDECL to ACCESS in T. Return 1 if change was
1160 legit, otherwise return 0. */
1162 static int
1164 {
1165 tree elem;
1174 {
1176 {
1180 else
1183 }
1184 else
1185 {
1186 /* They're changing the access to the same thing they changed
1187 it to before. That's OK. */
1188 ;
1189 }
1190 }
1191 else
1192 {
1196 }
1198 }
1200 /* Process the USING_DECL, which is a member of T. */
1202 static void
1204 {
1207 tree access
1212 tree old_value;
1217 tf_warning_or_error);
1219 {
1225 else
1227 }
1235 ;
1237 {
1239 /* It's OK to use functions from a base when there are functions with
1241 else
1242 {
1247 }
1248 }
1250 {
1254 }
1256 /* Make type T see field decl FDECL with access ACCESS. */
1259 {
1262 }
1263 else
1265 }
1266 \f
1267 /* Run through the base classes of T, updating CANT_HAVE_CONST_CTOR_P,
1268 and NO_CONST_ASN_REF_P. Also set flag bits in T based on
1269 properties of the bases. */
1271 static void
1275 {
1279 tree base_binfo;
1280 tree binfo;
1290 {
1299 /* If any base class is non-literal, so is the derived class. */
1303 /* Effective C++ rule 14. We only need to check TYPE_POLYMORPHIC_P
1304 here because the case of virtual functions but non-virtual
1305 dtor is handled in finish_struct_1. */
1310 /* If the base class doesn't have copy constructors or
1311 assignment operators that take const references, then the
1312 derived class cannot have such a member automatically
1313 generated. */
1322 /* A virtual base does not effect nearly emptiness. */
1323 ;
1325 {
1327 /* And if there is more than one nearly empty base, then the
1328 derived class is not nearly empty either. */
1330 else
1331 /* Remember we've seen one. */
1333 }
1335 /* If the base class is not empty or nearly empty, then this
1336 class cannot be nearly empty. */
1339 /* A lot of properties from the bases also apply to the derived
1340 class. */
1358 /* A standard-layout class is a class that:
1359 ...
1360 * has no non-standard-layout base classes, */
1363 {
1364 tree basefield;
1365 /* ...has no base classes of the same type as the first non-static
1366 data member... */
1368 && (same_type_ignoring_top_level_qualifiers_p
1371 else
1372 /* ...either has no non-static data members in the most-derived
1373 class and at most one base class with non-static data
1374 members, or has no base classes with non-static data
1375 members */
1379 {
1382 else
1385 }
1386 }
1388 /* Don't bother collecting tm attributes if transactional memory
1389 support is not enabled. */
1391 {
1395 }
1396 }
1398 /* If one of the base classes had TM attributes, and the current class
1399 doesn't define its own, then the current class inherits one. */
1401 {
1404 }
1405 }
1407 /* Determine all the primary bases within T. Sets BINFO_PRIMARY_BASE_P for
1408 those that are primaries. Sets BINFO_LOST_PRIMARY_P for those
1409 that have had a nearly-empty virtual primary base stolen by some
1410 other base in the hierarchy. Determines CLASSTYPE_PRIMARY_BASE for
1411 T. */
1413 static void
1415 {
1419 tree base_binfo;
1421 /* Determine the primary bases of our bases. */
1424 {
1427 /* See if we're the non-virtual primary of our inheritance
1428 chain. */
1430 {
1437 /* We are the primary binfo. */
1439 }
1440 /* Determine if we have a virtual primary base, and mark it so.
1441 */
1443 {
1447 /* Someone already claimed this base. */
1449 else
1450 {
1451 tree delta;
1456 /* A virtual binfo might have been copied from within
1457 another hierarchy. As we're about to use it as a
1458 primary base, make sure the offsets match. */
1466 }
1467 }
1468 }
1470 /* First look for a dynamic direct non-virtual base. */
1472 {
1476 {
1479 }
1480 }
1482 /* A "nearly-empty" virtual base class can be the primary base
1483 class, if no non-virtual polymorphic base can be found. Look for
1484 a nearly-empty virtual dynamic base that is not already a primary
1485 base of something in the hierarchy. If there is no such base,
1486 just pick the first nearly-empty virtual base. */
1492 {
1494 {
1495 /* Found one that is not primary. */
1498 }
1500 /* Remember the first candidate. */
1502 }
1504 found:
1505 /* If we've got a primary base, use it. */
1507 {
1512 /* We are stealing a primary base. */
1516 {
1517 tree delta;
1520 /* A virtual binfo might have been copied from within
1521 another hierarchy. As we're about to use it as a primary
1522 base, make sure the offsets match. */
1527 }
1534 }
1535 }
1537 /* Update the variant types of T. */
1539 void
1541 {
1542 tree variants;
1548 variants;
1550 {
1551 /* These fields are in the _TYPE part of the node, not in
1552 the TYPE_LANG_SPECIFIC component, so they are not shared. */
1562 /* Copy whatever these are holding today. */
1566 }
1567 }
1569 /* Early variant fixups: we apply attributes at the beginning of the class
1570 definition, and we need to fix up any variants that have already been
1571 made via elaborated-type-specifier so that check_qualified_type works. */
1573 void
1575 {
1576 tree variants;
1582 variants;
1584 {
1585 /* These are the two fields that check_qualified_type looks at and
1586 are affected by attributes. */
1589 }
1590 }
1591 \f
1592 /* Set memoizing fields and bits of T (and its variants) for later
1593 use. */
1595 static void
1597 {
1598 /* Fix up variants (if any). */
1602 /* For a class w/o baseclasses, 'finish_struct' has set
1603 CLASSTYPE_PURE_VIRTUALS correctly (by definition).
1604 Similarly for a class whose base classes do not have vtables.
1605 When neither of these is true, we might have removed abstract
1606 virtuals (by providing a definition), added some (by declaring
1607 new ones), or redeclared ones from a base class. We need to
1608 recalculate what's really an abstract virtual at this point (by
1609 looking in the vtables). */
1612 /* If this type has a copy constructor or a destructor, force its
1613 mode to be BLKmode, and force its TREE_ADDRESSABLE bit to be
1614 nonzero. This will cause it to be passed by invisible reference
1615 and prevent it from being returned in a register. */
1618 {
1619 tree variants;
1622 {
1625 }
1626 }
1627 }
1629 /* Issue warnings about T having private constructors, but no friends,
1630 and so forth.
1632 HAS_NONPRIVATE_METHOD is nonzero if T has any non-private methods or
1633 static members. HAS_NONPRIVATE_STATIC_FN is nonzero if T has any
1634 non-private static member functions. */
1636 static void
1638 {
1641 tree fn;
1644 /* If the class has friends, those entities might create and
1645 access instances, so we should not warn. */
1648 /* We will have warned when the template was declared; there's
1649 no need to warn on every instantiation. */
1651 /* There's no reason to even consider warning about this
1652 class. */
1655 /* We only issue one warning, if more than one applies, because
1656 otherwise, on code like:
1658 class A {
1659 // Oops - forgot `public:'
1660 A();
1661 A(const A&);
1662 ~A();
1663 };
1665 we warn several times about essentially the same problem. */
1667 /* Check to see if all (non-constructor, non-destructor) member
1668 functions are private. (Since there are no friends or
1669 non-private statics, we can't ever call any of the private member
1670 functions.) */
1672 /* We're not interested in compiler-generated methods; they don't
1673 provide any way to call private members. */
1675 {
1677 {
1679 /* A non-private static member function is just like a
1680 friend; it can create and invoke private member
1681 functions, and be accessed without a class
1682 instance. */
1686 /* Keep searching for a static member function. */
1687 }
1690 }
1693 {
1694 /* There are no non-private methods, and there's at least one
1695 private member function that isn't a constructor or
1696 destructor. (If all the private members are
1697 constructors/destructors we want to use the code below that
1698 issues error messages specifically referring to
1699 constructors/destructors.) */
1705 {
1708 }
1710 {
1714 }
1715 }
1717 /* Even if some of the member functions are non-private, the class
1718 won't be useful for much if all the constructors or destructors
1719 are private: such an object can never be created or destroyed. */
1722 {
1725 t);
1727 }
1729 /* Warn about classes that have private constructors and no friends. */
1731 /* Implicitly generated constructors are always public. */
1734 {
1737 /* If a non-template class does not define a copy
1738 constructor, one is defined for it, enabling it to avoid
1739 this warning. For a template class, this does not
1740 happen, and so we would normally get a warning on:
1742 template <class T> class C { private: C(); };
1744 To avoid this asymmetry, we check TYPE_HAS_COPY_CTOR. All
1745 complete non-template or fully instantiated classes have this
1746 flag set. */
1749 else
1751 {
1753 /* Ideally, we wouldn't count copy constructors (or, in
1754 fact, any constructor that takes an argument of the
1755 class type as a parameter) because such things cannot
1756 be used to construct an instance of the class unless
1757 you already have one. But, for now at least, we're
1758 more generous. */
1760 {
1763 }
1764 }
1767 {
1770 t);
1772 }
1773 }
1774 }
1777 gt_pointer_operator new_value;
1781 /* Comparison function to compare two TYPE_METHOD_VEC entries by name. */
1783 static int
1785 {
1798 }
1800 /* This routine compares two fields like method_name_cmp but using the
1801 pointer operator in resort_field_decl_data. */
1803 static int
1805 {
1814 {
1821 }
1823 }
1825 /* Resort TYPE_METHOD_VEC because pointers have been reordered. */
1827 void
1830 gt_pointer_operator new_value,
1832 {
1836 tree fn;
1838 /* The type conversion ops have to live at the front of the vec, so we
1839 can't sort them. */
1847 {
1851 resort_method_name_cmp);
1852 }
1853 }
1855 /* Warn about duplicate methods in fn_fields.
1857 Sort methods that are not special (i.e., constructors, destructors,
1858 and type conversion operators) so that we can find them faster in
1859 search. */
1861 static void
1863 {
1864 tree fn_fields;
1874 /* Clear DECL_IN_AGGR_P for all functions. */
1879 /* Issue warnings about private constructors and such. If there are
1880 no methods, then some public defaults are generated. */
1883 /* The type conversion ops have to live at the front of the vec, so we
1884 can't sort them. */
1893 }
1895 /* Make BINFO's vtable have N entries, including RTTI entries,
1896 vbase and vcall offsets, etc. Set its type and call the back end
1897 to lay it out. */
1899 static void
1901 {
1902 tree atype;
1903 tree vtable;
1908 /* We may have to grow the vtable. */
1911 {
1915 }
1916 }
1918 /* True iff FNDECL and BASE_FNDECL (both non-static member functions)
1919 have the same signature. */
1921 int
1923 {
1924 /* One destructor overrides another if they are the same kind of
1925 destructor. */
1929 /* But a non-destructor never overrides a destructor, nor vice
1930 versa, nor do different kinds of destructors override
1931 one-another. For example, a complete object destructor does not
1932 override a deleting destructor. */
1941 {
1949 }
1951 }
1953 /* Returns TRUE if DERIVED is a binfo containing the binfo BASE as a
1954 subobject. */
1956 static bool
1958 {
1959 tree probe;
1962 {
1966 /* If we meet a virtual base, we can't follow the inheritance
1967 any more. See if the complete type of DERIVED contains
1968 such a virtual base. */
1971 }
1973 }
1976 /* The function for which we are trying to find a final overrider. */
1977 tree fn;
1978 /* The base class in which the function was declared. */
1979 tree declaring_base;
1980 /* The candidate overriders. */
1981 tree candidates;
1982 /* Path to most derived. */
1986 /* Add the overrider along the current path to FFOD->CANDIDATES.
1987 Returns true if an overrider was found; false otherwise. */
1989 static bool
1993 {
1994 tree method;
1996 /* If BINFO is not the most derived type, try a more derived class.
1997 A definition there will overrider a definition here. */
1999 {
2000 depth--;
2004 }
2008 {
2011 /* Remove any candidates overridden by this new function. */
2013 {
2014 /* If *CANDIDATE overrides METHOD, then METHOD
2015 cannot override anything else on the list. */
2018 /* If METHOD overrides *CANDIDATE, remove *CANDIDATE. */
2021 else
2023 }
2025 /* Add the new function. */
2028 }
2031 }
2033 /* Called from find_final_overrider via dfs_walk. */
2035 static tree
2037 {
2045 }
2047 static tree
2049 {
2054 }
2056 /* Returns a TREE_LIST whose TREE_PURPOSE is the final overrider for
2057 FN and whose TREE_VALUE is the binfo for the base where the
2058 overriding occurs. BINFO (in the hierarchy dominated by the binfo
2059 DERIVED) is the base object in which FN is declared. */
2061 static tree
2063 {
2064 find_final_overrider_data ffod;
2066 /* Getting this right is a little tricky. This is valid:
2068 struct S { virtual void f (); };
2069 struct T { virtual void f (); };
2070 struct U : public S, public T { };
2072 even though calling `f' in `U' is ambiguous. But,
2074 struct R { virtual void f(); };
2075 struct S : virtual public R { virtual void f (); };
2076 struct T : virtual public R { virtual void f (); };
2077 struct U : public S, public T { };
2079 is not -- there's no way to decide whether to put `S::f' or
2080 `T::f' in the vtable for `R'.
2082 The solution is to look at all paths to BINFO. If we find
2083 different overriders along any two, then there is a problem. */
2087 /* Determine the depth of the hierarchy. */
2098 /* If there was no winner, issue an error message. */
2103 }
2105 /* Return the index of the vcall offset for FN when TYPE is used as a
2106 virtual base. */
2108 static tree
2110 {
2112 tree_pair_p p;
2120 /* There should always be an appropriate index. */
2122 }
2124 /* Update an entry in the vtable for BINFO, which is in the hierarchy
2125 dominated by T. FN is the old function; VIRTUALS points to the
2126 corresponding position in the new BINFO_VIRTUALS list. IX is the index
2127 of that entry in the list. */
2129 static void
2132 {
2133 tree b;
2134 tree overrider;
2135 tree delta;
2136 tree virtual_base;
2137 tree first_defn;
2143 /* Find the nearest primary base (possibly binfo itself) which defines
2144 this function; this is the class the caller will convert to when
2145 calling FN through BINFO. */
2147 {
2152 /* The nearest definition is from a lost primary. */
2155 }
2158 /* Find the final overrider. */
2161 {
2164 }
2167 /* Check for adjusting covariant return types. */
2175 /* If the overrider is invalid, don't even try. */
2177 {
2178 /* If FN is a covariant thunk, we must figure out the adjustment
2179 to the final base FN was converting to. As OVERRIDER_TARGET might
2180 also be converting to the return type of FN, we have to
2181 combine the two conversions here. */
2188 {
2192 }
2193 else
2197 /* Find the equivalent binfo within the return type of the
2198 overriding function. We will want the vbase offset from
2199 there. */
2201 over_return);
2204 {
2205 /* There was no existing virtual thunk (which takes
2206 precedence). So find the binfo of the base function's
2207 return type within the overriding function's return type.
2208 We cannot call lookup base here, because we're inside a
2209 dfs_walk, and will therefore clobber the BINFO_MARKED
2210 flags. Fortunately we know the covariancy is valid (it
2211 has already been checked), so we can just iterate along
2212 the binfos, which have been chained in inheritance graph
2213 order. Of course it is lame that we have to repeat the
2214 search here anyway -- we should really be caching pieces
2215 of the vtable and avoiding this repeated work. */
2218 /* Find the base binfo within the overriding function's
2219 return type. We will always find a thunk_binfo, except
2220 when the covariancy is invalid (which we will have
2221 already diagnosed). */
2224 thunk_binfo;
2230 /* See if virtual inheritance is involved. */
2232 virtual_offset;
2239 {
2243 {
2244 /* We convert via virtual base. Adjust the fixed
2245 offset to be from there. */
2246 offset =
2250 }
2252 /* There was an existing fixed offset, this must be
2253 from the base just converted to, and the base the
2254 FN was thunking to. */
2256 else
2258 }
2259 }
2262 /* Replace the overriding function with a covariant thunk. We
2263 will emit the overriding function in its own slot as
2264 well. */
2267 }
2268 else
2272 /* If we need a covariant thunk, then we may need to adjust first_defn.
2273 The ABI specifies that the thunks emitted with a function are
2274 determined by which bases the function overrides, so we need to be
2275 sure that we're using a thunk for some overridden base; even if we
2276 know that the necessary this adjustment is zero, there may not be an
2277 appropriate zero-this-adjusment thunk for us to use since thunks for
2278 overriding virtual bases always use the vcall offset.
2280 Furthermore, just choosing any base that overrides this function isn't
2281 quite right, as this slot won't be used for calls through a type that
2282 puts a covariant thunk here. Calling the function through such a type
2283 will use a different slot, and that slot is the one that determines
2284 the thunk emitted for that base.
2286 So, keep looking until we find the base that we're really overriding
2287 in this slot: the nearest primary base that doesn't use a covariant
2288 thunk in this slot. */
2290 {
2292 /* We already know that the overrider needs a covariant thunk. */
2295 {
2302 }
2304 }
2306 /* Assume that we will produce a thunk that convert all the way to
2307 the final overrider, and not to an intermediate virtual base. */
2310 /* See if we can convert to an intermediate virtual base first, and then
2311 use the vcall offset located there to finish the conversion. */
2313 {
2314 /* If we find the final overrider, then we can stop
2315 walking. */
2320 /* If we find a virtual base, and we haven't yet found the
2321 overrider, then there is a virtual base between the
2322 declaring base (first_defn) and the final overrider. */
2324 {
2327 }
2328 }
2330 /* Compute the constant adjustment to the `this' pointer. The
2331 `this' pointer, when this function is called, will point at BINFO
2332 (or one of its primary bases, which are at the same offset). */
2334 /* The `this' pointer needs to be adjusted from the declaration to
2335 the nearest virtual base. */
2340 /* If the nearest definition is in a lost primary, we don't need an
2341 entry in our vtable. Except possibly in a constructor vtable,
2342 if we happen to get our primary back. In that case, the offset
2343 will be zero, as it will be a primary base. */
2345 else
2346 /* The `this' pointer needs to be adjusted from pointing to
2347 BINFO to pointing at the base where the final overrider
2348 appears. */
2359 else
2363 }
2365 /* Called from modify_all_vtables via dfs_walk. */
2367 static tree
2369 {
2371 tree virtuals;
2372 tree old_virtuals;
2376 /* A base without a vtable needs no modification, and its bases
2377 are uninteresting. */
2382 /* Don't do the primary vtable, if it's new. */
2386 /* There's no need to modify the vtable for a non-virtual primary
2387 base; we're not going to use that vtable anyhow. We do still
2388 need to do this for virtual primary bases, as they could become
2389 non-primary in a construction vtable. */
2394 /* Now, go through each of the virtual functions in the virtual
2395 function table for BINFO. Find the final overrider, and update
2396 the BINFO_VIRTUALS list appropriately. */
2399 virtuals;
2403 binfo,
2408 }
2410 /* Update all of the primary and secondary vtables for T. Create new
2411 vtables as required, and initialize their RTTI information. Each
2412 of the functions in VIRTUALS is declared in T and may override a
2413 virtual function from a base class; find and modify the appropriate
2414 entries to point to the overriding functions. Returns a list, in
2415 declaration order, of the virtual functions that are declared in T,
2416 but do not appear in the primary base class vtable, and which
2417 should therefore be appended to the end of the vtable for T. */
2419 static tree
2421 {
2425 /* Update all of the vtables. */
2428 /* Add virtual functions not already in our primary vtable. These
2429 will be both those introduced by this class, and those overridden
2430 from secondary bases. It does not include virtuals merely
2431 inherited from secondary bases. */
2433 {
2438 {
2439 /* We don't need to adjust the `this' pointer when
2440 calling this function. */
2444 /* This is a function not already in our vtable. Keep it. */
2446 }
2447 else
2448 /* We've already got an entry for this function. Skip it. */
2450 }
2453 }
2455 /* Get the base virtual function declarations in T that have the
2456 indicated NAME. */
2458 static tree
2460 {
2461 tree methods;
2466 /* Find virtual functions in T with the indicated NAME. */
2470 methods;
2472 {
2478 }
2484 {
2487 base_fndecls);
2488 }
2491 }
2493 /* If this declaration supersedes the declaration of
2494 a method declared virtual in the base class, then
2495 mark this field as being virtual as well. */
2497 void
2499 {
2502 /* In [temp.mem] we have:
2504 A specialization of a member function template does not
2505 override a virtual function from a base class. */
2512 /* Set DECL_VINDEX to a value that is neither an INTEGER_CST nor
2513 the error_mark_node so that we know it is an overriding
2514 function. */
2515 {
2518 }
2521 {
2527 }
2532 }
2534 /* Warn about hidden virtual functions that are not overridden in t.
2535 We know that constructors and destructors don't apply. */
2537 static void
2539 {
2541 tree fns;
2544 /* We go through each separately named virtual function. */
2548 {
2549 tree fn;
2550 tree name;
2551 tree fndecl;
2552 tree base_fndecls;
2553 tree base_binfo;
2554 tree binfo;
2557 /* All functions in this slot in the CLASSTYPE_METHOD_VEC will
2558 have the same name. Figure out what name that is. */
2560 /* There are no possibly hidden functions yet. */
2562 /* Iterate through all of the base classes looking for possibly
2563 hidden functions. */
2566 {
2569 base_fndecls);
2570 }
2572 /* If there are no functions to hide, continue. */
2576 /* Remove any overridden functions. */
2578 {
2581 {
2585 /* If the method from the base class has the same
2586 signature as the method from the derived class, it
2587 has been overridden. */
2590 else
2592 }
2593 }
2595 /* Now give a warning for all base functions without overriders,
2596 as they are hidden. */
2598 {
2599 /* Here we know it is a hider, and no overrider exists. */
2603 }
2604 }
2605 }
2607 /* Check for things that are invalid. There are probably plenty of other
2608 things we should check for also. */
2610 static void
2612 {
2613 tree field;
2616 {
2624 {
2628 {
2629 /* We're generally only interested in entities the user
2630 declared, but we also find nested classes by noticing
2631 the TYPE_DECL that we create implicitly. You're
2632 allowed to put one anonymous union inside another,
2633 though, so we explicitly tolerate that. We use
2634 TYPE_ANONYMOUS_P rather than ANON_AGGR_TYPE_P so that
2635 we also allow unnamed types used for defining fields. */
2642 {
2646 else
2650 }
2653 {
2656 else
2658 }
2660 {
2663 else
2665 }
2669 }
2670 }
2671 }
2672 }
2674 /* Add T to CLASSTYPE_DECL_LIST of current_class_type which
2675 will be used later during class template instantiation.
2676 When FRIEND_P is zero, T can be a static member data (VAR_DECL),
2677 a non-static member data (FIELD_DECL), a member function
2678 (FUNCTION_DECL), a nested type (RECORD_TYPE, ENUM_TYPE),
2679 a typedef (TYPE_DECL) or a member class template (TEMPLATE_DECL)
2680 When FRIEND_P is nonzero, T is either a friend class
2681 (RECORD_TYPE, TEMPLATE_DECL) or a friend function
2682 (FUNCTION_DECL, TEMPLATE_DECL). */
2684 void
2686 {
2687 /* Save some memory by not creating TREE_LIST if TYPE is not template. */
2692 }
2694 /* This function is called from declare_virt_assop_and_dtor via
2695 dfs_walk_all.
2697 DATA is a type that direcly or indirectly inherits the base
2698 represented by BINFO. If BINFO contains a virtual assignment [copy
2699 assignment or move assigment] operator or a virtual constructor,
2700 declare that function in DATA if it hasn't been already declared. */
2702 static tree
2704 {
2712 /* A base without a vtable needs no modification, and its bases
2713 are uninteresting. */
2717 /* If this is a primary base, then we have already looked at the
2718 virtual functions of its vtable. */
2722 {
2726 {
2731 }
2735 }
2738 }
2740 /* If the class type T has a direct or indirect base that contains a
2741 virtual assignment operator or a virtual destructor, declare that
2742 function in T if it hasn't been already declared. */
2744 static void
2746 {
2754 dfs_declare_virt_assop_and_dtor,
2756 }
2758 /* Create default constructors, assignment operators, and so forth for
2759 the type indicated by T, if they are needed. CANT_HAVE_CONST_CTOR,
2760 and CANT_HAVE_CONST_ASSIGNMENT are nonzero if, for whatever reason,
2761 the class cannot have a default constructor, copy constructor
2762 taking a const reference argument, or an assignment operator taking
2763 a const reference, respectively. */
2765 static void
2769 {
2777 /* Destructor. */
2779 {
2780 /* In general, we create destructors lazily. */
2785 /* But if this is a Java class, any non-trivial destructor is
2786 invalid, even if compiler-generated. Therefore, if the
2787 destructor is non-trivial we create it now. */
2789 }
2791 /* [class.ctor]
2793 If there is no user-declared constructor for a class, a default
2794 constructor is implicitly declared. */
2796 {
2801 /* This might force the declaration. */
2803 }
2805 /* [class.ctor]
2807 If a class definition does not explicitly declare a copy
2808 constructor, one is declared implicitly. */
2810 {
2816 }
2818 /* If there is no assignment operator, one will be created if and
2819 when it is needed. For now, just record whether or not the type
2820 of the parameter to the assignment operator will be a const or
2821 non-const reference. */
2823 {
2829 }
2831 /* We can't be lazy about declaring functions that might override
2832 a virtual function from a base class. */
2834 }
2836 /* Subroutine of insert_into_classtype_sorted_fields. Recursively
2837 count the number of fields in TYPE, including anonymous union
2838 members. */
2840 static int
2842 {
2843 tree x;
2846 {
2849 else
2851 }
2853 }
2855 /* Subroutine of insert_into_classtype_sorted_fields. Recursively add
2856 all the fields in the TREE_LIST FIELDS to the SORTED_FIELDS_TYPE
2857 elts, starting at offset IDX. */
2859 static int
2861 {
2862 tree x;
2864 {
2867 else
2869 }
2871 }
2873 /* Add all of the enum values of ENUMTYPE, to the FIELD_VEC elts,
2874 starting at offset IDX. */
2876 static int
2880 {
2881 tree values;
2885 }
2887 /* FIELD is a bit-field. We are finishing the processing for its
2888 enclosing type. Issue any appropriate messages and set appropriate
2889 flags. Returns false if an error has been diagnosed. */
2891 static bool
2893 {
2895 tree w;
2897 /* Extract the declared width of the bitfield, which has been
2898 temporarily stashed in DECL_INITIAL. */
2901 /* Remove the bit-field width indicator so that the rest of the
2902 compiler does not treat that value as an initializer. */
2905 /* Detect invalid bit-field type. */
2907 {
2910 }
2911 else
2912 {
2914 /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs. */
2917 /* detect invalid field size. */
2923 {
2926 }
2928 {
2931 }
2933 {
2936 }
2945 }
2948 {
2952 }
2953 else
2954 {
2955 /* Non-bit-fields are aligned for their type. */
2959 }
2960 }
2962 /* FIELD is a non bit-field. We are finishing the processing for its
2963 enclosing type T. Issue any appropriate messages and set appropriate
2964 flags. */
2966 static void
2968 tree t,
2972 {
2975 /* In C++98 an anonymous union cannot contain any fields which would change
2976 the settings of CANT_HAVE_CONST_CTOR and friends. */
2978 ;
2979 /* And, we don't set TYPE_HAS_CONST_COPY_CTOR, etc., for anonymous
2980 structs. So, we recurse through their fields here. */
2982 {
2983 tree fields;
2989 }
2990 /* Check members with class type for constructors, destructors,
2991 etc. */
2993 {
2994 /* Never let anything with uninheritable virtuals
2995 make it through without complaint. */
2999 {
3004 field);
3009 field);
3011 {
3015 }
3016 }
3017 else
3018 {
3031 }
3040 }
3042 {
3043 /* `build_class_init_list' does not recognize
3044 non-FIELD_DECLs. */
3048 }
3049 }
3051 /* Check the data members (both static and non-static), class-scoped
3052 typedefs, etc., appearing in the declaration of T. Issue
3053 appropriate diagnostics. Sets ACCESS_DECLS to a list (in
3054 declaration order) of access declarations; each TREE_VALUE in this
3055 list is a USING_DECL.
3057 In addition, set the following flags:
3059 EMPTY_P
3060 The class is empty, i.e., contains no non-static data members.
3062 CANT_HAVE_CONST_CTOR_P
3063 This class cannot have an implicitly generated copy constructor
3064 taking a const reference.
3066 CANT_HAVE_CONST_ASN_REF
3067 This class cannot have an implicitly generated assignment
3068 operator taking a const reference.
3070 All of these flags should be initialized before calling this
3071 function.
3073 Returns a pointer to the end of the TYPE_FIELDs chain; additional
3074 fields can be added by adding to this chain. */
3076 static void
3080 {
3088 /* Assume there are no access declarations. */
3090 /* Assume this class has no pointer members. */
3092 /* Assume none of the members of this class have default
3093 initializations. */
3097 {
3105 {
3106 /* Save the access declarations for our caller. */
3109 }
3115 /* If we've gotten this far, it's a data member, possibly static,
3116 or an enumerator. */
3119 /* When this goes into scope, it will be a non-local reference. */
3123 {
3124 /* [class.union]
3126 If a union contains a static data member, or a member of
3127 reference type, the program is ill-formed. */
3129 {
3132 }
3134 {
3139 }
3140 }
3142 /* Perform error checking that did not get done in
3143 grokdeclarator. */
3145 {
3149 }
3151 {
3155 }
3163 /* Now it can only be a FIELD_DECL. */
3168 /* If at least one non-static data member is non-literal, the whole
3169 class becomes non-literal. Note: if the type is incomplete we
3170 will complain later on. */
3174 /* A standard-layout class is a class that:
3175 ...
3176 has the same access control (Clause 11) for all non-static data members,
3177 ... */
3184 /* If this is of reference type, check if it needs an init. */
3186 {
3192 /* ARM $12.6.2: [A member initializer list] (or, for an
3193 aggregate, initialization by a brace-enclosed list) is the
3194 only way to initialize nonstatic const and reference
3195 members. */
3198 }
3203 {
3205 {
3206 warning
3209 x);
3211 }
3215 }
3218 /* We don't treat zero-width bitfields as making a class
3219 non-empty. */
3220 ;
3221 else
3222 {
3223 /* The class is non-empty. */
3225 /* The class is not even nearly empty. */
3227 /* If one of the data members contains an empty class,
3228 so does T. */
3232 }
3234 /* This is used by -Weffc++ (see below). Warn only for pointers
3235 to members which might hold dynamic memory. So do not warn
3236 for pointers to functions or pointers to members. */
3242 {
3247 }
3253 /* DR 148 now allows pointers to members (which are POD themselves),
3254 to be allowed in POD structs. */
3263 /* We set DECL_C_BIT_FIELD in grokbitfield.
3264 If the type and width are valid, we'll also set DECL_BIT_FIELD. */
3267 cant_have_const_ctor_p,
3268 no_const_asn_ref_p,
3271 /* Now that we've removed bit-field widths from DECL_INITIAL,
3272 anything left in DECL_INITIAL is an NSDMI that makes the class
3273 non-aggregate. */
3277 /* If any field is const, the structure type is pseudo-const. */
3279 {
3284 /* ARM $12.6.2: [A member initializer list] (or, for an
3285 aggregate, initialization by a brace-enclosed list) is the
3286 only way to initialize nonstatic const and reference
3287 members. */
3290 }
3291 /* A field that is pseudo-const makes the structure likewise. */
3293 {
3298 }
3300 /* Core issue 80: A nonstatic data member is required to have a
3301 different name from the class iff the class has a
3302 user-declared constructor. */
3306 }
3308 /* Effective C++ rule 11: if a class has dynamic memory held by pointers,
3309 it should also define a copy constructor and an assignment operator to
3310 implement the correct copy semantic (deep vs shallow, etc.). As it is
3311 not feasible to check whether the constructors do allocate dynamic memory
3312 and store it within members, we approximate the warning like this:
3314 -- Warn only if there are members which are pointers
3315 -- Warn only if there is a non-trivial constructor (otherwise,
3316 there cannot be memory allocated).
3317 -- Warn only if there is a non-trivial destructor. We assume that the
3318 user at least implemented the cleanup correctly, and a destructor
3319 is needed to free dynamic memory.
3321 This seems enough for practical purposes. */
3323 && has_pointers
3327 {
3331 {
3336 }
3340 }
3342 /* Non-static data member initializers make the default constructor
3343 non-trivial. */
3345 {
3348 }
3350 /* If any of the fields couldn't be packed, unset TYPE_PACKED. */
3354 /* Check anonymous struct/anonymous union fields. */
3357 /* We've built up the list of access declarations in reverse order.
3358 Fix that now. */
3360 }
3362 /* If TYPE is an empty class type, records its OFFSET in the table of
3363 OFFSETS. */
3365 static int
3367 {
3368 splay_tree_node n;
3373 /* Record the location of this empty object in OFFSETS. */
3381 type,
3385 }
3387 /* Returns nonzero if TYPE is an empty class type and there is
3388 already an entry in OFFSETS for the same TYPE as the same OFFSET. */
3390 static int
3392 {
3393 splay_tree_node n;
3394 tree t;
3399 /* Record the location of this empty object in OFFSETS. */
3409 }
3411 /* Walk through all the subobjects of TYPE (located at OFFSET). Call
3412 F for every subobject, passing it the type, offset, and table of
3413 OFFSETS. If VBASES_P is one, then virtual non-primary bases should
3414 be traversed.
3416 If MAX_OFFSET is non-NULL, then subobjects with an offset greater
3417 than MAX_OFFSET will not be walked.
3419 If F returns a nonzero value, the traversal ceases, and that value
3420 is returned. Otherwise, returns zero. */
3422 static int
3424 subobject_offset_fn f,
3425 tree offset,
3426 splay_tree offsets,
3427 tree max_offset,
3429 {
3433 /* If this OFFSET is bigger than the MAX_OFFSET, then we should
3434 stop. */
3442 {
3446 }
3449 {
3450 tree field;
3451 tree binfo;
3454 /* Avoid recursing into objects that are not interesting. */
3458 /* Record the location of TYPE. */
3463 /* Iterate through the direct base classes of TYPE. */
3467 {
3468 tree binfo_offset;
3481 offset,
3483 else
3484 {
3485 tree orig_binfo;
3486 /* We cannot rely on BINFO_OFFSET being set for the base
3487 class yet, but the offsets for direct non-virtual
3488 bases can be calculated by going back to the TYPE. */
3491 offset,
3493 }
3496 f,
3497 binfo_offset,
3498 offsets,
3499 max_offset,
3504 }
3507 {
3511 /* Iterate through the virtual base classes of TYPE. In G++
3512 3.2, we included virtual bases in the direct base class
3513 loop above, which results in incorrect results; the
3514 correct offsets for virtual bases are only known when
3515 working with the most derived type. */
3519 {
3521 f,
3523 offset,
3525 offsets,
3526 max_offset,
3530 }
3531 else
3532 {
3533 /* We still have to walk the primary base, if it is
3534 virtual. (If it is non-virtual, then it was walked
3535 above.) */
3541 {
3542 r = (walk_subobject_offsets
3547 }
3548 }
3549 }
3551 /* Iterate through the fields of TYPE. */
3554 {
3555 tree field_offset;
3559 else
3560 /* In G++ 3.2, DECL_FIELD_OFFSET was used. */
3564 f,
3566 offset,
3567 field_offset),
3568 offsets,
3569 max_offset,
3573 }
3574 }
3576 {
3579 tree index;
3581 /* Avoid recursing into objects that are not interesting. */
3586 /* Step through each of the elements in the array. */
3588 /* G++ 3.2 had an off-by-one error here. */
3593 {
3595 f,
3596 offset,
3597 offsets,
3598 max_offset,
3604 /* If this new OFFSET is bigger than the MAX_OFFSET, then
3605 there's no point in iterating through the remaining
3606 elements of the array. */
3609 }
3610 }
3613 }
3615 /* Record all of the empty subobjects of TYPE (either a type or a
3616 binfo). If IS_DATA_MEMBER is true, then a non-static data member
3617 is being placed at OFFSET; otherwise, it is a base class that is
3618 being placed at OFFSET. */
3620 static void
3622 tree offset,
3623 splay_tree offsets,
3625 {
3626 tree max_offset;
3627 /* If recording subobjects for a non-static data member or a
3628 non-empty base class , we do not need to record offsets beyond
3629 the size of the biggest empty class. Additional data members
3630 will go at the end of the class. Additional base classes will go
3631 either at offset zero (if empty, in which case they cannot
3632 overlap with offsets past the size of the biggest empty class) or
3633 at the end of the class.
3635 However, if we are placing an empty base class, then we must record
3636 all offsets, as either the empty class is at offset zero (where
3637 other empty classes might later be placed) or at the end of the
3638 class (where other objects might then be placed, so other empty
3639 subobjects might later overlap). */
3643 else
3647 }
3649 /* Returns nonzero if any of the empty subobjects of TYPE (located at
3650 OFFSET) conflict with entries in OFFSETS. If VBASES_P is nonzero,
3651 virtual bases of TYPE are examined. */
3653 static int
3655 tree offset,
3656 splay_tree offsets,
3658 {
3659 splay_tree_node max_node;
3661 /* Get the node in OFFSETS that indicates the maximum offset where
3662 an empty subobject is located. */
3664 /* If there aren't any empty subobjects, then there's no point in
3665 performing this check. */
3671 vbases_p);
3672 }
3674 /* DECL is a FIELD_DECL corresponding either to a base subobject of a
3675 non-static data member of the type indicated by RLI. BINFO is the
3676 binfo corresponding to the base subobject, OFFSETS maps offsets to
3677 types already located at those offsets. This function determines
3678 the position of the DECL. */
3680 static void
3682 tree decl,
3683 tree binfo,
3684 splay_tree offsets)
3685 {
3688 tree type;
3691 {
3692 /* For the purposes of determining layout conflicts, we want to
3693 use the class type of BINFO; TREE_TYPE (DECL) will be the
3694 CLASSTYPE_AS_BASE version, which does not contain entries for
3695 zero-sized bases. */
3698 }
3699 else
3700 {
3703 }
3705 /* Try to place the field. It may take more than one try if we have
3706 a hard time placing the field without putting two objects of the
3707 same type at the same address. */
3709 {
3712 /* Place this field. */
3716 /* We have to check to see whether or not there is already
3717 something of the same type at the offset we're about to use.
3718 For example, consider:
3720 struct S {};
3721 struct T : public S { int i; };
3722 struct U : public S, public T {};
3724 Here, we put S at offset zero in U. Then, we can't put T at
3725 offset zero -- its S component would be at the same address
3726 as the S we already allocated. So, we have to skip ahead.
3727 Since all data members, including those whose type is an
3728 empty class, have nonzero size, any overlap can happen only
3729 with a direct or indirect base-class -- it can't happen with
3730 a data member. */
3731 /* In a union, overlap is permitted; all members are placed at
3732 offset zero. */
3735 /* G++ 3.2 did not check for overlaps when placing a non-empty
3736 virtual base. */
3741 {
3742 /* Strip off the size allocated to this field. That puts us
3743 at the first place we could have put the field with
3744 proper alignment. */
3747 /* Bump up by the alignment required for the type. */
3748 rli->bitpos
3754 }
3755 else
3756 /* There was no conflict. We're done laying out this field. */
3758 }
3760 /* Now that we know where it will be placed, update its
3761 BINFO_OFFSET. */
3763 /* Indirect virtual bases may have a nonzero BINFO_OFFSET at
3764 this point because their BINFO_OFFSET is copied from another
3765 hierarchy. Therefore, we may not need to add the entire
3766 OFFSET. */
3772 }
3774 /* Returns true if TYPE is empty and OFFSET is nonzero. */
3776 static int
3778 tree offset,
3779 splay_tree offsets ATTRIBUTE_UNUSED)
3780 {
3782 }
3784 /* Layout the empty base BINFO. EOC indicates the byte currently just
3785 past the end of the class, and should be correctly aligned for a
3786 class of the type indicated by BINFO; OFFSETS gives the offsets of
3787 the empty bases allocated so far. T is the most derived
3788 type. Return nonzero iff we added it at the end. */
3790 static bool
3793 {
3794 tree alignment;
3798 /* This routine should only be used for empty classes. */
3803 {
3805 propagate_binfo_offsets
3808 else
3810 "offset of empty base %qT may not be ABI-compliant and may"
3813 }
3815 /* This is an empty base class. We first try to put it at offset
3816 zero. */
3819 offsets,
3821 {
3822 /* That didn't work. Now, we move forward from the next
3823 available spot in the class. */
3827 {
3830 offsets,
3832 /* We finally found a spot where there's no overlap. */
3835 /* There's overlap here, too. Bump along to the next spot. */
3837 }
3838 }
3841 {
3846 }
3849 }
3851 /* Layout the base given by BINFO in the class indicated by RLI.
3852 *BASE_ALIGN is a running maximum of the alignments of
3853 any base class. OFFSETS gives the location of empty base
3854 subobjects. T is the most derived type. Return nonzero if the new
3855 object cannot be nearly-empty. A new FIELD_DECL is inserted at
3856 *NEXT_FIELD, unless BINFO is for an empty base class.
3858 Returns the location at which the next field should be inserted. */
3863 {
3868 /* This error is now reported in xref_tag, thus giving better
3869 location information. */
3872 /* Place the base class. */
3874 {
3875 tree decl;
3877 /* The containing class is non-empty because it has a non-empty
3878 base class. */
3881 /* Create the FIELD_DECL. */
3888 {
3896 /* Try to place the field. It may take more than one try if we
3897 have a hard time placing the field without putting two
3898 objects of the same type at the same address. */
3900 /* Add the new FIELD_DECL to the list of fields for T. */
3904 }
3905 }
3906 else
3907 {
3908 tree eoc;
3911 /* On some platforms (ARM), even empty classes will not be
3912 byte-aligned. */
3917 /* A nearly-empty class "has no proper base class that is empty,
3918 not morally virtual, and at an offset other than zero." */
3920 {
3923 /* The check above (used in G++ 3.2) is insufficient because
3924 an empty class placed at offset zero might itself have an
3925 empty base at a nonzero offset. */
3927 empty_base_at_nonzero_offset_p,
3928 size_zero_node,
3932 {
3935 else
3937 "class %qT will be considered nearly empty in a "
3939 }
3940 }
3942 /* We do not create a FIELD_DECL for empty base classes because
3943 it might overlap some other field. We want to be able to
3944 create CONSTRUCTORs for the class by iterating over the
3945 FIELD_DECLs, and the back end does not handle overlapping
3946 FIELD_DECLs. */
3948 /* An empty virtual base causes a class to be non-empty
3949 -- but in that case we do not need to clear CLASSTYPE_EMPTY_P
3950 here because that was already done when the virtual table
3951 pointer was created. */
3952 }
3954 /* Record the offsets of BINFO and its base subobjects. */
3957 offsets,
3961 }
3963 /* Layout all of the non-virtual base classes. Record empty
3964 subobjects in OFFSETS. T is the most derived type. Return nonzero
3965 if the type cannot be nearly empty. The fields created
3966 corresponding to the base classes will be inserted at
3967 *NEXT_FIELD. */
3969 static void
3972 {
3973 /* Chain to hold all the new FIELD_DECLs which stand in for base class
3974 subobjects. */
3979 /* The primary base class is always allocated first. */
3984 /* Now allocate the rest of the bases. */
3986 {
3987 tree base_binfo;
3991 /* The primary base was already allocated above, so we don't
3992 need to allocate it again here. */
3996 /* Virtual bases are added at the end (a primary virtual base
3997 will have already been added). */
4003 }
4004 }
4006 /* Go through the TYPE_METHODS of T issuing any appropriate
4007 diagnostics, figuring out which methods override which other
4008 methods, and so forth. */
4010 static void
4012 {
4013 tree x;
4016 {
4020 /* The name of the field is the original field name
4021 Save this in auxiliary field for later overloading. */
4023 {
4027 }
4028 /* All user-provided destructors are non-trivial.
4029 Constructors and assignment ops are handled in
4030 grok_special_member_properties. */
4033 }
4034 }
4036 /* FN is a constructor or destructor. Clone the declaration to create
4037 a specialized in-charge or not-in-charge version, as indicated by
4038 NAME. */
4040 static tree
4042 {
4043 tree parms;
4044 tree clone;
4046 /* Copy the function. */
4048 /* Reset the function name. */
4051 /* Remember where this function came from. */
4053 /* Make it easy to find the CLONE given the FN. */
4057 /* If this is a template, do the rest on the DECL_TEMPLATE_RESULT. */
4059 {
4066 }
4069 /* There's no pending inline data for this function. */
4073 /* The base-class destructor is not virtual. */
4075 {
4079 }
4081 /* If there was an in-charge parameter, drop it from the function
4082 type. */
4084 {
4085 tree basetype;
4086 tree parmtypes;
4087 tree exceptions;
4092 /* Skip the `this' parameter. */
4094 /* Skip the in-charge parameter. */
4096 /* And the VTT parm, in a complete [cd]tor. */
4100 /* If this is subobject constructor or destructor, add the vtt
4101 parameter. */
4105 parmtypes);
4108 exceptions);
4112 }
4114 /* Copy the function parameters. */
4116 /* Remove the in-charge parameter. */
4118 {
4122 }
4123 /* And the VTT parm, in a complete [cd]tor. */
4125 {
4128 else
4129 {
4133 }
4134 }
4137 {
4140 }
4142 /* Create the RTL for this function. */
4150 }
4152 /* Implementation of DECL_CLONED_FUNCTION and DECL_CLONED_FUNCTION_P, do
4153 not invoke this function directly.
4155 For a non-thunk function, returns the address of the slot for storing
4156 the function it is a clone of. Otherwise returns NULL_TREE.
4158 If JUST_TESTING, looks through TEMPLATE_DECL and returns NULL if
4159 cloned_function is unset. This is to support the separate
4160 DECL_CLONED_FUNCTION and DECL_CLONED_FUNCTION_P modes; using the latter
4161 on a template makes sense, but not the former. */
4163 tree *
4165 {
4173 {
4174 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
4177 else
4178 #endif
4180 }
4185 else
4187 }
4189 /* Produce declarations for all appropriate clones of FN. If
4190 UPDATE_METHOD_VEC_P is nonzero, the clones are added to the
4191 CLASTYPE_METHOD_VEC as well. */
4193 void
4195 {
4196 tree clone;
4198 /* Avoid inappropriate cloning. */
4204 {
4205 /* For each constructor, we need two variants: an in-charge version
4206 and a not-in-charge version. */
4213 }
4214 else
4215 {
4218 /* For each destructor, we need three variants: an in-charge
4219 version, a not-in-charge version, and an in-charge deleting
4220 version. We clone the deleting version first because that
4221 means it will go second on the TYPE_METHODS list -- and that
4222 corresponds to the correct layout order in the virtual
4223 function table.
4225 For a non-virtual destructor, we do not build a deleting
4226 destructor. */
4228 {
4232 }
4239 }
4241 /* Note that this is an abstract function that is never emitted. */
4243 }
4245 /* DECL is an in charge constructor, which is being defined. This will
4246 have had an in class declaration, from whence clones were
4247 declared. An out-of-class definition can specify additional default
4248 arguments. As it is the clones that are involved in overload
4249 resolution, we must propagate the information from the DECL to its
4250 clones. */
4252 void
4254 {
4255 tree clone;
4259 {
4266 /* Skip the 'this' parameter. */
4282 {
4287 {
4288 /* A default parameter has been added. Adjust the
4289 clone's parameters. */
4293 tree type;
4298 {
4301 clone_parms);
4303 }
4306 clone_parms);
4315 }
4316 }
4318 }
4319 }
4321 /* For each of the constructors and destructors in T, create an
4322 in-charge and not-in-charge variant. */
4324 static void
4326 {
4327 tree fns;
4329 /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail
4330 out now. */
4338 }
4340 /* Deduce noexcept for a destructor DTOR. */
4342 void
4344 {
4346 {
4352 }
4353 }
4355 /* For each destructor in T, deduce noexcept:
4357 12.4/3: A declaration of a destructor that does not have an
4358 exception-specification is implicitly considered to have the
4359 same exception-specification as an implicit declaration (15.4). */
4361 static void
4363 {
4364 tree fns;
4366 /* If for some reason we don't have a CLASSTYPE_METHOD_VEC, we bail
4367 out now. */
4373 }
4375 /* Subroutine of set_one_vmethod_tm_attributes. Search base classes
4376 of TYPE for virtual functions which FNDECL overrides. Return a
4377 mask of the tm attributes found therein. */
4379 static int
4381 {
4383 tree base_binfo;
4387 {
4397 else
4399 }
4402 }
4404 /* Subroutine of set_method_tm_attributes. Handle the checks and
4405 inheritance for one virtual method FNDECL. */
4407 static void
4409 {
4410 tree tm_attr;
4415 /* If FNDECL doesn't actually override anything (i.e. T is the
4416 class that first declares FNDECL virtual), then we're done. */
4423 /* Intel STM Language Extension 3.0, Section 4.2 table 4:
4424 tm_pure must match exactly, otherwise no weakening of
4425 tm_safe > tm_callable > nothing. */
4426 /* ??? The tm_pure attribute didn't make the transition to the
4427 multivendor language spec. */
4429 {
4431 {
4434 }
4435 }
4436 /* If the overridden function is tm_pure, then FNDECL must be. */
4439 /* Look for base class combinations that cannot be satisfied. */
4441 {
4447 }
4448 /* If FNDECL did not declare an attribute, then inherit the most
4449 restrictive one. */
4451 {
4453 }
4454 /* Otherwise validate that we're not weaker than a function
4455 that is being overridden. */
4456 else
4457 {
4461 }
4464 err_override:
4468 }
4470 /* For each of the methods in T, propagate a class-level tm attribute. */
4472 static void
4474 {
4477 /* Don't bother collecting tm attributes if transactional memory
4478 support is not enabled. */
4482 /* Process virtual methods first, as they inherit directly from the
4483 base virtual function and also require validation of new attributes. */
4485 {
4486 tree vchain;
4489 {
4494 }
4495 }
4497 /* If the class doesn't have an attribute, nothing more to do. */
4502 /* Any method that does not yet have a tm attribute inherits
4503 the one from the class. */
4505 {
4508 }
4509 }
4511 /* Returns true iff class T has a user-defined constructor other than
4512 the default constructor. */
4514 bool
4516 {
4517 tree fns;
4523 {
4530 }
4533 }
4535 /* Returns the defaulted constructor if T has one. Otherwise, returns
4536 NULL_TREE. */
4538 tree
4540 {
4547 {
4551 {
4557 }
4558 }
4561 }
4563 /* Returns true iff FN is a user-provided function, i.e. user-declared
4564 and not defaulted at its first declaration; or explicit, private,
4565 protected, or non-const. */
4567 bool
4569 {
4572 else
4575 }
4577 /* Returns true iff class T has a user-provided constructor. */
4579 bool
4581 {
4582 tree fns;
4590 /* This can happen in error cases; avoid crashing. */
4599 }
4601 /* Returns true iff class T has a user-provided default constructor. */
4603 bool
4605 {
4606 tree fns;
4612 {
4618 }
4621 }
4623 /* If default-initialization leaves part of TYPE uninitialized, returns
4624 a DECL for the field or TYPE itself (DR 253). */
4626 tree
4628 {
4639 {
4643 }
4648 {
4652 }
4655 }
4657 /* Returns true iff for class T, a trivial synthesized default constructor
4658 would be constexpr. */
4660 bool
4662 {
4663 /* A defaulted trivial default constructor is constexpr
4664 if there is nothing to initialize. */
4667 }
4669 /* Returns true iff class T has a constexpr default constructor. */
4671 bool
4673 {
4674 tree fns;
4677 {
4678 /* The caller should have stripped an enclosing array. */
4681 }
4683 {
4686 /* Non-trivial, we need to check subobject constructors. */
4688 }
4691 }
4693 /* Returns true iff class TYPE has a virtual destructor. */
4695 bool
4697 {
4698 tree dtor;
4706 }
4708 /* Returns true iff class T has a move constructor. */
4710 bool
4712 {
4713 tree fns;
4716 {
4719 }
4729 }
4731 /* Returns true iff class T has a move assignment operator. */
4733 bool
4735 {
4736 tree fns;
4739 {
4742 }
4750 }
4752 /* Returns true iff class T has a move constructor that was explicitly
4753 declared in the class body. Note that this is different from
4754 "user-provided", which doesn't include functions that are defaulted in
4755 the class. */
4757 bool
4759 {
4760 tree fns;
4769 {
4773 }
4776 }
4778 /* Returns true iff class T has a move assignment operator that was
4779 explicitly declared in the class body. */
4781 bool
4783 {
4784 tree fns;
4791 {
4795 }
4798 }
4800 /* Nonzero if we need to build up a constructor call when initializing an
4801 object of this class, either because it has a user-provided constructor
4802 or because it doesn't have a default constructor (so we need to give an
4803 error if no initializer is provided). Use TYPE_NEEDS_CONSTRUCTING when
4804 what you care about is whether or not an object can be produced by a
4805 constructor (e.g. so we don't set TREE_READONLY on const variables of
4806 such type); use this function when what you care about is whether or not
4807 to try to call a constructor to create an object. The latter case is
4808 the former plus some cases of constructors that cannot be called. */
4810 bool
4812 {
4813 tree inner;
4819 }
4821 /* Remove all zero-width bit-fields from T. */
4823 static void
4825 {
4830 {
4833 /* We should not be confused by the fact that grokbitfield
4834 temporarily sets the width of the bit field into
4835 DECL_INITIAL (*fieldsp).
4836 check_bitfield_decl eventually sets DECL_SIZE (*fieldsp)
4837 to that width. */
4840 else
4842 }
4843 }
4845 /* Returns TRUE iff we need a cookie when dynamically allocating an
4846 array whose elements have the indicated class TYPE. */
4848 static bool
4850 {
4851 tree fns;
4856 /* If there's a non-trivial destructor, we need a cookie. In order
4857 to iterate through the array calling the destructor for each
4858 element, we'll have to know how many elements there are. */
4862 /* If the usual deallocation function is a two-argument whose second
4863 argument is of type `size_t', then we have to pass the size of
4864 the array to the deallocation function, so we will need to store
4865 a cookie. */
4869 /* If there are no `operator []' members, or the lookup is
4870 ambiguous, then we don't need a cookie. */
4873 /* Loop through all of the functions. */
4875 {
4876 tree fn;
4877 tree second_parm;
4879 /* Select the current function. */
4881 /* See if this function is a one-argument delete function. If
4882 it is, then it will be the usual deallocation function. */
4886 /* Do not consider this function if its second argument is an
4887 ellipsis. */
4890 /* Otherwise, if we have a two-argument function and the second
4891 argument is `size_t', it will be the usual deallocation
4892 function -- unless there is one-argument function, too. */
4896 }
4899 }
4901 /* Finish computing the `literal type' property of class type T.
4903 At this point, we have already processed base classes and
4904 non-static data members. We need to check whether the copy
4905 constructor is trivial, the destructor is trivial, and there
4906 is a trivial default constructor or at least one constexpr
4907 constructor other than the copy constructor. */
4909 static void
4911 {
4912 tree fn;
4928 {
4931 {
4935 }
4936 }
4937 }
4939 /* T is a non-literal type used in a context which requires a constant
4940 expression. Explain why it isn't literal. */
4942 void
4944 {
4954 /* Already explained. */
4963 {
4965 "default constructor, and has no constexpr constructor that "
4969 {
4970 /* Note that we can't simply call locate_ctor because when the
4971 constructor is deleted it just returns NULL_TREE. */
4972 tree fns;
4974 {
4981 {
4984 else
4987 }
4988 }
4989 }
4990 }
4991 else
4992 {
4996 {
4999 {
5004 }
5005 }
5007 {
5008 tree ftype;
5013 {
5018 }
5019 }
5020 }
5021 }
5023 /* Check the validity of the bases and members declared in T. Add any
5024 implicitly-generated functions (like copy-constructors and
5025 assignment operators). Compute various flag bits (like
5026 CLASSTYPE_NON_LAYOUT_POD_T) for T. This routine works purely at the C++
5027 level: i.e., independently of the ABI in use. */
5029 static void
5031 {
5032 /* Nonzero if the implicitly generated copy constructor should take
5033 a non-const reference argument. */
5035 /* Nonzero if the implicitly generated assignment operator
5036 should take a non-const reference argument. */
5038 tree access_decls;
5041 tree fn;
5043 /* By default, we use const reference arguments and generate default
5044 constructors. */
5048 /* Deduce noexcept on destructors. */
5052 /* Check all the base-classes. */
5056 /* Check all the method declarations. */
5059 /* Save the initial values of these flags which only indicate whether
5060 or not the class has user-provided functions. As we analyze the
5061 bases and members we can set these flags for other reasons. */
5065 /* Check all the data member declarations. We cannot call
5066 check_field_decls until we have called check_bases check_methods,
5067 as check_field_decls depends on TYPE_HAS_NONTRIVIAL_DESTRUCTOR
5068 being set appropriately. */
5073 /* A nearly-empty class has to be vptr-containing; a nearly empty
5074 class contains just a vptr. */
5078 /* Do some bookkeeping that will guide the generation of implicitly
5079 declared member functions. */
5082 /* We need to call a constructor for this class if it has a
5083 user-provided constructor, or if the default constructor is going
5084 to initialize the vptr. (This is not an if-and-only-if;
5085 TYPE_NEEDS_CONSTRUCTING is set elsewhere if bases or members
5086 themselves need constructing.) */
5089 /* [dcl.init.aggr]
5091 An aggregate is an array or a class with no user-provided
5092 constructors ... and no virtual functions.
5094 Again, other conditions for being an aggregate are checked
5095 elsewhere. */
5098 /* This is the C++98/03 definition of POD; it changed in C++0x, but we
5099 retain the old definition internally for ABI reasons. */
5108 /* If the class has no user-declared constructor, but does have
5109 non-static const or reference data members that can never be
5110 initialized, issue a warning. */
5112 /* Classes with user-declared constructors are presumed to
5113 initialize these members. */
5115 /* Aggregates can be initialized with brace-enclosed
5116 initializers. */
5118 {
5119 tree field;
5122 {
5123 tree type;
5137 }
5138 }
5140 /* Synthesize any needed methods. */
5142 cant_have_const_ctor,
5143 no_const_asn_ref);
5145 /* Check defaulted declarations here so we have cant_have_const_ctor
5146 and don't need to worry about clones. */
5149 {
5152 {
5153 bool imp_const_p
5159 /* If the function is defaulted outside the class, we just
5160 give the synthesis error. */
5163 }
5165 }
5168 {
5169 /* "The closure type associated with a lambda-expression has a deleted
5170 default constructor and a deleted copy assignment operator." */
5176 /* "This class type is not an aggregate." */
5178 }
5180 /* Compute the 'literal type' property before we
5181 do anything with non-static member functions. */
5184 /* Create the in-charge and not-in-charge variants of constructors
5185 and destructors. */
5188 /* Process the using-declarations. */
5192 /* Build and sort the CLASSTYPE_METHOD_VEC. */
5195 /* Figure out whether or not we will need a cookie when dynamically
5196 allocating an array of this type. */
5199 }
5201 /* If T needs a pointer to its virtual function table, set TYPE_VFIELD
5202 accordingly. If a new vfield was created (because T doesn't have a
5203 primary base class), then the newly created field is returned. It
5204 is not added to the TYPE_FIELDS list; it is the caller's
5205 responsibility to do that. Accumulate declared virtual functions
5206 on VIRTUALS_P. */
5208 static tree
5210 {
5211 tree fn;
5213 /* Collect the virtual functions declared in T. */
5217 {
5226 }
5228 /* If we couldn't find an appropriate base class, create a new field
5229 here. Even if there weren't any new virtual functions, we might need a
5230 new virtual function table if we're supposed to include vptrs in
5231 all classes that need them. */
5233 {
5234 /* We build this decl with vtbl_ptr_type_node, which is a
5235 `vtable_entry_type*'. It might seem more precise to use
5236 `vtable_entry_type (*)[N]' where N is the number of virtual
5237 functions. However, that would require the vtable pointer in
5238 base classes to have a different type than the vtable pointer
5239 in derived classes. We could make that happen, but that
5240 still wouldn't solve all the problems. In particular, the
5241 type-based alias analysis code would decide that assignments
5242 to the base class vtable pointer can't alias assignments to
5243 the derived class vtable pointer, since they have different
5244 types. Thus, in a derived class destructor, where the base
5245 class constructor was inlined, we could generate bad code for
5246 setting up the vtable pointer.
5248 Therefore, we use one type for all vtable pointers. We still
5249 use a type-correct type; it's just doesn't indicate the array
5250 bounds. That's better than using `void*' or some such; it's
5251 cleaner, and it let's the alias analysis code know that these
5252 stores cannot alias stores to void*! */
5253 tree field;
5266 /* This class is non-empty. */
5270 }
5273 }
5275 /* Add OFFSET to all base types of BINFO which is a base in the
5276 hierarchy dominated by T.
5278 OFFSET, which is a type offset, is number of bytes. */
5280 static void
5282 {
5284 tree primary_binfo;
5285 tree base_binfo;
5287 /* Update BINFO's offset. */
5292 offset));
5294 /* Find the primary base class. */
5300 /* Scan all of the bases, pushing the BINFO_OFFSET adjust
5301 downwards. */
5303 {
5304 /* Don't do the primary base twice. */
5312 }
5313 }
5315 /* Set BINFO_OFFSET for all of the virtual bases for RLI->T. Update
5316 TYPE_ALIGN and TYPE_SIZE for T. OFFSETS gives the location of
5317 empty subobjects of T. */
5319 static void
5321 {
5322 tree vbase;
5331 {
5332 /* In G++ 3.2, we incorrectly rounded the size before laying out
5333 the virtual bases. */
5335 #ifdef STRUCTURE_SIZE_BOUNDARY
5336 /* Packed structures don't need to have minimum size. */
5339 #endif
5343 }
5345 /* Find the last field. The artificial fields created for virtual
5346 bases will go after the last extant field to date. */
5351 /* Go through the virtual bases, allocating space for each virtual
5352 base that is not already a primary base class. These are
5353 allocated in inheritance graph order. */
5355 {
5360 {
5363 /* This virtual base is not a primary base of any class in the
5364 hierarchy, so we have to add space for it. */
5368 /* If the first virtual base might have been placed at a
5369 lower address, had we started from CLASSTYPE_SIZE, rather
5370 than TYPE_SIZE, issue a warning. There can be both false
5371 positives and false negatives from this warning in rare
5372 cases; to deal with all the possibilities would probably
5373 require performing both layout algorithms and comparing
5374 the results which is not particularly tractable. */
5376 && first_vbase
5377 && (tree_int_cst_lt
5382 bitsize_unit_node),
5385 "offset of virtual base %qT is not ABI-compliant and "
5387 basetype);
5390 }
5391 }
5392 }
5394 /* Returns the offset of the byte just past the end of the base class
5395 BINFO. */
5397 static tree
5399 {
5400 tree size;
5405 /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to
5406 allocate some space for it. It cannot have virtual bases, so
5407 TYPE_SIZE_UNIT is fine. */
5409 else
5413 }
5415 /* Returns the offset of the byte just past the end of the base class
5416 with the highest offset in T. If INCLUDE_VIRTUALS_P is zero, then
5417 only non-virtual bases are included. */
5419 static tree
5421 {
5424 tree binfo;
5425 tree base_binfo;
5426 tree offset;
5431 {
5441 }
5443 /* G++ 3.2 did not check indirect virtual bases. */
5447 {
5451 }
5454 }
5456 /* Warn about bases of T that are inaccessible because they are
5457 ambiguous. For example:
5459 struct S {};
5460 struct T : public S {};
5461 struct U : public S, public T {};
5463 Here, `(S*) new U' is not allowed because there are two `S'
5464 subobjects of U. */
5466 static void
5468 {
5471 tree basetype;
5472 tree binfo;
5473 tree base_binfo;
5475 /* If there are no repeated bases, nothing can be ambiguous. */
5479 /* Check direct bases. */
5482 {
5488 }
5490 /* Check for ambiguous virtual bases. */
5494 {
5500 }
5501 }
5503 /* Compare two INTEGER_CSTs K1 and K2. */
5505 static int
5507 {
5509 }
5511 /* Increase the size indicated in RLI to account for empty classes
5512 that are "off the end" of the class. */
5514 static void
5516 {
5517 tree eoc;
5518 tree rli_size;
5520 /* It might be the case that we grew the class to allocate a
5521 zero-sized base class. That won't be reflected in RLI, yet,
5522 because we are willing to overlay multiple bases at the same
5523 offset. However, now we need to make sure that RLI is big enough
5524 to reflect the entire class. */
5530 {
5532 /* In version 1 of the ABI, the size of a class that ends with
5533 a bitfield was not rounded up to a whole multiple of a
5534 byte. Because rli_size_unit_so_far returns only the number
5535 of fully allocated bytes, any extra bits were not included
5536 in the size. */
5538 else
5539 /* The size should have been rounded to a whole byte. */
5542 rli->bitpos
5551 }
5552 }
5554 /* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T. Calculate
5555 BINFO_OFFSETs for all of the base-classes. Position the vtable
5556 pointer. Accumulate declared virtual functions on VIRTUALS_P. */
5558 static void
5560 {
5561 tree non_static_data_members;
5562 tree field;
5563 tree vptr;
5564 record_layout_info rli;
5565 /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of
5566 types that appear at that offset. */
5567 splay_tree empty_base_offsets;
5568 /* True if the last field layed out was a bit-field. */
5570 /* The location at which the next field should be inserted. */
5572 /* T, as a base class. */
5573 tree base_t;
5575 /* Keep track of the first non-static data member. */
5578 /* Start laying out the record. */
5581 /* Mark all the primary bases in the hierarchy. */
5584 /* Create a pointer to our virtual function table. */
5587 /* The vptr is always the first thing in the class. */
5589 {
5594 }
5595 else
5598 /* Build FIELD_DECLs for all of the non-virtual base-types. */
5603 /* Layout the non-static data members. */
5605 {
5606 tree type;
5607 tree padding;
5609 /* We still pass things that aren't non-static data members to
5610 the back end, in case it wants to do something with them. */
5612 {
5614 /* If the static data member has incomplete type, keep track
5615 of it so that it can be completed later. (The handling
5616 of pending statics in finish_record_layout is
5617 insufficient; consider:
5619 struct S1;
5620 struct S2 { static S1 s1; };
5622 At this point, finish_record_layout will be called, but
5623 S1 is still incomplete.) */
5625 {
5627 /* The visibility of static data members is determined
5628 at their point of declaration, not their point of
5629 definition. */
5631 }
5633 }
5641 /* If this field is a bit-field whose width is greater than its
5642 type, then there are some special rules for allocating
5643 it. */
5646 {
5648 tree integer_type;
5650 /* We must allocate the bits as if suitably aligned for the
5651 longest integer type that fits in this many bits. type
5652 of the field. Then, we are supposed to use the left over
5653 bits as additional padding. */
5662 /* ITK now indicates a type that is too large for the
5663 field. We have to back up by one to find the largest
5664 type that fits. */
5665 do
5666 {
5671 /* Figure out how much additional padding is required. GCC
5672 3.2 always created a padding field, even if it had zero
5673 width. */
5676 {
5678 /* In a union, the padding field must have the full width
5679 of the bit-field; all fields start at offset zero. */
5681 else
5682 {
5685 "ABI-compliant and may change in a future "
5687 t);
5690 }
5691 }
5692 #ifdef PCC_BITFIELD_TYPE_MATTERS
5693 /* An unnamed bitfield does not normally affect the
5694 alignment of the containing class on a target where
5695 PCC_BITFIELD_TYPE_MATTERS. But, the C++ ABI does not
5696 make any exceptions for unnamed bitfields when the
5697 bitfields are longer than their types. Therefore, we
5698 temporarily give the field a name. */
5700 {
5703 }
5704 #endif
5709 empty_base_offsets);
5712 /* Now that layout has been performed, set the size of the
5713 field to the size of its declared type; the rest of the
5714 field is effectively invisible. */
5716 /* We must also reset the DECL_MODE of the field. */
5721 /* Versions of G++ before G++ 3.4 did not reset the
5722 DECL_MODE. */
5724 "the offset of %qD may not be ABI-compliant and may "
5726 }
5727 else
5729 empty_base_offsets);
5731 /* Remember the location of any empty classes in FIELD. */
5735 empty_base_offsets,
5738 /* If a bit-field does not immediately follow another bit-field,
5739 and yet it starts in the middle of a byte, we have failed to
5740 comply with the ABI. */
5743 /* The TREE_NO_WARNING flag gets set by Objective-C when
5744 laying out an Objective-C class. The ObjC ABI differs
5745 from the C++ ABI, and so we do not want a warning
5746 here. */
5748 && !last_field_was_bitfield
5751 bitsize_unit_node)))
5755 /* G++ used to use DECL_FIELD_OFFSET as if it were the byte
5756 offset of the field. */
5763 "classes to be placed at different locations in a "
5766 /* The middle end uses the type of expressions to determine the
5767 possible range of expression values. In order to optimize
5768 "x.i > 7" to "false" for a 2-bit bitfield "i", the middle end
5769 must be made aware of the width of "i", via its type.
5771 Because C++ does not have integer types of arbitrary width,
5772 we must (for the purposes of the front end) convert from the
5773 type assigned here to the declared type of the bitfield
5774 whenever a bitfield expression is used as an rvalue.
5775 Similarly, when assigning a value to a bitfield, the value
5776 must be converted to the type given the bitfield here. */
5778 {
5783 {
5790 }
5791 }
5793 /* If we needed additional padding after this field, add it
5794 now. */
5796 {
5797 tree padding_field;
5800 FIELD_DECL,
5801 NULL_TREE,
5802 char_type_node);
5809 NULL_TREE,
5810 empty_base_offsets);
5811 }
5814 }
5817 {
5818 /* Make sure that we are on a byte boundary so that the size of
5819 the class without virtual bases will always be a round number
5820 of bytes. */
5823 }
5825 /* G++ 3.2 does not allow virtual bases to be overlaid with tail
5826 padding. */
5830 /* Delete all zero-width bit-fields from the list of fields. Now
5831 that the type is laid out they are no longer important. */
5834 /* Create the version of T used for virtual bases. We do not use
5835 make_class_type for this version; this is an artificial type. For
5836 a POD type, we just reuse T. */
5838 {
5841 /* Set the size and alignment for the new type. In G++ 3.2, all
5842 empty classes were considered to have size zero when used as
5843 base classes. */
5845 {
5850 "layout of classes derived from empty class %qT "
5852 t);
5853 }
5854 else
5855 {
5856 tree eoc;
5858 /* If the ABI version is not at least two, and the last
5859 field was a bit-field, RLI may not be on a byte
5860 boundary. In particular, rli_size_unit_so_far might
5861 indicate the last complete byte, while rli_size_so_far
5862 indicates the total number of bits used. Therefore,
5863 rli_size_so_far, rather than rli_size_unit_so_far, is
5864 used to compute TYPE_SIZE_UNIT. */
5872 eoc);
5879 }
5883 /* Copy the fields from T. */
5887 {
5889 FIELD_DECL,
5899 }
5901 /* Record the base version of the type. */
5904 }
5905 else
5908 /* Every empty class contains an empty class. */
5912 /* Set the TYPE_DECL for this type to contain the right
5913 value for DECL_OFFSET, so that we can use it as part
5914 of a COMPONENT_REF for multiple inheritance. */
5917 /* Now fix up any virtual base class types that we left lying
5918 around. We must get these done before we try to lay out the
5919 virtual function table. As a side-effect, this will remove the
5920 base subobject fields. */
5923 /* Make sure that empty classes are reflected in RLI at this
5924 point. */
5927 /* Make sure not to create any structures with zero size. */
5933 /* If this is a non-POD, declaring it packed makes a difference to how it
5934 can be used as a field; don't let finalize_record_size undo it. */
5938 /* Let the back end lay out the type. */
5941 /* Warn about bases that can't be talked about due to ambiguity. */
5944 /* Now that we're done with layout, give the base fields the real types. */
5949 /* Clean up. */
5956 }
5958 /* Determine the "key method" for the class type indicated by TYPE,
5959 and set CLASSTYPE_KEY_METHOD accordingly. */
5961 void
5963 {
5964 tree method;
5967 || processing_template_decl
5972 /* The key method is the first non-pure virtual function that is not
5973 inline at the point of class definition. On some targets the
5974 key function may not be inline; those targets should not call
5975 this function until the end of the translation unit. */
5981 {
5984 }
5987 }
5990 /* Allocate and return an instance of struct sorted_fields_type with
5991 N fields. */
5995 {
6002 }
6005 /* Perform processing required when the definition of T (a class type)
6006 is complete. */
6008 void
6010 {
6011 tree x;
6012 /* A TREE_LIST. The TREE_VALUE of each node is a FUNCTION_DECL. */
6016 {
6021 }
6023 /* If this type was previously laid out as a forward reference,
6024 make sure we lay it out again. */
6028 /* Make assumptions about the class; we'll reset the flags if
6029 necessary. */
6035 /* Do end-of-class semantic processing: checking the validity of the
6036 bases and members and add implicitly generated methods. */
6039 /* Find the key method. */
6041 {
6042 /* The Itanium C++ ABI permits the key method to be chosen when
6043 the class is defined -- even though the key method so
6044 selected may later turn out to be an inline function. On
6045 some systems (such as ARM Symbian OS) the key method cannot
6046 be determined until the end of the translation unit. On such
6047 systems, we leave CLASSTYPE_KEY_METHOD set to NULL, which
6048 will cause the class to be added to KEYED_CLASSES. Then, in
6049 finish_file we will determine the key method. */
6053 /* If a polymorphic class has no key method, we may emit the vtable
6054 in every translation unit where the class definition appears. */
6057 }
6059 /* Layout the class itself. */
6062 /* We use the base type for trivial assignments, and hence it
6063 needs a mode. */
6068 /* If necessary, create the primary vtable for this class. */
6070 {
6071 /* We must enter these virtuals into the table. */
6075 /* Here we know enough to change the type of our virtual
6076 function table, but we will wait until later this function. */
6078 }
6081 {
6083 tree fn;
6090 /* Add entries for virtual functions introduced by this class. */
6094 /* Set DECL_VINDEX for all functions declared in this class. */
6096 fn;
6098 vindex += (TARGET_VTABLE_USES_DESCRIPTORS
6100 {
6104 /* A thunk. We should never be calling this entry directly
6105 from this vtable -- we'd use the entry for the non
6106 thunk base function. */
6110 }
6111 }
6116 /* Complete the rtl for any static member objects of the type we're
6117 working on. */
6124 /* Done with FIELDS...now decide whether to sort these for
6125 faster lookups later.
6127 We use a small number because most searches fail (succeeding
6128 ultimately as the search bores through the inheritance
6129 hierarchy), and we want this failure to occur quickly. */
6133 /* Complain if one of the field types requires lower visibility. */
6136 /* Make the rtl for any new vtables we have created, and unmark
6137 the base types we marked. */
6140 /* Build the VTT for T. */
6143 /* This warning does not make sense for Java classes, since they
6144 cannot have destructors. */
6146 {
6147 tree dtor;
6151 if it were virtual, we would have created it by now. */
6152 !dtor
6161 "%q#T has virtual functions and accessible"
6163 }
6170 /* Class layout, assignment of virtual table slots, etc., is now
6171 complete. Give the back end a chance to tweak the visibility of
6172 the class or perform any other required target modifications. */
6179 /* Finish debugging output for this type. */
6183 {
6186 {
6189 }
6191 {
6194 else
6195 {
6198 }
6200 }
6201 }
6202 }
6204 /* Insert FIELDS into T for the sorted case if the FIELDS count is
6205 equal to THRESHOLD or greater than THRESHOLD. */
6207 static void
6209 {
6212 {
6217 }
6218 }
6220 /* Insert lately defined enum ENUMTYPE into T for the sorted case. */
6222 void
6224 {
6227 {
6229 int n_fields
6240 }
6241 }
6243 /* When T was built up, the member declarations were added in reverse
6244 order. Rearrange them to declaration order. */
6246 void
6248 {
6249 tree next;
6250 tree prev;
6251 tree x;
6253 /* The following lists are all in reverse order. Put them in
6254 declaration order now. */
6258 /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
6259 reverse order, so we can't just use nreverse. */
6264 {
6268 }
6270 {
6274 }
6275 }
6277 tree
6279 {
6282 /* Now that we've got all the field declarations, reverse everything
6283 as necessary. */
6288 /* Nadger the current location so that diagnostics point to the start of
6289 the struct, not the end. */
6293 {
6294 tree x;
6300 /* We need to emit an error message if this type was used as a parameter
6301 and it is an abstract type, even if it is a template. We construct
6302 a simple CLASSTYPE_PURE_VIRTUALS list without taking bases into
6303 account and we call complete_vars with this type, which will check
6304 the PARM_DECLS. Note that while the type is being defined,
6305 CLASSTYPE_PURE_VIRTUALS contains the list of the inline friends
6306 (see CLASSTYPE_INLINE_FRIENDS) so we need to clear it. */
6312 /* We need to add the target functions to the CLASSTYPE_METHOD_VEC if
6313 an enclosing scope is a template class, so that this function be
6314 found by lookup_fnfields_1 when the using declaration is not
6315 instantiated yet. */
6318 {
6323 }
6325 /* Remember current #pragma pack value. */
6327 }
6328 else
6337 else
6344 }
6345 \f
6346 /* Return the dynamic type of INSTANCE, if known.
6347 Used to determine whether the virtual function table is needed
6348 or not.
6350 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
6351 of our knowledge of its type. *NONNULL should be initialized
6352 before this function is called. */
6354 static tree
6356 {
6357 #define RECUR(T) fixed_type_or_null((T), nonnull, cdtorp)
6360 {
6364 else
6368 /* This is a call to a constructor, hence it's never zero. */
6370 {
6374 }
6378 /* This is a call to a constructor, hence it's never zero. */
6380 {
6384 }
6393 /* Propagate nonnull. */
6398 CASE_CONVERT:
6404 {
6405 /* Just because we see an ADDR_EXPR doesn't mean we're dealing
6406 with a real object -- given &p->f, p can still be null. */
6408 /* ??? Probably should check DECL_WEAK here. */
6411 }
6415 /* If this component is really a base class reference, then the field
6416 itself isn't definitive. */
6425 {
6429 }
6430 /* fall through... */
6435 {
6439 }
6441 {
6445 /* if we're in a ctor or dtor, we know our type. If
6446 current_class_ptr is set but we aren't in a function, we're in
6447 an NSDMI (and therefore a constructor). */
6452 {
6456 }
6457 }
6459 {
6460 /* We only need one hash table because it is always left empty. */
6464 htab_hash_pointer,
6465 htab_eq_pointer,
6468 /* Reference variables should be references to objects. */
6472 /* Enter the INSTANCE in a table to prevent recursion; a
6473 variable's initializer may refer to the variable
6474 itself. */
6479 {
6480 tree type;
6489 }
6490 }
6495 }
6496 #undef RECUR
6497 }
6499 /* Return nonzero if the dynamic type of INSTANCE is known, and
6500 equivalent to the static type. We also handle the case where
6501 INSTANCE is really a pointer. Return negative if this is a
6502 ctor/dtor. There the dynamic type is known, but this might not be
6503 the most derived base of the original object, and hence virtual
6504 bases may not be layed out according to this type.
6506 Used to determine whether the virtual function table is needed
6507 or not.
6509 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
6510 of our knowledge of its type. *NONNULL should be initialized
6511 before this function is called. */
6513 int
6515 {
6518 tree fixed;
6521 {
6522 /* In a template we only care about the type of the result. */
6526 }
6536 }
6538 \f
6539 void
6541 {
6544 current_class_stack
6552 }
6554 /* Restore the cached PREVIOUS_CLASS_LEVEL. */
6556 static void
6558 {
6559 tree type;
6561 /* We are re-entering the same class we just left, so we don't
6562 have to search the whole inheritance matrix to find all the
6563 decls to bind again. Instead, we install the cached
6564 class_shadowed list and walk through it binding names. */
6567 /* Restore IDENTIFIER_TYPE_VALUE. */
6569 type;
6572 }
6574 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
6575 appropriate for TYPE.
6577 So that we may avoid calls to lookup_name, we cache the _TYPE
6578 nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
6580 For multiple inheritance, we perform a two-pass depth-first search
6581 of the type lattice. */
6583 void
6585 {
6586 class_stack_node_t csn;
6590 /* Make sure there is enough room for the new entry on the stack. */
6592 {
6594 current_class_stack
6596 current_class_stack_size);
6597 }
6599 /* Insert a new entry on the class stack. */
6606 current_class_depth++;
6608 /* Now set up the new type. */
6614 /* By default, things in classes are private, while things in
6615 structures or unions are public. */
6617 ? access_private_node
6623 {
6624 /* Forcibly remove any old class remnants. */
6626 }
6632 else
6634 }
6636 /* When we exit a toplevel class scope, we save its binding level so
6637 that we can restore it quickly. Here, we've entered some other
6638 class, so we must invalidate our cache. */
6640 void
6642 {
6644 }
6646 /* Get out of the current class scope. If we were in a class scope
6647 previously, that is the one popped to. */
6649 void
6651 {
6654 current_class_depth--;
6660 }
6662 /* Mark the top of the class stack as hidden. */
6664 void
6666 {
6669 }
6671 /* Mark the top of the class stack as un-hidden. */
6673 void
6675 {
6678 }
6680 /* Returns 1 if the class type currently being defined is either T or
6681 a nested type of T. */
6683 bool
6685 {
6693 /* We start looking from 1 because entry 0 is from global scope,
6694 and has no type. */
6696 {
6697 tree c;
6700 else
6701 {
6705 }
6710 }
6712 }
6714 /* If either current_class_type or one of its enclosing classes are derived
6715 from T, return the appropriate type. Used to determine how we found
6716 something via unqualified lookup. */
6718 tree
6720 {
6723 /* The bases of a dependent type are unknown. */
6734 {
6739 }
6742 }
6744 /* Returns the innermost class type which is not a lambda closure type. */
6746 tree
6748 {
6751 /* We start looking from 1 because entry 0 is from global scope,
6752 and has no type. */
6754 {
6755 tree c;
6758 else
6759 {
6763 }
6768 }
6770 }
6772 /* When entering a class scope, all enclosing class scopes' names with
6773 static meaning (static variables, static functions, types and
6774 enumerators) have to be visible. This recursive function calls
6775 pushclass for all enclosing class contexts until global or a local
6776 scope is reached. TYPE is the enclosed class. */
6778 void
6780 {
6781 /* A namespace might be passed in error cases, like A::B:C. */
6789 }
6791 /* Undoes a push_nested_class call. */
6793 void
6795 {
6801 }
6803 /* Returns the number of extern "LANG" blocks we are nested within. */
6805 int
6807 {
6809 }
6811 /* Set global variables CURRENT_LANG_NAME to appropriate value
6812 so that behavior of name-mangling machinery is correct. */
6814 void
6816 {
6820 {
6822 }
6824 {
6826 /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
6827 (See record_builtin_java_type in decl.c.) However, that causes
6828 incorrect debug entries if these types are actually used.
6829 So we re-enable debug output after extern "Java". */
6838 }
6840 {
6842 }
6843 else
6845 }
6847 /* Get out of the current language scope. */
6849 void
6851 {
6853 }
6854 \f
6855 /* Type instantiation routines. */
6857 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
6858 matches the TARGET_TYPE. If there is no satisfactory match, return
6859 error_mark_node, and issue an error & warning messages under
6860 control of FLAGS. Permit pointers to member function if FLAGS
6861 permits. If TEMPLATE_ONLY, the name of the overloaded function was
6862 a template-id, and EXPLICIT_TARGS are the explicitly provided
6863 template arguments.
6865 If OVERLOAD is for one or more member functions, then ACCESS_PATH
6866 is the base path used to reference those member functions. If
6867 TF_NO_ACCESS_CONTROL is not set in FLAGS, and the address is
6868 resolved to a member function, access checks will be performed and
6869 errors issued if appropriate. */
6871 static tree
6873 tree overload,
6874 tsubst_flags_t flags,
6876 tree explicit_targs,
6877 tree access_path)
6878 {
6879 /* Here's what the standard says:
6881 [over.over]
6883 If the name is a function template, template argument deduction
6884 is done, and if the argument deduction succeeds, the deduced
6885 arguments are used to generate a single template function, which
6886 is added to the set of overloaded functions considered.
6888 Non-member functions and static member functions match targets of
6889 type "pointer-to-function" or "reference-to-function." Nonstatic
6890 member functions match targets of type "pointer-to-member
6891 function;" the function type of the pointer to member is used to
6892 select the member function from the set of overloaded member
6893 functions. If a nonstatic member function is selected, the
6894 reference to the overloaded function name is required to have the
6895 form of a pointer to member as described in 5.3.1.
6897 If more than one function is selected, any template functions in
6898 the set are eliminated if the set also contains a non-template
6899 function, and any given template function is eliminated if the
6900 set contains a second template function that is more specialized
6901 than the first according to the partial ordering rules 14.5.5.2.
6902 After such eliminations, if any, there shall remain exactly one
6903 selected function. */
6906 /* We store the matches in a TREE_LIST rooted here. The functions
6907 are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
6908 interoperability with most_specialized_instantiation. */
6910 tree fn;
6911 tree target_fn_type;
6913 /* By the time we get here, we should be seeing only real
6914 pointer-to-member types, not the internal POINTER_TYPE to
6915 METHOD_TYPE representation. */
6921 /* Check that the TARGET_TYPE is reasonable. */
6925 /* This is OK, too. */
6928 /* This is OK, too. This comes from a conversion to reference
6929 type. */
6931 else
6932 {
6938 }
6940 /* Non-member functions and static member functions match targets of type
6941 "pointer-to-function" or "reference-to-function." Nonstatic member
6942 functions match targets of type "pointer-to-member-function;" the
6943 function type of the pointer to member is used to select the member
6944 function from the set of overloaded member functions.
6946 So figure out the FUNCTION_TYPE that we want to match against. */
6949 /* If we can find a non-template function that matches, we can just
6950 use it. There's no point in generating template instantiations
6951 if we're just going to throw them out anyhow. But, of course, we
6952 can only do this when we don't *need* a template function. */
6954 {
6955 tree fns;
6958 {
6962 /* We're not looking for templates just yet. */
6967 /* We're looking for a non-static member, and this isn't
6968 one, or vice versa. */
6971 /* Ignore functions which haven't been explicitly
6972 declared. */
6976 /* See if there's a match. */
6979 }
6980 }
6982 /* Now, if we've already got a match (or matches), there's no need
6983 to proceed to the template functions. But, if we don't have a
6984 match we need to look at them, too. */
6986 {
6987 tree target_arg_types;
6988 tree target_ret_type;
6989 tree fns;
6992 tree arg;
7006 {
7008 tree instantiation;
7009 tree targs;
7012 /* We're only looking for templates. */
7017 /* We're not looking for a non-static member, and this is
7018 one, or vice versa. */
7021 /* Try to do argument deduction. */
7026 /* Argument deduction failed. */
7029 /* Instantiate the template. */
7032 /* Instantiation failed. */
7035 /* See if there's a match. */
7038 }
7040 /* Now, remove all but the most specialized of the matches. */
7042 {
7047 NULL_TREE,
7048 NULL_TREE);
7049 }
7050 }
7052 /* Now we should have exactly one function in MATCHES. */
7054 {
7055 /* There were *no* matches. */
7057 {
7060 target_type);
7063 }
7065 }
7067 {
7068 /* There were too many matches. First check if they're all
7069 the same function. */
7070 tree match;
7078 {
7080 {
7083 target_type);
7085 /* Since print_candidates expects the functions in the
7086 TREE_VALUE slot, we flip them here. */
7091 }
7094 }
7095 }
7097 /* Good, exactly one match. Now, convert it to the correct type. */
7102 {
7110 {
7113 }
7114 }
7116 /* If we're doing overload resolution purely for the purpose of
7117 determining conversion sequences, we should not consider the
7118 function used. If this conversion sequence is selected, the
7119 function will be marked as used at this point. */
7121 {
7122 /* Make =delete work with SFINAE. */
7127 }
7129 /* We could not check access to member functions when this
7130 expression was originally created since we did not know at that
7131 time to which function the expression referred. */
7134 {
7137 }
7141 else
7142 {
7143 /* The target must be a REFERENCE_TYPE. Above, cp_build_unary_op
7144 will mark the function as addressed, but here we must do it
7145 explicitly. */
7149 }
7150 }
7152 /* This function will instantiate the type of the expression given in
7153 RHS to match the type of LHSTYPE. If errors exist, then return
7154 error_mark_node. FLAGS is a bit mask. If TF_ERROR is set, then
7155 we complain on errors. If we are not complaining, never modify rhs,
7156 as overload resolution wants to try many possible instantiations, in
7157 the hope that at least one will work.
7159 For non-recursive calls, LHSTYPE should be a function, pointer to
7160 function, or a pointer to member function. */
7162 tree
7164 {
7171 {
7175 }
7178 {
7184 /* Microsoft allows `A::f' to be resolved to a
7185 pointer-to-member. */
7186 ;
7187 else
7188 {
7193 }
7194 }
7197 {
7200 }
7202 /* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot
7203 deduce any type information. */
7205 {
7209 }
7211 /* There only a few kinds of expressions that may have a type
7212 dependent on overload resolution. */
7218 /* This should really only be used when attempting to distinguish
7219 what sort of a pointer to function we have. For now, any
7220 arithmetic operation which is not supported on pointers
7221 is rejected as an error. */
7224 {
7226 {
7232 /* Do not lose object's side effects. */
7236 }
7243 /* This can happen if we are forming a pointer-to-member for a
7244 member template. */
7247 /* Fall through. */
7250 {
7254 return
7258 }
7262 return
7266 access_path);
7269 {
7274 }
7281 }
7283 }
7284 \f
7285 /* Return the name of the virtual function pointer field
7286 (as an IDENTIFIER_NODE) for the given TYPE. Note that
7287 this may have to look back through base types to find the
7288 ultimate field name. (For single inheritance, these could
7289 all be the same name. Who knows for multiple inheritance). */
7291 static tree
7293 {
7300 {
7306 }
7314 }
7316 void
7318 {
7319 #ifdef GATHER_STATISTICS
7323 {
7328 }
7329 #endif
7330 }
7332 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
7333 according to [class]:
7334 The class-name is also inserted
7335 into the scope of the class itself. For purposes of access checking,
7336 the inserted class name is treated as if it were a public member name. */
7338 void
7340 {
7343 tree saved_cas;
7358 }
7360 /* Returns 1 if TYPE contains only padding bytes. */
7362 int
7364 {
7371 /* In G++ 3.2, whether or not a class was empty was determined by
7372 looking at its size. */
7375 else
7377 }
7379 /* Returns true if TYPE contains an empty class. */
7381 static bool
7383 {
7387 {
7388 tree field;
7389 tree binfo;
7390 tree base_binfo;
7402 }
7406 }
7408 /* Returns true if TYPE contains no actual data, just various
7409 possible combinations of empty classes and possibly a vptr. */
7411 bool
7413 {
7415 {
7416 tree field;
7417 tree binfo;
7418 tree base_binfo;
7421 /* CLASSTYPE_EMPTY_P isn't set properly until the class is actually laid
7422 out, but we'd like to be able to check this before then. */
7436 }
7440 }
7442 /* Note that NAME was looked up while the current class was being
7443 defined and that the result of that lookup was DECL. */
7445 void
7447 {
7448 splay_tree names_used;
7450 /* If we're not defining a class, there's nothing to do. */
7456 /* If there's already a binding for this NAME, then we don't have
7457 anything to worry about. */
7470 }
7472 /* Note that NAME was declared (as DECL) in the current class. Check
7473 to see that the declaration is valid. */
7475 void
7477 {
7478 splay_tree names_used;
7479 splay_tree_node n;
7481 /* Look to see if we ever used this name. */
7482 names_used
7486 /* The C language allows members to be declared with a type of the same
7487 name, and the C++ standard says this diagnostic is not required. So
7488 allow it in extern "C" blocks unless predantic is specified.
7489 Allow it in all cases if -ms-extensions is specified. */
7495 {
7496 /* [basic.scope.class]
7498 A name N used in a class S shall refer to the same declaration
7499 in its context and when re-evaluated in the completed scope of
7500 S. */
7504 }
7505 }
7507 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
7508 Secondary vtables are merged with primary vtables; this function
7509 will return the VAR_DECL for the primary vtable. */
7511 tree
7513 {
7514 tree decl;
7518 {
7521 }
7525 }
7528 /* Returns the binfo for the primary base of BINFO. If the resulting
7529 BINFO is a virtual base, and it is inherited elsewhere in the
7530 hierarchy, then the returned binfo might not be the primary base of
7531 BINFO in the complete object. Check BINFO_PRIMARY_P or
7532 BINFO_LOST_PRIMARY_P to be sure. */
7534 static tree
7536 {
7537 tree primary_base;
7544 }
7546 /* If INDENTED_P is zero, indent to INDENT. Return nonzero. */
7548 static int
7550 {
7554 }
7556 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
7557 INDENT should be zero when called from the top level; it is
7558 incremented recursively. IGO indicates the next expected BINFO in
7559 inheritance graph ordering. */
7561 static tree
7564 tree binfo,
7565 tree igo,
7567 {
7569 tree base_binfo;
7577 {
7580 }
7595 {
7599 TFF_PLAIN_IDENTIFIER),
7601 }
7603 {
7606 }
7611 {
7615 {
7619 TFF_PLAIN_IDENTIFIER));
7620 }
7622 {
7626 TFF_PLAIN_IDENTIFIER));
7627 }
7629 {
7633 TFF_PLAIN_IDENTIFIER));
7634 }
7636 {
7640 TFF_PLAIN_IDENTIFIER));
7641 }
7645 }
7651 }
7653 /* Dump the BINFO hierarchy for T. */
7655 static void
7657 {
7669 }
7671 /* Debug interface to hierarchy dumping. */
7673 void
7675 {
7677 }
7679 static void
7681 {
7686 {
7689 }
7690 }
7692 static void
7694 {
7695 tree value;
7697 HOST_WIDE_INT elt;
7705 TFF_PLAIN_IDENTIFIER));
7712 }
7714 static void
7716 {
7724 {
7731 {
7735 }
7739 }
7742 }
7744 static void
7746 {
7754 {
7759 }
7762 }
7764 /* Dump a function or thunk and its thunkees. */
7766 static void
7768 {
7771 tree thunks;
7779 {
7789 else
7795 }
7799 }
7801 /* Dump the thunks for FN. */
7803 void
7805 {
7807 }
7809 /* Virtual function table initialization. */
7811 /* Create all the necessary vtables for T and its base classes. */
7813 static void
7815 {
7816 tree vbase;
7820 /* We lay out the primary and secondary vtables in one contiguous
7821 vtable. The primary vtable is first, followed by the non-virtual
7822 secondary vtables in inheritance graph order. */
7826 /* Then come the virtual bases, also in inheritance graph order. */
7828 {
7832 }
7836 }
7838 /* Initialize the vtable for BINFO with the INITS. */
7840 static void
7842 {
7843 tree decl;
7849 }
7851 /* Build the VTT (virtual table table) for T.
7852 A class requires a VTT if it has virtual bases.
7854 This holds
7855 1 - primary virtual pointer for complete object T
7856 2 - secondary VTTs for each direct non-virtual base of T which requires a
7857 VTT
7858 3 - secondary virtual pointers for each direct or indirect base of T which
7859 has virtual bases or is reachable via a virtual path from T.
7860 4 - secondary VTTs for each direct or indirect virtual base of T.
7862 Secondary VTTs look like complete object VTTs without part 4. */
7864 static void
7866 {
7867 tree type;
7868 tree vtt;
7869 tree index;
7872 /* Build up the initializers for the VTT. */
7877 /* If we didn't need a VTT, we're done. */
7881 /* Figure out the type of the VTT. */
7885 /* Now, build the VTT object itself. */
7888 /* Add the VTT to the vtables list. */
7893 }
7895 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
7896 PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
7897 and CHAIN the vtable pointer for this binfo after construction is
7898 complete. VALUE can also be another BINFO, in which case we recurse. */
7900 static tree
7902 {
7903 tree vt;
7906 {
7912 else
7914 }
7917 }
7919 /* Data for secondary VTT initialization. */
7921 {
7922 /* Is this the primary VTT? */
7925 /* Current index into the VTT. */
7926 tree index;
7928 /* Vector of initializers built up. */
7931 /* The type being constructed by this secondary VTT. */
7932 tree type_being_constructed;
7935 /* Recursively build the VTT-initializer for BINFO (which is in the
7936 hierarchy dominated by T). INITS points to the end of the initializer
7937 list to date. INDEX is the VTT index where the next element will be
7938 replaced. Iff BINFO is the binfo for T, this is the top level VTT (i.e.
7939 not a subvtt for some base of T). When that is so, we emit the sub-VTTs
7940 for virtual bases of T. When it is not so, we build the constructor
7941 vtables for the BINFO-in-T variant. */
7943 static void
7945 {
7947 tree b;
7948 tree init;
7949 secondary_vptr_vtt_init_data data;
7952 /* We only need VTTs for subobjects with virtual bases. */
7956 /* We need to use a construction vtable if this is not the primary
7957 VTT. */
7959 {
7962 /* Record the offset in the VTT where this sub-VTT can be found. */
7964 }
7966 /* Add the address of the primary vtable for the complete object. */
7970 {
7973 }
7976 /* Recursively add the secondary VTTs for non-virtual bases. */
7981 /* Add secondary virtual pointers for all subobjects of BINFO with
7982 either virtual bases or reachable along a virtual path, except
7983 subobjects that are non-virtual primary bases. */
7993 /* data.inits might have grown as we added secondary virtual pointers.
7994 Make sure our caller knows about the new vector. */
7998 /* Add the secondary VTTs for virtual bases in inheritance graph
7999 order. */
8001 {
8006 }
8007 else
8008 /* Remove the ctor vtables we created. */
8010 }
8012 /* Called from build_vtt_inits via dfs_walk. BINFO is the binfo for the base
8013 in most derived. DATA is a SECONDARY_VPTR_VTT_INIT_DATA structure. */
8015 static tree
8017 {
8020 /* We don't care about bases that don't have vtables. */
8024 /* We're only interested in proper subobjects of the type being
8025 constructed. */
8029 /* We're only interested in bases with virtual bases or reachable
8030 via a virtual path from the type being constructed. */
8035 /* We're not interested in non-virtual primary bases. */
8039 /* Record the index where this secondary vptr can be found. */
8041 {
8046 {
8047 /* It's a primary virtual base, and this is not a
8048 construction vtable. Find the base this is primary of in
8049 the inheritance graph, and use that base's vtable
8050 now. */
8053 }
8054 }
8056 /* Add the initializer for the secondary vptr itself. */
8059 /* Advance the vtt index. */
8064 }
8066 /* Called from build_vtt_inits via dfs_walk. After building
8067 constructor vtables and generating the sub-vtt from them, we need
8068 to restore the BINFO_VTABLES that were scribbled on. DATA is the
8069 binfo of the base whose sub vtt was generated. */
8071 static tree
8073 {
8077 /* If this class has no vtable, none of its bases do. */
8081 /* This might be a primary base, so have no vtable in this
8082 hierarchy. */
8085 /* If we scribbled the construction vtable vptr into BINFO, clear it
8086 out now. */
8092 }
8094 /* Build the construction vtable group for BINFO which is in the
8095 hierarchy dominated by T. */
8097 static void
8099 {
8100 tree type;
8101 tree vtbl;
8102 tree id;
8103 tree vbase;
8106 /* See if we've already created this construction vtable group. */
8112 /* Build a version of VTBL (with the wrong type) for use in
8113 constructing the addresses of secondary vtables in the
8114 construction vtable group. */
8122 /* Add the vtables for each of our virtual bases using the vbase in T
8123 binfo. */
8125 vbase;
8127 {
8128 tree b;
8135 }
8137 /* Figure out the type of the construction vtable. */
8145 /* Initialize the construction vtable. */
8149 }
8151 /* Add the vtbl initializers for BINFO (and its bases other than
8152 non-virtual primaries) to the list of INITS. BINFO is in the
8153 hierarchy dominated by T. RTTI_BINFO is the binfo within T of
8154 the constructor the vtbl inits should be accumulated for. (If this
8155 is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
8156 ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
8157 BINFO is the active base equivalent of ORIG_BINFO in the inheritance
8158 graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
8159 but are not necessarily the same in terms of layout. */
8161 static void
8163 tree orig_binfo,
8164 tree rtti_binfo,
8165 tree vtbl,
8166 tree t,
8168 {
8170 tree base_binfo;
8175 /* If it doesn't have a vptr, we don't do anything. */
8179 /* If we're building a construction vtable, we're not interested in
8180 subobjects that don't require construction vtables. */
8186 /* Build the initializers for the BINFO-in-T vtable. */
8189 /* Walk the BINFO and its bases. We walk in preorder so that as we
8190 initialize each vtable we can figure out at what offset the
8191 secondary vtable lies from the primary vtable. We can't use
8192 dfs_walk here because we need to iterate through bases of BINFO
8193 and RTTI_BINFO simultaneously. */
8195 {
8196 /* Skip virtual bases. */
8202 inits);
8203 }
8204 }
8206 /* Called from accumulate_vtbl_inits. Adds the initializers for the
8207 BINFO vtable to L. */
8209 static void
8211 tree orig_binfo,
8212 tree rtti_binfo,
8213 tree orig_vtbl,
8214 tree t,
8216 {
8223 {
8224 /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
8225 primary virtual base. If it is not the same primary in
8226 the hierarchy of T, we'll need to generate a ctor vtable
8227 for it, to place at its location in T. If it is the same
8228 primary, we still need a VTT entry for the vtable, but it
8229 should point to the ctor vtable for the base it is a
8230 primary for within the sub-hierarchy of RTTI_BINFO.
8232 There are three possible cases:
8234 1) We are in the same place.
8235 2) We are a primary base within a lost primary virtual base of
8236 RTTI_BINFO.
8237 3) We are primary to something not a base of RTTI_BINFO. */
8239 tree b;
8242 /* First, look through the bases we are primary to for RTTI_BINFO
8243 or a virtual base. */
8246 {
8251 }
8252 /* If we run out of primary links, keep looking down our
8253 inheritance chain; we might be an indirect primary. */
8257 found:
8259 /* If we found RTTI_BINFO, this is case 1. If we found a virtual
8260 base B and it is a base of RTTI_BINFO, this is case 2. In
8261 either case, we share our vtable with LAST, i.e. the
8262 derived-most base within B of which we are a primary. */
8265 /* Just set our BINFO_VTABLE to point to LAST, as we may not have
8266 set LAST's BINFO_VTABLE yet. We'll extract the actual vptr in
8267 binfo_ctor_vtable after everything's been set up. */
8270 /* Otherwise, this is case 3 and we get our own. */
8271 }
8278 {
8279 tree index;
8282 /* Add the initializer for this vtable. */
8286 /* Figure out the position to which the VPTR should point. */
8292 }
8295 /* For a construction vtable, we can't overwrite BINFO_VTABLE.
8296 So, we make a TREE_LIST. Later, dfs_fixup_binfo_vtbls will
8297 straighten this out. */
8300 /* Throw away any unneeded intializers. */
8302 else
8303 /* For an ordinary vtable, set BINFO_VTABLE. */
8305 }
8309 /* Construct the initializer for BINFO's virtual function table. BINFO
8310 is part of the hierarchy dominated by T. If we're building a
8311 construction vtable, the ORIG_BINFO is the binfo we should use to
8312 find the actual function pointers to put in the vtable - but they
8313 can be overridden on the path to most-derived in the graph that
8314 ORIG_BINFO belongs. Otherwise,
8315 ORIG_BINFO should be the same as BINFO. The RTTI_BINFO is the
8316 BINFO that should be indicated by the RTTI information in the
8317 vtable; it will be a base class of T, rather than T itself, if we
8318 are building a construction vtable.
8320 The value returned is a TREE_LIST suitable for wrapping in a
8321 CONSTRUCTOR to use as the DECL_INITIAL for a vtable. If
8322 NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
8323 number of non-function entries in the vtable.
8325 It might seem that this function should never be called with a
8326 BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
8327 base is always subsumed by a derived class vtable. However, when
8328 we are building construction vtables, we do build vtables for
8329 primary bases; we need these while the primary base is being
8330 constructed. */
8332 static void
8334 tree orig_binfo,
8335 tree t,
8336 tree rtti_binfo,
8339 {
8340 tree v;
8341 vtbl_init_data vid;
8343 tree vbinfo;
8347 /* Initialize VID. */
8355 /* The first vbase or vcall offset is at index -3 in the vtable. */
8358 /* Add entries to the vtable for RTTI. */
8361 /* Create an array for keeping track of the functions we've
8362 processed. When we see multiple functions with the same
8363 signature, we share the vcall offsets. */
8365 /* Add the vcall and vbase offset entries. */
8368 /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
8369 build_vbase_offset_vtbl_entries. */
8374 /* If the target requires padding between data entries, add that now. */
8376 {
8382 /* Move data entries into their new positions and add padding
8383 after the new positions. Iterate backwards so we don't
8384 overwrite entries that we would need to process later. */
8387 ix--)
8388 {
8396 {
8401 null_pointer_node);
8402 }
8403 }
8404 }
8409 /* The initializers for virtual functions were built up in reverse
8410 order. Straighten them out and add them to the running list in one
8411 step. */
8421 /* Go through all the ordinary virtual functions, building up
8422 initializers. */
8424 {
8425 tree delta;
8426 tree vcall_index;
8433 {
8437 {
8440 }
8442 }
8444 /* If the only definition of this function signature along our
8445 primary base chain is from a lost primary, this vtable slot will
8446 never be used, so just zero it out. This is important to avoid
8447 requiring extra thunks which cannot be generated with the function.
8449 We first check this in update_vtable_entry_for_fn, so we handle
8450 restored primary bases properly; we also need to do it here so we
8451 zero out unused slots in ctor vtables, rather than filling them
8452 with erroneous values (though harmless, apart from relocation
8453 costs). */
8458 {
8459 /* Pull the offset for `this', and the function to call, out of
8460 the list. */
8467 /* You can't call an abstract virtual function; it's abstract.
8468 So, we replace these functions with __pure_virtual. */
8470 {
8473 {
8475 abort_fndecl_addr
8479 }
8480 }
8481 /* Likewise for deleted virtuals. */
8483 {
8488 NULL_TREE);
8492 }
8493 else
8494 {
8496 {
8500 }
8501 /* Take the address of the function, considering it to be of an
8502 appropriate generic type. */
8506 }
8507 }
8509 /* And add it to the chain of initializers. */
8511 {
8516 else
8518 {
8524 }
8525 }
8526 else
8528 }
8529 }
8531 /* Adds to vid->inits the initializers for the vbase and vcall
8532 offsets in BINFO, which is in the hierarchy dominated by T. */
8534 static void
8536 {
8537 tree b;
8539 /* If this is a derived class, we must first create entries
8540 corresponding to the primary base class. */
8545 /* Add the vbase entries for this base. */
8547 /* Add the vcall entries for this base. */
8549 }
8551 /* Returns the initializers for the vbase offset entries in the vtable
8552 for BINFO (which is part of the class hierarchy dominated by T), in
8553 reverse order. VBASE_OFFSET_INDEX gives the vtable index
8554 where the next vbase offset will go. */
8556 static void
8558 {
8559 tree vbase;
8560 tree t;
8561 tree non_primary_binfo;
8563 /* If there are no virtual baseclasses, then there is nothing to
8564 do. */
8570 /* We might be a primary base class. Go up the inheritance hierarchy
8571 until we find the most derived class of which we are a primary base:
8572 it is the offset of that which we need to use. */
8575 {
8576 tree b;
8578 /* If we have reached a virtual base, then it must be a primary
8579 base (possibly multi-level) of vid->binfo, or we wouldn't
8580 have called build_vcall_and_vbase_vtbl_entries for it. But it
8581 might be a lost primary, so just skip down to vid->binfo. */
8583 {
8586 }
8592 }
8594 /* Go through the virtual bases, adding the offsets. */
8596 vbase;
8598 {
8599 tree b;
8600 tree delta;
8605 /* Find the instance of this virtual base in the complete
8606 object. */
8609 /* If we've already got an offset for this virtual base, we
8610 don't need another one. */
8615 /* Figure out where we can find this vbase offset. */
8624 /* The vbase offset had better be the same. */
8627 /* The next vbase will come at a more negative offset. */
8631 /* The initializer is the delta from BINFO to this virtual base.
8632 The vbase offsets go in reverse inheritance-graph order, and
8633 we are walking in inheritance graph order so these end up in
8634 the right order. */
8641 }
8642 }
8644 /* Adds the initializers for the vcall offset entries in the vtable
8645 for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
8646 to VID->INITS. */
8648 static void
8650 {
8651 /* We only need these entries if this base is a virtual base. We
8652 compute the indices -- but do not add to the vtable -- when
8653 building the main vtable for a class. */
8656 /* If BINFO is RTTI_BINFO, then (since BINFO does not
8657 correspond to VID->DERIVED), we are building a primary
8658 construction virtual table. Since this is a primary
8659 virtual table, we do not need the vcall offsets for
8660 BINFO. */
8662 {
8663 /* We need a vcall offset for each of the virtual functions in this
8664 vtable. For example:
8666 class A { virtual void f (); };
8667 class B1 : virtual public A { virtual void f (); };
8668 class B2 : virtual public A { virtual void f (); };
8669 class C: public B1, public B2 { virtual void f (); };
8671 A C object has a primary base of B1, which has a primary base of A. A
8672 C also has a secondary base of B2, which no longer has a primary base
8673 of A. So the B2-in-C construction vtable needs a secondary vtable for
8674 A, which will adjust the A* to a B2* to call f. We have no way of
8675 knowing what (or even whether) this offset will be when we define B2,
8676 so we store this "vcall offset" in the A sub-vtable and look it up in
8677 a "virtual thunk" for B2::f.
8679 We need entries for all the functions in our primary vtable and
8680 in our non-virtual bases' secondary vtables. */
8682 /* If we are just computing the vcall indices -- but do not need
8683 the actual entries -- not that. */
8686 /* Now, walk through the non-virtual bases, adding vcall offsets. */
8688 }
8689 }
8691 /* Build vcall offsets, starting with those for BINFO. */
8693 static void
8695 {
8697 tree primary_binfo;
8698 tree base_binfo;
8700 /* Don't walk into virtual bases -- except, of course, for the
8701 virtual base for which we are building vcall offsets. Any
8702 primary virtual base will have already had its offsets generated
8703 through the recursion in build_vcall_and_vbase_vtbl_entries. */
8707 /* If BINFO has a primary base, process it first. */
8712 /* Add BINFO itself to the list. */
8715 /* Scan the non-primary bases of BINFO. */
8719 }
8721 /* Called from build_vcall_offset_vtbl_entries_r. */
8723 static void
8725 {
8726 /* Make entries for the rest of the virtuals. */
8728 {
8729 tree orig_fn;
8731 /* The ABI requires that the methods be processed in declaration
8732 order. G++ 3.2 used the order in the vtable. */
8734 orig_fn;
8738 }
8739 else
8740 {
8741 tree derived_virtuals;
8742 tree base_virtuals;
8743 tree orig_virtuals;
8744 /* If BINFO is a primary base, the most derived class which has
8745 BINFO as a primary base; otherwise, just BINFO. */
8746 tree non_primary_binfo;
8748 /* We might be a primary base class. Go up the inheritance hierarchy
8749 until we find the most derived class of which we are a primary base:
8750 it is the BINFO_VIRTUALS there that we need to consider. */
8753 {
8754 tree b;
8756 /* If we have reached a virtual base, then it must be vid->vbase,
8757 because we ignore other virtual bases in
8758 add_vcall_offset_vtbl_entries_r. In turn, it must be a primary
8759 base (possibly multi-level) of vid->binfo, or we wouldn't
8760 have called build_vcall_and_vbase_vtbl_entries for it. But it
8761 might be a lost primary, so just skip down to vid->binfo. */
8763 {
8767 }
8773 }
8776 /* For a ctor vtable we need the equivalent binfo within the hierarchy
8777 where rtti_binfo is the most derived type. */
8778 non_primary_binfo
8784 base_virtuals;
8788 {
8789 tree orig_fn;
8791 /* Find the declaration that originally caused this function to
8792 be present in BINFO_TYPE (binfo). */
8795 /* When processing BINFO, we only want to generate vcall slots for
8796 function slots introduced in BINFO. So don't try to generate
8797 one if the function isn't even defined in BINFO. */
8802 }
8803 }
8804 }
8806 /* Add a vcall offset entry for ORIG_FN to the vtable. */
8808 static void
8810 {
8812 tree vcall_offset;
8813 tree derived_entry;
8815 /* If there is already an entry for a function with the same
8816 signature as FN, then we do not need a second vcall offset.
8817 Check the list of functions already present in the derived
8818 class vtable. */
8820 {
8822 /* We only use one vcall offset for virtual destructors,
8823 even though there are two virtual table entries. */
8827 }
8829 /* If we are building these vcall offsets as part of building
8830 the vtable for the most derived class, remember the vcall
8831 offset. */
8833 {
8836 NULL);
8839 }
8841 /* The next vcall offset will be found at a more negative
8842 offset. */
8846 /* Keep track of this function. */
8850 {
8851 tree base;
8852 tree fn;
8854 /* Find the overriding function. */
8858 else
8859 {
8862 /* The vbase we're working on is a primary base of
8863 vid->binfo. But it might be a lost primary, so its
8864 BINFO_OFFSET might be wrong, so we just use the
8865 BINFO_OFFSET from vid->binfo. */
8871 vcall_offset);
8872 }
8873 /* Add the initializer to the vtable. */
8875 }
8876 }
8878 /* Return vtbl initializers for the RTTI entries corresponding to the
8879 BINFO's vtable. The RTTI entries should indicate the object given
8880 by VID->rtti_binfo. */
8882 static void
8884 {
8885 tree b;
8886 tree t;
8887 tree offset;
8888 tree decl;
8889 tree init;
8893 /* To find the complete object, we will first convert to our most
8894 primary base, and then add the offset in the vtbl to that value. */
8898 {
8899 tree primary_base;
8905 }
8909 /* The second entry is the address of the typeinfo object. */
8912 else
8915 /* Convert the declaration to a type that can be stored in the
8916 vtable. */
8920 /* Add the offset-to-top entry. It comes earlier in the vtable than
8921 the typeinfo entry. Convert the offset to look like a
8922 function pointer, so that we can put it in the vtable. */
8925 }