| blob | 0d4a40d4dbecd2e3167e6dcd155a341c7ab9ab75 |
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. */
329 {
334 }
336 /* If we're in an NSDMI, we don't have the full constructor context yet
337 that we need for converting to a virtual base, so just build a stub
338 CONVERT_EXPR and expand it later in bot_replace. */
341 {
347 }
349 /* Do we need to check for a null pointer? */
351 {
352 /* If we know the conversion will not actually change the value
353 of EXPR, then we can avoid testing the expression for NULL.
354 We have to avoid generating a COMPONENT_REF for a base class
355 field, because other parts of the compiler know that such
356 expressions are always non-NULL. */
360 }
362 /* Protect against multiple evaluation if necessary. */
366 /* Now that we've saved expr, build the real null test. */
368 {
372 }
374 /* If this is a simple base reference, express it as a COMPONENT_REF. */
376 /* We don't build base fields for empty bases, and they aren't very
377 interesting to the optimizers anyway. */
379 {
386 }
389 {
390 /* Going via virtual base V_BINFO. We need the static offset
391 from V_BINFO to BINFO, and the dynamic offset from D_BINFO to
392 V_BINFO. That offset is an entry in D_BINFO's vtable. */
393 tree v_offset;
396 {
397 /* In a base member initializer, we cannot rely on the
398 vtable being set up. We have to indirect via the
399 vtt_parm. */
400 tree t;
406 }
407 else
409 complain),
415 v_offset);
427 /* Negative fixed_type_p means this is a constructor or destructor;
428 virtual base layout is fixed in in-charge [cd]tors, but not in
429 base [cd]tors. */
433 v_offset,
436 else
438 }
446 {
451 }
452 else
458 out:
464 }
466 /* Subroutine of build_base_path; EXPR and BINFO are as in that function.
467 Perform a derived-to-base conversion by recursively building up a
468 sequence of COMPONENT_REFs to the appropriate base fields. */
470 static tree
472 {
475 tree field;
478 {
479 tree temp;
483 /* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x'
484 into `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only
485 an lvalue in the front end; only _DECLs and _REFs are lvalues
486 in the back end. */
492 }
494 /* Recurse. */
499 /* Is this the base field created by build_base_field? */
503 /* If we're looking for a field in the most-derived class,
504 also check the field offset; we can have two base fields
505 of the same type if one is an indirect virtual base and one
506 is a direct non-virtual base. */
510 {
511 /* We don't use build_class_member_access_expr here, as that
512 has unnecessary checks, and more importantly results in
513 recursive calls to dfs_walk_once. */
521 /* Mark the expression const or volatile, as appropriate.
522 Even though we've dealt with the type above, we still have
523 to mark the expression itself. */
530 }
532 /* Didn't find the base field?!? */
534 }
536 /* Convert OBJECT to the base TYPE. OBJECT is an expression whose
537 type is a class type or a pointer to a class type. In the former
538 case, TYPE is also a class type; in the latter it is another
539 pointer type. If CHECK_ACCESS is true, an error message is emitted
540 if TYPE is inaccessible. If OBJECT has pointer type, the value is
541 assumed to be non-NULL. */
543 tree
545 tsubst_flags_t complain)
546 {
547 tree binfo;
548 tree object_type;
549 base_access access;
552 {
555 }
556 else
563 access,
564 NULL);
569 }
571 /* EXPR is an expression with unqualified class type. BASE is a base
572 binfo of that class type. Returns EXPR, converted to the BASE
573 type. This function assumes that EXPR is the most derived class;
574 therefore virtual bases can be found at their static offsets. */
576 tree
578 {
579 tree expr_type;
583 {
584 /* If this is a non-empty base, use a COMPONENT_REF. */
588 /* We use fold_build2 and fold_convert below to simplify the trees
589 provided to the optimizers. It is not safe to call these functions
590 when processing a template because they do not handle C++-specific
591 trees. */
599 }
602 }
604 \f
605 tree
607 {
613 /* First, convert to the requested type. */
618 /* Second, the requested type may not be the owner of its own vptr.
619 If not, convert to the base class that owns it. We cannot use
620 convert_to_base here, because VCONTEXT may appear more than once
621 in the inheritance hierarchy of TYPE, and thus direct conversion
622 between the types may be ambiguous. Following the path back up
623 one step at a time via primary bases avoids the problem. */
627 {
630 }
633 }
635 /* Given an object INSTANCE, return an expression which yields the
636 vtable element corresponding to INDEX. There are many special
637 cases for INSTANCE which we take care of here, mainly to avoid
638 creating extra tree nodes when we don't have to. */
640 static tree
642 {
643 tree aref;
646 /* Try to figure out what a reference refers to, and
647 access its virtual function table directly. */
655 {
660 }
669 }
671 tree
673 {
677 }
679 /* Given a stable object pointer INSTANCE_PTR, return an expression which
680 yields a function pointer corresponding to vtable element INDEX. */
682 tree
684 {
685 tree aref;
688 tf_warning_or_error),
689 idx);
691 /* When using function descriptors, the address of the
692 vtable entry is treated as a function pointer. */
697 /* Remember this as a method reference, for later devirtualization. */
701 }
703 /* Return the name of the virtual function table (as an IDENTIFIER_NODE)
704 for the given TYPE. */
706 static tree
708 {
710 }
712 /* DECL is an entity associated with TYPE, like a virtual table or an
713 implicitly generated constructor. Determine whether or not DECL
714 should have external or internal linkage at the object file
715 level. This routine does not deal with COMDAT linkage and other
716 similar complexities; it simply sets TREE_PUBLIC if it possible for
717 entities in other translation units to contain copies of DECL, in
718 the abstract. */
720 void
722 {
725 }
727 /* Create a VAR_DECL for a primary or secondary vtable for CLASS_TYPE.
728 (For a secondary vtable for B-in-D, CLASS_TYPE should be D, not B.)
729 Use NAME for the name of the vtable, and VTABLE_TYPE for its type. */
731 static tree
733 {
734 tree decl;
737 /* vtable names are already mangled; give them their DECL_ASSEMBLER_NAME
738 now to avoid confusion in mangle_decl. */
747 /* At one time the vtable info was grabbed 2 words at a time. This
748 fails on sparc unless you have 8-byte alignment. (tiemann) */
752 /* The vtable has not been defined -- yet. */
756 /* Mark the VAR_DECL node representing the vtable itself as a
757 "gratuitous" one, thereby forcing dwarfout.c to ignore it. It
758 is rather important that such things be ignored because any
759 effort to actually generate DWARF for them will run into
760 trouble when/if we encounter code like:
762 #pragma interface
763 struct S { virtual void member (); };
765 because the artificial declaration of the vtable itself (as
766 manufactured by the g++ front end) will say that the vtable is
767 a static member of `S' but only *after* the debug output for
768 the definition of `S' has already been output. This causes
769 grief because the DWARF entry for the definition of the vtable
770 will try to refer back to an earlier *declaration* of the
771 vtable as a static member of `S' and there won't be one. We
772 might be able to arrange to have the "vtable static member"
773 attached to the member list for `S' before the debug info for
774 `S' get written (which would solve the problem) but that would
775 require more intrusive changes to the g++ front end. */
779 }
781 /* Get the VAR_DECL of the vtable for TYPE. TYPE need not be polymorphic,
782 or even complete. If this does not exist, create it. If COMPLETE is
783 nonzero, then complete the definition of it -- that will render it
784 impossible to actually build the vtable, but is useful to get at those
785 which are known to exist in the runtime. */
787 tree
789 {
790 tree decl;
799 {
802 }
805 }
807 /* Build the primary virtual function table for TYPE. If BINFO is
808 non-NULL, build the vtable starting with the initial approximation
809 that it is the same as the one which is the head of the association
810 list. Returns a nonzero value if a new vtable is actually
811 created. */
813 static int
815 {
816 tree decl;
817 tree virtuals;
822 {
824 /* We have already created a vtable for this base, so there's
825 no need to do it again. */
832 }
833 else
834 {
837 }
839 #ifdef GATHER_STATISTICS
842 #endif
844 /* Initialize the association list for this type, based
845 on our first approximation. */
850 }
852 /* Give BINFO a new virtual function table which is initialized
853 with a skeleton-copy of its original initialization. The only
854 entry that changes is the `delta' entry, so we can really
855 share a lot of structure.
857 FOR_TYPE is the most derived type which caused this table to
858 be needed.
860 Returns nonzero if we haven't met BINFO before.
862 The order in which vtables are built (by calling this function) for
863 an object must remain the same, otherwise a binary incompatibility
864 can result. */
866 static int
868 {
870 /* We already created a vtable for this base. There's no need to
871 do it again. */
874 /* Remember that we've created a vtable for this BINFO, so that we
875 don't try to do so again. */
878 /* Make fresh virtual list, so we can smash it later. */
881 /* Secondary vtables are laid out as part of the same structure as
882 the primary vtable. */
885 }
887 /* Create a new vtable for BINFO which is the hierarchy dominated by
888 T. Return nonzero if we actually created a new vtable. */
890 static int
892 {
894 /* In this case, it is *type*'s vtable we are modifying. We start
895 with the approximation that its vtable is that of the
896 immediate base class. */
898 else
899 /* This is our very own copy of `basetype' to play with. Later,
900 we will fill in all the virtual functions that override the
901 virtual functions in these base classes which are not defined
902 by the current type. */
904 }
906 /* Make *VIRTUALS, an entry on the BINFO_VIRTUALS list for BINFO
907 (which is in the hierarchy dominated by T) list FNDECL as its
908 BV_FN. DELTA is the required constant adjustment from the `this'
909 pointer where the vtable entry appears to the `this' required when
910 the function is actually called. */
912 static void
914 tree binfo,
915 tree fndecl,
916 tree delta,
918 {
919 tree v;
925 {
926 /* We need a new vtable for BINFO. */
928 {
929 /* If we really did make a new vtable, we also made a copy
930 of the BINFO_VIRTUALS list. Now, we have to find the
931 corresponding entry in that list. */
936 }
941 }
942 }
944 \f
945 /* Add method METHOD to class TYPE. If USING_DECL is non-null, it is
946 the USING_DECL naming METHOD. Returns true if the method could be
947 added to the method vec. */
949 bool
951 {
953 tree overload;
959 tree current_fns;
960 tree fns;
973 {
974 /* Make a new method vector. We start with 8 entries. We must
975 allocate at least two (for constructors and destructors), and
976 we're going to end up with an assignment operator at some
977 point as well. */
979 /* Create slots for constructors and destructors. */
983 }
985 /* Maintain TYPE_HAS_USER_CONSTRUCTOR, etc. */
988 /* Constructors and destructors go in special slots. */
992 {
996 {
1002 type);
1003 }
1004 }
1005 else
1006 {
1007 tree m;
1010 /* See if we already have an entry with this name. */
1014 {
1017 {
1022 }
1026 {
1029 }
1034 }
1035 }
1038 /* Check to see if we've already got this method. */
1040 {
1042 tree fn_type;
1043 tree method_type;
1044 tree parms1;
1045 tree parms2;
1050 /* [over.load] Member function declarations with the
1051 same name and the same parameter types cannot be
1052 overloaded if any of them is a static member
1053 function declaration.
1055 [namespace.udecl] When a using-declaration brings names
1056 from a base class into a derived class scope, member
1057 functions in the derived class override and/or hide member
1058 functions with the same name and parameter types in a base
1059 class (rather than conflicting). */
1065 /* Compare the quals on the 'this' parm. Don't compare
1066 the whole types, as used functions are treated as
1067 coming from the using class in overload resolution. */
1076 /* For templates, the return type and template parameters
1077 must be identical. */
1094 {
1096 {
1098 /* Defer to the local function. */
1100 }
1101 else
1102 {
1105 }
1107 /* We don't call duplicate_decls here to merge the
1108 declarations because that will confuse things if the
1109 methods have inline definitions. In particular, we
1110 will crash while processing the definitions. */
1112 }
1113 }
1115 /* A class should never have more than one destructor. */
1119 /* Add the new binding. */
1121 {
1124 }
1125 else
1134 {
1137 /* We only expect to add few methods in the COMPLETE_P case, so
1138 just make room for one more method in that case. */
1141 else
1147 else
1149 }
1150 else
1151 /* Replace the current slot. */
1154 }
1156 /* Subroutines of finish_struct. */
1158 /* Change the access of FDECL to ACCESS in T. Return 1 if change was
1159 legit, otherwise return 0. */
1161 static int
1163 {
1164 tree elem;
1173 {
1175 {
1179 else
1182 }
1183 else
1184 {
1185 /* They're changing the access to the same thing they changed
1186 it to before. That's OK. */
1187 ;
1188 }
1189 }
1190 else
1191 {
1195 }
1197 }
1199 /* Process the USING_DECL, which is a member of T. */
1201 static void
1203 {
1206 tree access
1211 tree old_value;
1216 tf_warning_or_error);
1218 {
1224 else
1226 }
1234 ;
1236 {
1238 /* It's OK to use functions from a base when there are functions with
1240 else
1241 {
1246 }
1247 }
1249 {
1253 }
1255 /* Make type T see field decl FDECL with access ACCESS. */
1258 {
1261 }
1262 else
1264 }
1265 \f
1266 /* Run through the base classes of T, updating CANT_HAVE_CONST_CTOR_P,
1267 and NO_CONST_ASN_REF_P. Also set flag bits in T based on
1268 properties of the bases. */
1270 static void
1274 {
1278 tree base_binfo;
1279 tree binfo;
1289 {
1298 /* If any base class is non-literal, so is the derived class. */
1302 /* Effective C++ rule 14. We only need to check TYPE_POLYMORPHIC_P
1303 here because the case of virtual functions but non-virtual
1304 dtor is handled in finish_struct_1. */
1309 /* If the base class doesn't have copy constructors or
1310 assignment operators that take const references, then the
1311 derived class cannot have such a member automatically
1312 generated. */
1321 /* A virtual base does not effect nearly emptiness. */
1322 ;
1324 {
1326 /* And if there is more than one nearly empty base, then the
1327 derived class is not nearly empty either. */
1329 else
1330 /* Remember we've seen one. */
1332 }
1334 /* If the base class is not empty or nearly empty, then this
1335 class cannot be nearly empty. */
1338 /* A lot of properties from the bases also apply to the derived
1339 class. */
1357 /* A standard-layout class is a class that:
1358 ...
1359 * has no non-standard-layout base classes, */
1362 {
1363 tree basefield;
1364 /* ...has no base classes of the same type as the first non-static
1365 data member... */
1367 && (same_type_ignoring_top_level_qualifiers_p
1370 else
1371 /* ...either has no non-static data members in the most-derived
1372 class and at most one base class with non-static data
1373 members, or has no base classes with non-static data
1374 members */
1378 {
1381 else
1384 }
1385 }
1387 /* Don't bother collecting tm attributes if transactional memory
1388 support is not enabled. */
1390 {
1394 }
1395 }
1397 /* If one of the base classes had TM attributes, and the current class
1398 doesn't define its own, then the current class inherits one. */
1400 {
1403 }
1404 }
1406 /* Determine all the primary bases within T. Sets BINFO_PRIMARY_BASE_P for
1407 those that are primaries. Sets BINFO_LOST_PRIMARY_P for those
1408 that have had a nearly-empty virtual primary base stolen by some
1409 other base in the hierarchy. Determines CLASSTYPE_PRIMARY_BASE for
1410 T. */
1412 static void
1414 {
1418 tree base_binfo;
1420 /* Determine the primary bases of our bases. */
1423 {
1426 /* See if we're the non-virtual primary of our inheritance
1427 chain. */
1429 {
1436 /* We are the primary binfo. */
1438 }
1439 /* Determine if we have a virtual primary base, and mark it so.
1440 */
1442 {
1446 /* Someone already claimed this base. */
1448 else
1449 {
1450 tree delta;
1455 /* A virtual binfo might have been copied from within
1456 another hierarchy. As we're about to use it as a
1457 primary base, make sure the offsets match. */
1465 }
1466 }
1467 }
1469 /* First look for a dynamic direct non-virtual base. */
1471 {
1475 {
1478 }
1479 }
1481 /* A "nearly-empty" virtual base class can be the primary base
1482 class, if no non-virtual polymorphic base can be found. Look for
1483 a nearly-empty virtual dynamic base that is not already a primary
1484 base of something in the hierarchy. If there is no such base,
1485 just pick the first nearly-empty virtual base. */
1491 {
1493 {
1494 /* Found one that is not primary. */
1497 }
1499 /* Remember the first candidate. */
1501 }
1503 found:
1504 /* If we've got a primary base, use it. */
1506 {
1511 /* We are stealing a primary base. */
1515 {
1516 tree delta;
1519 /* A virtual binfo might have been copied from within
1520 another hierarchy. As we're about to use it as a primary
1521 base, make sure the offsets match. */
1526 }
1533 }
1534 }
1536 /* Update the variant types of T. */
1538 void
1540 {
1541 tree variants;
1547 variants;
1549 {
1550 /* These fields are in the _TYPE part of the node, not in
1551 the TYPE_LANG_SPECIFIC component, so they are not shared. */
1561 /* Copy whatever these are holding today. */
1565 }
1566 }
1568 /* Early variant fixups: we apply attributes at the beginning of the class
1569 definition, and we need to fix up any variants that have already been
1570 made via elaborated-type-specifier so that check_qualified_type works. */
1572 void
1574 {
1575 tree variants;
1581 variants;
1583 {
1584 /* These are the two fields that check_qualified_type looks at and
1585 are affected by attributes. */
1588 }
1589 }
1590 \f
1591 /* Set memoizing fields and bits of T (and its variants) for later
1592 use. */
1594 static void
1596 {
1597 /* Fix up variants (if any). */
1601 /* For a class w/o baseclasses, 'finish_struct' has set
1602 CLASSTYPE_PURE_VIRTUALS correctly (by definition).
1603 Similarly for a class whose base classes do not have vtables.
1604 When neither of these is true, we might have removed abstract
1605 virtuals (by providing a definition), added some (by declaring
1606 new ones), or redeclared ones from a base class. We need to
1607 recalculate what's really an abstract virtual at this point (by
1608 looking in the vtables). */
1611 /* If this type has a copy constructor or a destructor, force its
1612 mode to be BLKmode, and force its TREE_ADDRESSABLE bit to be
1613 nonzero. This will cause it to be passed by invisible reference
1614 and prevent it from being returned in a register. */
1617 {
1618 tree variants;
1621 {
1624 }
1625 }
1626 }
1628 /* Issue warnings about T having private constructors, but no friends,
1629 and so forth.
1631 HAS_NONPRIVATE_METHOD is nonzero if T has any non-private methods or
1632 static members. HAS_NONPRIVATE_STATIC_FN is nonzero if T has any
1633 non-private static member functions. */
1635 static void
1637 {
1640 tree fn;
1643 /* If the class has friends, those entities might create and
1644 access instances, so we should not warn. */
1647 /* We will have warned when the template was declared; there's
1648 no need to warn on every instantiation. */
1650 /* There's no reason to even consider warning about this
1651 class. */
1654 /* We only issue one warning, if more than one applies, because
1655 otherwise, on code like:
1657 class A {
1658 // Oops - forgot `public:'
1659 A();
1660 A(const A&);
1661 ~A();
1662 };
1664 we warn several times about essentially the same problem. */
1666 /* Check to see if all (non-constructor, non-destructor) member
1667 functions are private. (Since there are no friends or
1668 non-private statics, we can't ever call any of the private member
1669 functions.) */
1671 /* We're not interested in compiler-generated methods; they don't
1672 provide any way to call private members. */
1674 {
1676 {
1678 /* A non-private static member function is just like a
1679 friend; it can create and invoke private member
1680 functions, and be accessed without a class
1681 instance. */
1685 /* Keep searching for a static member function. */
1686 }
1689 }
1692 {
1693 /* There are no non-private methods, and there's at least one
1694 private member function that isn't a constructor or
1695 destructor. (If all the private members are
1696 constructors/destructors we want to use the code below that
1697 issues error messages specifically referring to
1698 constructors/destructors.) */
1704 {
1707 }
1709 {
1713 }
1714 }
1716 /* Even if some of the member functions are non-private, the class
1717 won't be useful for much if all the constructors or destructors
1718 are private: such an object can never be created or destroyed. */
1721 {
1724 t);
1726 }
1728 /* Warn about classes that have private constructors and no friends. */
1730 /* Implicitly generated constructors are always public. */
1733 {
1736 /* If a non-template class does not define a copy
1737 constructor, one is defined for it, enabling it to avoid
1738 this warning. For a template class, this does not
1739 happen, and so we would normally get a warning on:
1741 template <class T> class C { private: C(); };
1743 To avoid this asymmetry, we check TYPE_HAS_COPY_CTOR. All
1744 complete non-template or fully instantiated classes have this
1745 flag set. */
1748 else
1750 {
1752 /* Ideally, we wouldn't count copy constructors (or, in
1753 fact, any constructor that takes an argument of the
1754 class type as a parameter) because such things cannot
1755 be used to construct an instance of the class unless
1756 you already have one. But, for now at least, we're
1757 more generous. */
1759 {
1762 }
1763 }
1766 {
1769 t);
1771 }
1772 }
1773 }
1776 gt_pointer_operator new_value;
1780 /* Comparison function to compare two TYPE_METHOD_VEC entries by name. */
1782 static int
1784 {
1797 }
1799 /* This routine compares two fields like method_name_cmp but using the
1800 pointer operator in resort_field_decl_data. */
1802 static int
1804 {
1813 {
1820 }
1822 }
1824 /* Resort TYPE_METHOD_VEC because pointers have been reordered. */
1826 void
1829 gt_pointer_operator new_value,
1831 {
1835 tree fn;
1837 /* The type conversion ops have to live at the front of the vec, so we
1838 can't sort them. */
1846 {
1850 resort_method_name_cmp);
1851 }
1852 }
1854 /* Warn about duplicate methods in fn_fields.
1856 Sort methods that are not special (i.e., constructors, destructors,
1857 and type conversion operators) so that we can find them faster in
1858 search. */
1860 static void
1862 {
1863 tree fn_fields;
1873 /* Clear DECL_IN_AGGR_P for all functions. */
1878 /* Issue warnings about private constructors and such. If there are
1879 no methods, then some public defaults are generated. */
1882 /* The type conversion ops have to live at the front of the vec, so we
1883 can't sort them. */
1892 }
1894 /* Make BINFO's vtable have N entries, including RTTI entries,
1895 vbase and vcall offsets, etc. Set its type and call the back end
1896 to lay it out. */
1898 static void
1900 {
1901 tree atype;
1902 tree vtable;
1907 /* We may have to grow the vtable. */
1910 {
1914 }
1915 }
1917 /* True iff FNDECL and BASE_FNDECL (both non-static member functions)
1918 have the same signature. */
1920 int
1922 {
1923 /* One destructor overrides another if they are the same kind of
1924 destructor. */
1928 /* But a non-destructor never overrides a destructor, nor vice
1929 versa, nor do different kinds of destructors override
1930 one-another. For example, a complete object destructor does not
1931 override a deleting destructor. */
1940 {
1948 }
1950 }
1952 /* Returns TRUE if DERIVED is a binfo containing the binfo BASE as a
1953 subobject. */
1955 static bool
1957 {
1958 tree probe;
1961 {
1965 /* If we meet a virtual base, we can't follow the inheritance
1966 any more. See if the complete type of DERIVED contains
1967 such a virtual base. */
1970 }
1972 }
1975 /* The function for which we are trying to find a final overrider. */
1976 tree fn;
1977 /* The base class in which the function was declared. */
1978 tree declaring_base;
1979 /* The candidate overriders. */
1980 tree candidates;
1981 /* Path to most derived. */
1985 /* Add the overrider along the current path to FFOD->CANDIDATES.
1986 Returns true if an overrider was found; false otherwise. */
1988 static bool
1992 {
1993 tree method;
1995 /* If BINFO is not the most derived type, try a more derived class.
1996 A definition there will overrider a definition here. */
1998 {
1999 depth--;
2003 }
2007 {
2010 /* Remove any candidates overridden by this new function. */
2012 {
2013 /* If *CANDIDATE overrides METHOD, then METHOD
2014 cannot override anything else on the list. */
2017 /* If METHOD overrides *CANDIDATE, remove *CANDIDATE. */
2020 else
2022 }
2024 /* Add the new function. */
2027 }
2030 }
2032 /* Called from find_final_overrider via dfs_walk. */
2034 static tree
2036 {
2044 }
2046 static tree
2048 {
2053 }
2055 /* Returns a TREE_LIST whose TREE_PURPOSE is the final overrider for
2056 FN and whose TREE_VALUE is the binfo for the base where the
2057 overriding occurs. BINFO (in the hierarchy dominated by the binfo
2058 DERIVED) is the base object in which FN is declared. */
2060 static tree
2062 {
2063 find_final_overrider_data ffod;
2065 /* Getting this right is a little tricky. This is valid:
2067 struct S { virtual void f (); };
2068 struct T { virtual void f (); };
2069 struct U : public S, public T { };
2071 even though calling `f' in `U' is ambiguous. But,
2073 struct R { virtual void f(); };
2074 struct S : virtual public R { virtual void f (); };
2075 struct T : virtual public R { virtual void f (); };
2076 struct U : public S, public T { };
2078 is not -- there's no way to decide whether to put `S::f' or
2079 `T::f' in the vtable for `R'.
2081 The solution is to look at all paths to BINFO. If we find
2082 different overriders along any two, then there is a problem. */
2086 /* Determine the depth of the hierarchy. */
2097 /* If there was no winner, issue an error message. */
2102 }
2104 /* Return the index of the vcall offset for FN when TYPE is used as a
2105 virtual base. */
2107 static tree
2109 {
2111 tree_pair_p p;
2119 /* There should always be an appropriate index. */
2121 }
2123 /* Update an entry in the vtable for BINFO, which is in the hierarchy
2124 dominated by T. FN is the old function; VIRTUALS points to the
2125 corresponding position in the new BINFO_VIRTUALS list. IX is the index
2126 of that entry in the list. */
2128 static void
2131 {
2132 tree b;
2133 tree overrider;
2134 tree delta;
2135 tree virtual_base;
2136 tree first_defn;
2142 /* Find the nearest primary base (possibly binfo itself) which defines
2143 this function; this is the class the caller will convert to when
2144 calling FN through BINFO. */
2146 {
2151 /* The nearest definition is from a lost primary. */
2154 }
2157 /* Find the final overrider. */
2160 {
2163 }
2166 /* Check for adjusting covariant return types. */
2174 /* If the overrider is invalid, don't even try. */
2176 {
2177 /* If FN is a covariant thunk, we must figure out the adjustment
2178 to the final base FN was converting to. As OVERRIDER_TARGET might
2179 also be converting to the return type of FN, we have to
2180 combine the two conversions here. */
2187 {
2191 }
2192 else
2196 /* Find the equivalent binfo within the return type of the
2197 overriding function. We will want the vbase offset from
2198 there. */
2200 over_return);
2203 {
2204 /* There was no existing virtual thunk (which takes
2205 precedence). So find the binfo of the base function's
2206 return type within the overriding function's return type.
2207 We cannot call lookup base here, because we're inside a
2208 dfs_walk, and will therefore clobber the BINFO_MARKED
2209 flags. Fortunately we know the covariancy is valid (it
2210 has already been checked), so we can just iterate along
2211 the binfos, which have been chained in inheritance graph
2212 order. Of course it is lame that we have to repeat the
2213 search here anyway -- we should really be caching pieces
2214 of the vtable and avoiding this repeated work. */
2217 /* Find the base binfo within the overriding function's
2218 return type. We will always find a thunk_binfo, except
2219 when the covariancy is invalid (which we will have
2220 already diagnosed). */
2223 thunk_binfo;
2229 /* See if virtual inheritance is involved. */
2231 virtual_offset;
2238 {
2242 {
2243 /* We convert via virtual base. Adjust the fixed
2244 offset to be from there. */
2245 offset =
2249 }
2251 /* There was an existing fixed offset, this must be
2252 from the base just converted to, and the base the
2253 FN was thunking to. */
2255 else
2257 }
2258 }
2261 /* Replace the overriding function with a covariant thunk. We
2262 will emit the overriding function in its own slot as
2263 well. */
2266 }
2267 else
2271 /* If we need a covariant thunk, then we may need to adjust first_defn.
2272 The ABI specifies that the thunks emitted with a function are
2273 determined by which bases the function overrides, so we need to be
2274 sure that we're using a thunk for some overridden base; even if we
2275 know that the necessary this adjustment is zero, there may not be an
2276 appropriate zero-this-adjusment thunk for us to use since thunks for
2277 overriding virtual bases always use the vcall offset.
2279 Furthermore, just choosing any base that overrides this function isn't
2280 quite right, as this slot won't be used for calls through a type that
2281 puts a covariant thunk here. Calling the function through such a type
2282 will use a different slot, and that slot is the one that determines
2283 the thunk emitted for that base.
2285 So, keep looking until we find the base that we're really overriding
2286 in this slot: the nearest primary base that doesn't use a covariant
2287 thunk in this slot. */
2289 {
2291 /* We already know that the overrider needs a covariant thunk. */
2294 {
2301 }
2303 }
2305 /* Assume that we will produce a thunk that convert all the way to
2306 the final overrider, and not to an intermediate virtual base. */
2309 /* See if we can convert to an intermediate virtual base first, and then
2310 use the vcall offset located there to finish the conversion. */
2312 {
2313 /* If we find the final overrider, then we can stop
2314 walking. */
2319 /* If we find a virtual base, and we haven't yet found the
2320 overrider, then there is a virtual base between the
2321 declaring base (first_defn) and the final overrider. */
2323 {
2326 }
2327 }
2329 /* Compute the constant adjustment to the `this' pointer. The
2330 `this' pointer, when this function is called, will point at BINFO
2331 (or one of its primary bases, which are at the same offset). */
2333 /* The `this' pointer needs to be adjusted from the declaration to
2334 the nearest virtual base. */
2339 /* If the nearest definition is in a lost primary, we don't need an
2340 entry in our vtable. Except possibly in a constructor vtable,
2341 if we happen to get our primary back. In that case, the offset
2342 will be zero, as it will be a primary base. */
2344 else
2345 /* The `this' pointer needs to be adjusted from pointing to
2346 BINFO to pointing at the base where the final overrider
2347 appears. */
2358 else
2362 }
2364 /* Called from modify_all_vtables via dfs_walk. */
2366 static tree
2368 {
2370 tree virtuals;
2371 tree old_virtuals;
2375 /* A base without a vtable needs no modification, and its bases
2376 are uninteresting. */
2381 /* Don't do the primary vtable, if it's new. */
2385 /* There's no need to modify the vtable for a non-virtual primary
2386 base; we're not going to use that vtable anyhow. We do still
2387 need to do this for virtual primary bases, as they could become
2388 non-primary in a construction vtable. */
2393 /* Now, go through each of the virtual functions in the virtual
2394 function table for BINFO. Find the final overrider, and update
2395 the BINFO_VIRTUALS list appropriately. */
2398 virtuals;
2402 binfo,
2407 }
2409 /* Update all of the primary and secondary vtables for T. Create new
2410 vtables as required, and initialize their RTTI information. Each
2411 of the functions in VIRTUALS is declared in T and may override a
2412 virtual function from a base class; find and modify the appropriate
2413 entries to point to the overriding functions. Returns a list, in
2414 declaration order, of the virtual functions that are declared in T,
2415 but do not appear in the primary base class vtable, and which
2416 should therefore be appended to the end of the vtable for T. */
2418 static tree
2420 {
2424 /* Update all of the vtables. */
2427 /* Add virtual functions not already in our primary vtable. These
2428 will be both those introduced by this class, and those overridden
2429 from secondary bases. It does not include virtuals merely
2430 inherited from secondary bases. */
2432 {
2437 {
2438 /* We don't need to adjust the `this' pointer when
2439 calling this function. */
2443 /* This is a function not already in our vtable. Keep it. */
2445 }
2446 else
2447 /* We've already got an entry for this function. Skip it. */
2449 }
2452 }
2454 /* Get the base virtual function declarations in T that have the
2455 indicated NAME. */
2457 static tree
2459 {
2460 tree methods;
2465 /* Find virtual functions in T with the indicated NAME. */
2469 methods;
2471 {
2477 }
2483 {
2486 base_fndecls);
2487 }
2490 }
2492 /* If this declaration supersedes the declaration of
2493 a method declared virtual in the base class, then
2494 mark this field as being virtual as well. */
2496 void
2498 {
2501 /* In [temp.mem] we have:
2503 A specialization of a member function template does not
2504 override a virtual function from a base class. */
2511 /* Set DECL_VINDEX to a value that is neither an INTEGER_CST nor
2512 the error_mark_node so that we know it is an overriding
2513 function. */
2514 {
2517 }
2520 {
2526 }
2531 }
2533 /* Warn about hidden virtual functions that are not overridden in t.
2534 We know that constructors and destructors don't apply. */
2536 static void
2538 {
2540 tree fns;
2543 /* We go through each separately named virtual function. */
2547 {
2548 tree fn;
2549 tree name;
2550 tree fndecl;
2551 tree base_fndecls;
2552 tree base_binfo;
2553 tree binfo;
2556 /* All functions in this slot in the CLASSTYPE_METHOD_VEC will
2557 have the same name. Figure out what name that is. */
2559 /* There are no possibly hidden functions yet. */
2561 /* Iterate through all of the base classes looking for possibly
2562 hidden functions. */
2565 {
2568 base_fndecls);
2569 }
2571 /* If there are no functions to hide, continue. */
2575 /* Remove any overridden functions. */
2577 {
2580 {
2584 /* If the method from the base class has the same
2585 signature as the method from the derived class, it
2586 has been overridden. */
2589 else
2591 }
2592 }
2594 /* Now give a warning for all base functions without overriders,
2595 as they are hidden. */
2597 {
2598 /* Here we know it is a hider, and no overrider exists. */
2602 }
2603 }
2604 }
2606 /* Check for things that are invalid. There are probably plenty of other
2607 things we should check for also. */
2609 static void
2611 {
2612 tree field;
2615 {
2623 {
2627 {
2628 /* We're generally only interested in entities the user
2629 declared, but we also find nested classes by noticing
2630 the TYPE_DECL that we create implicitly. You're
2631 allowed to put one anonymous union inside another,
2632 though, so we explicitly tolerate that. We use
2633 TYPE_ANONYMOUS_P rather than ANON_AGGR_TYPE_P so that
2634 we also allow unnamed types used for defining fields. */
2641 {
2645 else
2649 }
2652 {
2655 else
2657 }
2659 {
2662 else
2664 }
2668 }
2669 }
2670 }
2671 }
2673 /* Add T to CLASSTYPE_DECL_LIST of current_class_type which
2674 will be used later during class template instantiation.
2675 When FRIEND_P is zero, T can be a static member data (VAR_DECL),
2676 a non-static member data (FIELD_DECL), a member function
2677 (FUNCTION_DECL), a nested type (RECORD_TYPE, ENUM_TYPE),
2678 a typedef (TYPE_DECL) or a member class template (TEMPLATE_DECL)
2679 When FRIEND_P is nonzero, T is either a friend class
2680 (RECORD_TYPE, TEMPLATE_DECL) or a friend function
2681 (FUNCTION_DECL, TEMPLATE_DECL). */
2683 void
2685 {
2686 /* Save some memory by not creating TREE_LIST if TYPE is not template. */
2691 }
2693 /* This function is called from declare_virt_assop_and_dtor via
2694 dfs_walk_all.
2696 DATA is a type that direcly or indirectly inherits the base
2697 represented by BINFO. If BINFO contains a virtual assignment [copy
2698 assignment or move assigment] operator or a virtual constructor,
2699 declare that function in DATA if it hasn't been already declared. */
2701 static tree
2703 {
2711 /* A base without a vtable needs no modification, and its bases
2712 are uninteresting. */
2716 /* If this is a primary base, then we have already looked at the
2717 virtual functions of its vtable. */
2721 {
2725 {
2730 }
2734 }
2737 }
2739 /* If the class type T has a direct or indirect base that contains a
2740 virtual assignment operator or a virtual destructor, declare that
2741 function in T if it hasn't been already declared. */
2743 static void
2745 {
2753 dfs_declare_virt_assop_and_dtor,
2755 }
2757 /* Create default constructors, assignment operators, and so forth for
2758 the type indicated by T, if they are needed. CANT_HAVE_CONST_CTOR,
2759 and CANT_HAVE_CONST_ASSIGNMENT are nonzero if, for whatever reason,
2760 the class cannot have a default constructor, copy constructor
2761 taking a const reference argument, or an assignment operator taking
2762 a const reference, respectively. */
2764 static void
2768 {
2776 /* Destructor. */
2778 {
2779 /* In general, we create destructors lazily. */
2784 /* But if this is a Java class, any non-trivial destructor is
2785 invalid, even if compiler-generated. Therefore, if the
2786 destructor is non-trivial we create it now. */
2788 }
2790 /* [class.ctor]
2792 If there is no user-declared constructor for a class, a default
2793 constructor is implicitly declared. */
2795 {
2800 /* This might force the declaration. */
2802 }
2804 /* [class.ctor]
2806 If a class definition does not explicitly declare a copy
2807 constructor, one is declared implicitly. */
2809 {
2815 }
2817 /* If there is no assignment operator, one will be created if and
2818 when it is needed. For now, just record whether or not the type
2819 of the parameter to the assignment operator will be a const or
2820 non-const reference. */
2822 {
2828 }
2830 /* We can't be lazy about declaring functions that might override
2831 a virtual function from a base class. */
2833 }
2835 /* Subroutine of insert_into_classtype_sorted_fields. Recursively
2836 count the number of fields in TYPE, including anonymous union
2837 members. */
2839 static int
2841 {
2842 tree x;
2845 {
2848 else
2850 }
2852 }
2854 /* Subroutine of insert_into_classtype_sorted_fields. Recursively add
2855 all the fields in the TREE_LIST FIELDS to the SORTED_FIELDS_TYPE
2856 elts, starting at offset IDX. */
2858 static int
2860 {
2861 tree x;
2863 {
2866 else
2868 }
2870 }
2872 /* Add all of the enum values of ENUMTYPE, to the FIELD_VEC elts,
2873 starting at offset IDX. */
2875 static int
2879 {
2880 tree values;
2884 }
2886 /* FIELD is a bit-field. We are finishing the processing for its
2887 enclosing type. Issue any appropriate messages and set appropriate
2888 flags. Returns false if an error has been diagnosed. */
2890 static bool
2892 {
2894 tree w;
2896 /* Extract the declared width of the bitfield, which has been
2897 temporarily stashed in DECL_INITIAL. */
2900 /* Remove the bit-field width indicator so that the rest of the
2901 compiler does not treat that value as an initializer. */
2904 /* Detect invalid bit-field type. */
2906 {
2909 }
2910 else
2911 {
2913 /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs. */
2916 /* detect invalid field size. */
2922 {
2925 }
2927 {
2930 }
2932 {
2935 }
2944 }
2947 {
2951 }
2952 else
2953 {
2954 /* Non-bit-fields are aligned for their type. */
2958 }
2959 }
2961 /* FIELD is a non bit-field. We are finishing the processing for its
2962 enclosing type T. Issue any appropriate messages and set appropriate
2963 flags. */
2965 static void
2967 tree t,
2971 {
2974 /* In C++98 an anonymous union cannot contain any fields which would change
2975 the settings of CANT_HAVE_CONST_CTOR and friends. */
2977 ;
2978 /* And, we don't set TYPE_HAS_CONST_COPY_CTOR, etc., for anonymous
2979 structs. So, we recurse through their fields here. */
2981 {
2982 tree fields;
2988 }
2989 /* Check members with class type for constructors, destructors,
2990 etc. */
2992 {
2993 /* Never let anything with uninheritable virtuals
2994 make it through without complaint. */
2998 {
3003 field);
3008 field);
3010 {
3014 }
3015 }
3016 else
3017 {
3030 }
3039 }
3041 {
3042 /* `build_class_init_list' does not recognize
3043 non-FIELD_DECLs. */
3047 }
3048 }
3050 /* Check the data members (both static and non-static), class-scoped
3051 typedefs, etc., appearing in the declaration of T. Issue
3052 appropriate diagnostics. Sets ACCESS_DECLS to a list (in
3053 declaration order) of access declarations; each TREE_VALUE in this
3054 list is a USING_DECL.
3056 In addition, set the following flags:
3058 EMPTY_P
3059 The class is empty, i.e., contains no non-static data members.
3061 CANT_HAVE_CONST_CTOR_P
3062 This class cannot have an implicitly generated copy constructor
3063 taking a const reference.
3065 CANT_HAVE_CONST_ASN_REF
3066 This class cannot have an implicitly generated assignment
3067 operator taking a const reference.
3069 All of these flags should be initialized before calling this
3070 function.
3072 Returns a pointer to the end of the TYPE_FIELDs chain; additional
3073 fields can be added by adding to this chain. */
3075 static void
3079 {
3087 /* Assume there are no access declarations. */
3089 /* Assume this class has no pointer members. */
3091 /* Assume none of the members of this class have default
3092 initializations. */
3096 {
3104 {
3105 /* Save the access declarations for our caller. */
3108 }
3114 /* If we've gotten this far, it's a data member, possibly static,
3115 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;
5138 }
5139 }
5141 /* Synthesize any needed methods. */
5143 cant_have_const_ctor,
5144 no_const_asn_ref);
5146 /* Check defaulted declarations here so we have cant_have_const_ctor
5147 and don't need to worry about clones. */
5150 {
5153 {
5154 bool imp_const_p
5160 /* If the function is defaulted outside the class, we just
5161 give the synthesis error. */
5164 }
5166 }
5169 {
5170 /* "The closure type associated with a lambda-expression has a deleted
5171 default constructor and a deleted copy assignment operator." */
5177 /* "This class type is not an aggregate." */
5179 }
5181 /* Compute the 'literal type' property before we
5182 do anything with non-static member functions. */
5185 /* Create the in-charge and not-in-charge variants of constructors
5186 and destructors. */
5189 /* Process the using-declarations. */
5193 /* Build and sort the CLASSTYPE_METHOD_VEC. */
5196 /* Figure out whether or not we will need a cookie when dynamically
5197 allocating an array of this type. */
5200 }
5202 /* If T needs a pointer to its virtual function table, set TYPE_VFIELD
5203 accordingly. If a new vfield was created (because T doesn't have a
5204 primary base class), then the newly created field is returned. It
5205 is not added to the TYPE_FIELDS list; it is the caller's
5206 responsibility to do that. Accumulate declared virtual functions
5207 on VIRTUALS_P. */
5209 static tree
5211 {
5212 tree fn;
5214 /* Collect the virtual functions declared in T. */
5218 {
5227 }
5229 /* If we couldn't find an appropriate base class, create a new field
5230 here. Even if there weren't any new virtual functions, we might need a
5231 new virtual function table if we're supposed to include vptrs in
5232 all classes that need them. */
5234 {
5235 /* We build this decl with vtbl_ptr_type_node, which is a
5236 `vtable_entry_type*'. It might seem more precise to use
5237 `vtable_entry_type (*)[N]' where N is the number of virtual
5238 functions. However, that would require the vtable pointer in
5239 base classes to have a different type than the vtable pointer
5240 in derived classes. We could make that happen, but that
5241 still wouldn't solve all the problems. In particular, the
5242 type-based alias analysis code would decide that assignments
5243 to the base class vtable pointer can't alias assignments to
5244 the derived class vtable pointer, since they have different
5245 types. Thus, in a derived class destructor, where the base
5246 class constructor was inlined, we could generate bad code for
5247 setting up the vtable pointer.
5249 Therefore, we use one type for all vtable pointers. We still
5250 use a type-correct type; it's just doesn't indicate the array
5251 bounds. That's better than using `void*' or some such; it's
5252 cleaner, and it let's the alias analysis code know that these
5253 stores cannot alias stores to void*! */
5254 tree field;
5267 /* This class is non-empty. */
5271 }
5274 }
5276 /* Add OFFSET to all base types of BINFO which is a base in the
5277 hierarchy dominated by T.
5279 OFFSET, which is a type offset, is number of bytes. */
5281 static void
5283 {
5285 tree primary_binfo;
5286 tree base_binfo;
5288 /* Update BINFO's offset. */
5293 offset));
5295 /* Find the primary base class. */
5301 /* Scan all of the bases, pushing the BINFO_OFFSET adjust
5302 downwards. */
5304 {
5305 /* Don't do the primary base twice. */
5313 }
5314 }
5316 /* Set BINFO_OFFSET for all of the virtual bases for RLI->T. Update
5317 TYPE_ALIGN and TYPE_SIZE for T. OFFSETS gives the location of
5318 empty subobjects of T. */
5320 static void
5322 {
5323 tree vbase;
5332 {
5333 /* In G++ 3.2, we incorrectly rounded the size before laying out
5334 the virtual bases. */
5336 #ifdef STRUCTURE_SIZE_BOUNDARY
5337 /* Packed structures don't need to have minimum size. */
5340 #endif
5344 }
5346 /* Find the last field. The artificial fields created for virtual
5347 bases will go after the last extant field to date. */
5352 /* Go through the virtual bases, allocating space for each virtual
5353 base that is not already a primary base class. These are
5354 allocated in inheritance graph order. */
5356 {
5361 {
5364 /* This virtual base is not a primary base of any class in the
5365 hierarchy, so we have to add space for it. */
5369 /* If the first virtual base might have been placed at a
5370 lower address, had we started from CLASSTYPE_SIZE, rather
5371 than TYPE_SIZE, issue a warning. There can be both false
5372 positives and false negatives from this warning in rare
5373 cases; to deal with all the possibilities would probably
5374 require performing both layout algorithms and comparing
5375 the results which is not particularly tractable. */
5377 && first_vbase
5378 && (tree_int_cst_lt
5383 bitsize_unit_node),
5386 "offset of virtual base %qT is not ABI-compliant and "
5388 basetype);
5391 }
5392 }
5393 }
5395 /* Returns the offset of the byte just past the end of the base class
5396 BINFO. */
5398 static tree
5400 {
5401 tree size;
5406 /* An empty class has zero CLASSTYPE_SIZE_UNIT, but we need to
5407 allocate some space for it. It cannot have virtual bases, so
5408 TYPE_SIZE_UNIT is fine. */
5410 else
5414 }
5416 /* Returns the offset of the byte just past the end of the base class
5417 with the highest offset in T. If INCLUDE_VIRTUALS_P is zero, then
5418 only non-virtual bases are included. */
5420 static tree
5422 {
5425 tree binfo;
5426 tree base_binfo;
5427 tree offset;
5432 {
5442 }
5444 /* G++ 3.2 did not check indirect virtual bases. */
5448 {
5452 }
5455 }
5457 /* Warn about bases of T that are inaccessible because they are
5458 ambiguous. For example:
5460 struct S {};
5461 struct T : public S {};
5462 struct U : public S, public T {};
5464 Here, `(S*) new U' is not allowed because there are two `S'
5465 subobjects of U. */
5467 static void
5469 {
5472 tree basetype;
5473 tree binfo;
5474 tree base_binfo;
5476 /* If there are no repeated bases, nothing can be ambiguous. */
5480 /* Check direct bases. */
5483 {
5489 }
5491 /* Check for ambiguous virtual bases. */
5495 {
5501 }
5502 }
5504 /* Compare two INTEGER_CSTs K1 and K2. */
5506 static int
5508 {
5510 }
5512 /* Increase the size indicated in RLI to account for empty classes
5513 that are "off the end" of the class. */
5515 static void
5517 {
5518 tree eoc;
5519 tree rli_size;
5521 /* It might be the case that we grew the class to allocate a
5522 zero-sized base class. That won't be reflected in RLI, yet,
5523 because we are willing to overlay multiple bases at the same
5524 offset. However, now we need to make sure that RLI is big enough
5525 to reflect the entire class. */
5531 {
5533 /* In version 1 of the ABI, the size of a class that ends with
5534 a bitfield was not rounded up to a whole multiple of a
5535 byte. Because rli_size_unit_so_far returns only the number
5536 of fully allocated bytes, any extra bits were not included
5537 in the size. */
5539 else
5540 /* The size should have been rounded to a whole byte. */
5543 rli->bitpos
5552 }
5553 }
5555 /* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T. Calculate
5556 BINFO_OFFSETs for all of the base-classes. Position the vtable
5557 pointer. Accumulate declared virtual functions on VIRTUALS_P. */
5559 static void
5561 {
5562 tree non_static_data_members;
5563 tree field;
5564 tree vptr;
5565 record_layout_info rli;
5566 /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of
5567 types that appear at that offset. */
5568 splay_tree empty_base_offsets;
5569 /* True if the last field layed out was a bit-field. */
5571 /* The location at which the next field should be inserted. */
5573 /* T, as a base class. */
5574 tree base_t;
5576 /* Keep track of the first non-static data member. */
5579 /* Start laying out the record. */
5582 /* Mark all the primary bases in the hierarchy. */
5585 /* Create a pointer to our virtual function table. */
5588 /* The vptr is always the first thing in the class. */
5590 {
5595 }
5596 else
5599 /* Build FIELD_DECLs for all of the non-virtual base-types. */
5604 /* Layout the non-static data members. */
5606 {
5607 tree type;
5608 tree padding;
5610 /* We still pass things that aren't non-static data members to
5611 the back end, in case it wants to do something with them. */
5613 {
5615 /* If the static data member has incomplete type, keep track
5616 of it so that it can be completed later. (The handling
5617 of pending statics in finish_record_layout is
5618 insufficient; consider:
5620 struct S1;
5621 struct S2 { static S1 s1; };
5623 At this point, finish_record_layout will be called, but
5624 S1 is still incomplete.) */
5626 {
5628 /* The visibility of static data members is determined
5629 at their point of declaration, not their point of
5630 definition. */
5632 }
5634 }
5642 /* If this field is a bit-field whose width is greater than its
5643 type, then there are some special rules for allocating
5644 it. */
5647 {
5649 tree integer_type;
5651 /* We must allocate the bits as if suitably aligned for the
5652 longest integer type that fits in this many bits. type
5653 of the field. Then, we are supposed to use the left over
5654 bits as additional padding. */
5663 /* ITK now indicates a type that is too large for the
5664 field. We have to back up by one to find the largest
5665 type that fits. */
5666 do
5667 {
5672 /* Figure out how much additional padding is required. GCC
5673 3.2 always created a padding field, even if it had zero
5674 width. */
5677 {
5679 /* In a union, the padding field must have the full width
5680 of the bit-field; all fields start at offset zero. */
5682 else
5683 {
5686 "ABI-compliant and may change in a future "
5688 t);
5691 }
5692 }
5693 #ifdef PCC_BITFIELD_TYPE_MATTERS
5694 /* An unnamed bitfield does not normally affect the
5695 alignment of the containing class on a target where
5696 PCC_BITFIELD_TYPE_MATTERS. But, the C++ ABI does not
5697 make any exceptions for unnamed bitfields when the
5698 bitfields are longer than their types. Therefore, we
5699 temporarily give the field a name. */
5701 {
5704 }
5705 #endif
5710 empty_base_offsets);
5713 /* Now that layout has been performed, set the size of the
5714 field to the size of its declared type; the rest of the
5715 field is effectively invisible. */
5717 /* We must also reset the DECL_MODE of the field. */
5722 /* Versions of G++ before G++ 3.4 did not reset the
5723 DECL_MODE. */
5725 "the offset of %qD may not be ABI-compliant and may "
5727 }
5728 else
5730 empty_base_offsets);
5732 /* Remember the location of any empty classes in FIELD. */
5736 empty_base_offsets,
5739 /* If a bit-field does not immediately follow another bit-field,
5740 and yet it starts in the middle of a byte, we have failed to
5741 comply with the ABI. */
5744 /* The TREE_NO_WARNING flag gets set by Objective-C when
5745 laying out an Objective-C class. The ObjC ABI differs
5746 from the C++ ABI, and so we do not want a warning
5747 here. */
5749 && !last_field_was_bitfield
5752 bitsize_unit_node)))
5756 /* G++ used to use DECL_FIELD_OFFSET as if it were the byte
5757 offset of the field. */
5764 "classes to be placed at different locations in a "
5767 /* The middle end uses the type of expressions to determine the
5768 possible range of expression values. In order to optimize
5769 "x.i > 7" to "false" for a 2-bit bitfield "i", the middle end
5770 must be made aware of the width of "i", via its type.
5772 Because C++ does not have integer types of arbitrary width,
5773 we must (for the purposes of the front end) convert from the
5774 type assigned here to the declared type of the bitfield
5775 whenever a bitfield expression is used as an rvalue.
5776 Similarly, when assigning a value to a bitfield, the value
5777 must be converted to the type given the bitfield here. */
5779 {
5784 {
5791 }
5792 }
5794 /* If we needed additional padding after this field, add it
5795 now. */
5797 {
5798 tree padding_field;
5801 FIELD_DECL,
5802 NULL_TREE,
5803 char_type_node);
5810 NULL_TREE,
5811 empty_base_offsets);
5812 }
5815 }
5818 {
5819 /* Make sure that we are on a byte boundary so that the size of
5820 the class without virtual bases will always be a round number
5821 of bytes. */
5824 }
5826 /* G++ 3.2 does not allow virtual bases to be overlaid with tail
5827 padding. */
5831 /* Delete all zero-width bit-fields from the list of fields. Now
5832 that the type is laid out they are no longer important. */
5835 /* Create the version of T used for virtual bases. We do not use
5836 make_class_type for this version; this is an artificial type. For
5837 a POD type, we just reuse T. */
5839 {
5842 /* Set the size and alignment for the new type. In G++ 3.2, all
5843 empty classes were considered to have size zero when used as
5844 base classes. */
5846 {
5851 "layout of classes derived from empty class %qT "
5853 t);
5854 }
5855 else
5856 {
5857 tree eoc;
5859 /* If the ABI version is not at least two, and the last
5860 field was a bit-field, RLI may not be on a byte
5861 boundary. In particular, rli_size_unit_so_far might
5862 indicate the last complete byte, while rli_size_so_far
5863 indicates the total number of bits used. Therefore,
5864 rli_size_so_far, rather than rli_size_unit_so_far, is
5865 used to compute TYPE_SIZE_UNIT. */
5873 eoc);
5880 }
5884 /* Copy the fields from T. */
5888 {
5890 FIELD_DECL,
5900 }
5902 /* Record the base version of the type. */
5905 }
5906 else
5909 /* Every empty class contains an empty class. */
5913 /* Set the TYPE_DECL for this type to contain the right
5914 value for DECL_OFFSET, so that we can use it as part
5915 of a COMPONENT_REF for multiple inheritance. */
5918 /* Now fix up any virtual base class types that we left lying
5919 around. We must get these done before we try to lay out the
5920 virtual function table. As a side-effect, this will remove the
5921 base subobject fields. */
5924 /* Make sure that empty classes are reflected in RLI at this
5925 point. */
5928 /* Make sure not to create any structures with zero size. */
5934 /* If this is a non-POD, declaring it packed makes a difference to how it
5935 can be used as a field; don't let finalize_record_size undo it. */
5939 /* Let the back end lay out the type. */
5942 /* Warn about bases that can't be talked about due to ambiguity. */
5945 /* Now that we're done with layout, give the base fields the real types. */
5950 /* Clean up. */
5957 }
5959 /* Determine the "key method" for the class type indicated by TYPE,
5960 and set CLASSTYPE_KEY_METHOD accordingly. */
5962 void
5964 {
5965 tree method;
5968 || processing_template_decl
5973 /* The key method is the first non-pure virtual function that is not
5974 inline at the point of class definition. On some targets the
5975 key function may not be inline; those targets should not call
5976 this function until the end of the translation unit. */
5982 {
5985 }
5988 }
5991 /* Allocate and return an instance of struct sorted_fields_type with
5992 N fields. */
5996 {
6003 }
6006 /* Perform processing required when the definition of T (a class type)
6007 is complete. */
6009 void
6011 {
6012 tree x;
6013 /* A TREE_LIST. The TREE_VALUE of each node is a FUNCTION_DECL. */
6017 {
6022 }
6024 /* If this type was previously laid out as a forward reference,
6025 make sure we lay it out again. */
6029 /* Make assumptions about the class; we'll reset the flags if
6030 necessary. */
6036 /* Do end-of-class semantic processing: checking the validity of the
6037 bases and members and add implicitly generated methods. */
6040 /* Find the key method. */
6042 {
6043 /* The Itanium C++ ABI permits the key method to be chosen when
6044 the class is defined -- even though the key method so
6045 selected may later turn out to be an inline function. On
6046 some systems (such as ARM Symbian OS) the key method cannot
6047 be determined until the end of the translation unit. On such
6048 systems, we leave CLASSTYPE_KEY_METHOD set to NULL, which
6049 will cause the class to be added to KEYED_CLASSES. Then, in
6050 finish_file we will determine the key method. */
6054 /* If a polymorphic class has no key method, we may emit the vtable
6055 in every translation unit where the class definition appears. */
6058 }
6060 /* Layout the class itself. */
6063 /* We use the base type for trivial assignments, and hence it
6064 needs a mode. */
6069 /* If necessary, create the primary vtable for this class. */
6071 {
6072 /* We must enter these virtuals into the table. */
6076 /* Here we know enough to change the type of our virtual
6077 function table, but we will wait until later this function. */
6079 }
6082 {
6084 tree fn;
6091 /* Add entries for virtual functions introduced by this class. */
6095 /* Set DECL_VINDEX for all functions declared in this class. */
6097 fn;
6099 vindex += (TARGET_VTABLE_USES_DESCRIPTORS
6101 {
6105 /* A thunk. We should never be calling this entry directly
6106 from this vtable -- we'd use the entry for the non
6107 thunk base function. */
6111 }
6112 }
6117 /* Complete the rtl for any static member objects of the type we're
6118 working on. */
6125 /* Done with FIELDS...now decide whether to sort these for
6126 faster lookups later.
6128 We use a small number because most searches fail (succeeding
6129 ultimately as the search bores through the inheritance
6130 hierarchy), and we want this failure to occur quickly. */
6134 /* Complain if one of the field types requires lower visibility. */
6137 /* Make the rtl for any new vtables we have created, and unmark
6138 the base types we marked. */
6141 /* Build the VTT for T. */
6144 /* This warning does not make sense for Java classes, since they
6145 cannot have destructors. */
6147 {
6148 tree dtor;
6152 if it were virtual, we would have created it by now. */
6153 !dtor
6162 "%q#T has virtual functions and accessible"
6164 }
6171 /* Class layout, assignment of virtual table slots, etc., is now
6172 complete. Give the back end a chance to tweak the visibility of
6173 the class or perform any other required target modifications. */
6180 /* Finish debugging output for this type. */
6184 {
6187 {
6190 }
6192 {
6195 else
6196 {
6199 }
6201 }
6202 }
6203 }
6205 /* Insert FIELDS into T for the sorted case if the FIELDS count is
6206 equal to THRESHOLD or greater than THRESHOLD. */
6208 static void
6210 {
6213 {
6218 }
6219 }
6221 /* Insert lately defined enum ENUMTYPE into T for the sorted case. */
6223 void
6225 {
6228 {
6230 int n_fields
6241 }
6242 }
6244 /* When T was built up, the member declarations were added in reverse
6245 order. Rearrange them to declaration order. */
6247 void
6249 {
6250 tree next;
6251 tree prev;
6252 tree x;
6254 /* The following lists are all in reverse order. Put them in
6255 declaration order now. */
6259 /* Actually, for the TYPE_FIELDS, only the non TYPE_DECLs are in
6260 reverse order, so we can't just use nreverse. */
6265 {
6269 }
6271 {
6275 }
6276 }
6278 tree
6280 {
6283 /* Now that we've got all the field declarations, reverse everything
6284 as necessary. */
6289 /* Nadger the current location so that diagnostics point to the start of
6290 the struct, not the end. */
6294 {
6295 tree x;
6301 /* We need to emit an error message if this type was used as a parameter
6302 and it is an abstract type, even if it is a template. We construct
6303 a simple CLASSTYPE_PURE_VIRTUALS list without taking bases into
6304 account and we call complete_vars with this type, which will check
6305 the PARM_DECLS. Note that while the type is being defined,
6306 CLASSTYPE_PURE_VIRTUALS contains the list of the inline friends
6307 (see CLASSTYPE_INLINE_FRIENDS) so we need to clear it. */
6313 /* We need to add the target functions to the CLASSTYPE_METHOD_VEC if
6314 an enclosing scope is a template class, so that this function be
6315 found by lookup_fnfields_1 when the using declaration is not
6316 instantiated yet. */
6319 {
6324 }
6326 /* Remember current #pragma pack value. */
6328 }
6329 else
6338 else
6342 /* Lambdas are defined by the LAMBDA_EXPR. */
6347 }
6348 \f
6349 /* Return the dynamic type of INSTANCE, if known.
6350 Used to determine whether the virtual function table is needed
6351 or not.
6353 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
6354 of our knowledge of its type. *NONNULL should be initialized
6355 before this function is called. */
6357 static tree
6359 {
6360 #define RECUR(T) fixed_type_or_null((T), nonnull, cdtorp)
6363 {
6367 else
6371 /* This is a call to a constructor, hence it's never zero. */
6373 {
6377 }
6381 /* This is a call to a constructor, hence it's never zero. */
6383 {
6387 }
6396 /* Propagate nonnull. */
6401 CASE_CONVERT:
6407 {
6408 /* Just because we see an ADDR_EXPR doesn't mean we're dealing
6409 with a real object -- given &p->f, p can still be null. */
6411 /* ??? Probably should check DECL_WEAK here. */
6414 }
6418 /* If this component is really a base class reference, then the field
6419 itself isn't definitive. */
6428 {
6432 }
6433 /* fall through... */
6438 {
6442 }
6444 {
6448 /* if we're in a ctor or dtor, we know our type. If
6449 current_class_ptr is set but we aren't in a function, we're in
6450 an NSDMI (and therefore a constructor). */
6455 {
6459 }
6460 }
6462 {
6463 /* We only need one hash table because it is always left empty. */
6467 htab_hash_pointer,
6468 htab_eq_pointer,
6471 /* Reference variables should be references to objects. */
6475 /* Enter the INSTANCE in a table to prevent recursion; a
6476 variable's initializer may refer to the variable
6477 itself. */
6482 {
6483 tree type;
6492 }
6493 }
6498 }
6499 #undef RECUR
6500 }
6502 /* Return nonzero if the dynamic type of INSTANCE is known, and
6503 equivalent to the static type. We also handle the case where
6504 INSTANCE is really a pointer. Return negative if this is a
6505 ctor/dtor. There the dynamic type is known, but this might not be
6506 the most derived base of the original object, and hence virtual
6507 bases may not be layed out according to this type.
6509 Used to determine whether the virtual function table is needed
6510 or not.
6512 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
6513 of our knowledge of its type. *NONNULL should be initialized
6514 before this function is called. */
6516 int
6518 {
6521 tree fixed;
6523 /* processing_template_decl can be false in a template if we're in
6524 fold_non_dependent_expr, but we still want to suppress this check. */
6526 {
6527 /* In a template we only care about the type of the result. */
6531 }
6541 }
6543 \f
6544 void
6546 {
6549 current_class_stack
6557 }
6559 /* Restore the cached PREVIOUS_CLASS_LEVEL. */
6561 static void
6563 {
6564 tree type;
6566 /* We are re-entering the same class we just left, so we don't
6567 have to search the whole inheritance matrix to find all the
6568 decls to bind again. Instead, we install the cached
6569 class_shadowed list and walk through it binding names. */
6572 /* Restore IDENTIFIER_TYPE_VALUE. */
6574 type;
6577 }
6579 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE as
6580 appropriate for TYPE.
6582 So that we may avoid calls to lookup_name, we cache the _TYPE
6583 nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
6585 For multiple inheritance, we perform a two-pass depth-first search
6586 of the type lattice. */
6588 void
6590 {
6591 class_stack_node_t csn;
6595 /* Make sure there is enough room for the new entry on the stack. */
6597 {
6599 current_class_stack
6601 current_class_stack_size);
6602 }
6604 /* Insert a new entry on the class stack. */
6611 current_class_depth++;
6613 /* Now set up the new type. */
6619 /* By default, things in classes are private, while things in
6620 structures or unions are public. */
6622 ? access_private_node
6628 {
6629 /* Forcibly remove any old class remnants. */
6631 }
6637 else
6639 }
6641 /* When we exit a toplevel class scope, we save its binding level so
6642 that we can restore it quickly. Here, we've entered some other
6643 class, so we must invalidate our cache. */
6645 void
6647 {
6649 }
6651 /* Get out of the current class scope. If we were in a class scope
6652 previously, that is the one popped to. */
6654 void
6656 {
6659 current_class_depth--;
6665 }
6667 /* Mark the top of the class stack as hidden. */
6669 void
6671 {
6674 }
6676 /* Mark the top of the class stack as un-hidden. */
6678 void
6680 {
6683 }
6685 /* Returns 1 if the class type currently being defined is either T or
6686 a nested type of T. */
6688 bool
6690 {
6698 /* We start looking from 1 because entry 0 is from global scope,
6699 and has no type. */
6701 {
6702 tree c;
6705 else
6706 {
6710 }
6715 }
6717 }
6719 /* If either current_class_type or one of its enclosing classes are derived
6720 from T, return the appropriate type. Used to determine how we found
6721 something via unqualified lookup. */
6723 tree
6725 {
6728 /* The bases of a dependent type are unknown. */
6739 {
6744 }
6747 }
6749 /* Returns the innermost class type which is not a lambda closure type. */
6751 tree
6753 {
6756 /* We start looking from 1 because entry 0 is from global scope,
6757 and has no type. */
6759 {
6760 tree c;
6763 else
6764 {
6768 }
6773 }
6775 }
6777 /* When entering a class scope, all enclosing class scopes' names with
6778 static meaning (static variables, static functions, types and
6779 enumerators) have to be visible. This recursive function calls
6780 pushclass for all enclosing class contexts until global or a local
6781 scope is reached. TYPE is the enclosed class. */
6783 void
6785 {
6786 /* A namespace might be passed in error cases, like A::B:C. */
6794 }
6796 /* Undoes a push_nested_class call. */
6798 void
6800 {
6806 }
6808 /* Returns the number of extern "LANG" blocks we are nested within. */
6810 int
6812 {
6814 }
6816 /* Set global variables CURRENT_LANG_NAME to appropriate value
6817 so that behavior of name-mangling machinery is correct. */
6819 void
6821 {
6825 {
6827 }
6829 {
6831 /* DECL_IGNORED_P is initially set for these types, to avoid clutter.
6832 (See record_builtin_java_type in decl.c.) However, that causes
6833 incorrect debug entries if these types are actually used.
6834 So we re-enable debug output after extern "Java". */
6843 }
6845 {
6847 }
6848 else
6850 }
6852 /* Get out of the current language scope. */
6854 void
6856 {
6858 }
6859 \f
6860 /* Type instantiation routines. */
6862 /* Given an OVERLOAD and a TARGET_TYPE, return the function that
6863 matches the TARGET_TYPE. If there is no satisfactory match, return
6864 error_mark_node, and issue an error & warning messages under
6865 control of FLAGS. Permit pointers to member function if FLAGS
6866 permits. If TEMPLATE_ONLY, the name of the overloaded function was
6867 a template-id, and EXPLICIT_TARGS are the explicitly provided
6868 template arguments.
6870 If OVERLOAD is for one or more member functions, then ACCESS_PATH
6871 is the base path used to reference those member functions. If
6872 TF_NO_ACCESS_CONTROL is not set in FLAGS, and the address is
6873 resolved to a member function, access checks will be performed and
6874 errors issued if appropriate. */
6876 static tree
6878 tree overload,
6879 tsubst_flags_t flags,
6881 tree explicit_targs,
6882 tree access_path)
6883 {
6884 /* Here's what the standard says:
6886 [over.over]
6888 If the name is a function template, template argument deduction
6889 is done, and if the argument deduction succeeds, the deduced
6890 arguments are used to generate a single template function, which
6891 is added to the set of overloaded functions considered.
6893 Non-member functions and static member functions match targets of
6894 type "pointer-to-function" or "reference-to-function." Nonstatic
6895 member functions match targets of type "pointer-to-member
6896 function;" the function type of the pointer to member is used to
6897 select the member function from the set of overloaded member
6898 functions. If a nonstatic member function is selected, the
6899 reference to the overloaded function name is required to have the
6900 form of a pointer to member as described in 5.3.1.
6902 If more than one function is selected, any template functions in
6903 the set are eliminated if the set also contains a non-template
6904 function, and any given template function is eliminated if the
6905 set contains a second template function that is more specialized
6906 than the first according to the partial ordering rules 14.5.5.2.
6907 After such eliminations, if any, there shall remain exactly one
6908 selected function. */
6911 /* We store the matches in a TREE_LIST rooted here. The functions
6912 are the TREE_PURPOSE, not the TREE_VALUE, in this list, for easy
6913 interoperability with most_specialized_instantiation. */
6915 tree fn;
6916 tree target_fn_type;
6918 /* By the time we get here, we should be seeing only real
6919 pointer-to-member types, not the internal POINTER_TYPE to
6920 METHOD_TYPE representation. */
6926 /* Check that the TARGET_TYPE is reasonable. */
6930 /* This is OK, too. */
6933 /* This is OK, too. This comes from a conversion to reference
6934 type. */
6936 else
6937 {
6943 }
6945 /* Non-member functions and static member functions match targets of type
6946 "pointer-to-function" or "reference-to-function." Nonstatic member
6947 functions match targets of type "pointer-to-member-function;" the
6948 function type of the pointer to member is used to select the member
6949 function from the set of overloaded member functions.
6951 So figure out the FUNCTION_TYPE that we want to match against. */
6954 /* If we can find a non-template function that matches, we can just
6955 use it. There's no point in generating template instantiations
6956 if we're just going to throw them out anyhow. But, of course, we
6957 can only do this when we don't *need* a template function. */
6959 {
6960 tree fns;
6963 {
6967 /* We're not looking for templates just yet. */
6972 /* We're looking for a non-static member, and this isn't
6973 one, or vice versa. */
6976 /* Ignore functions which haven't been explicitly
6977 declared. */
6981 /* See if there's a match. */
6984 }
6985 }
6987 /* Now, if we've already got a match (or matches), there's no need
6988 to proceed to the template functions. But, if we don't have a
6989 match we need to look at them, too. */
6991 {
6992 tree target_arg_types;
6993 tree target_ret_type;
6994 tree fns;
6997 tree arg;
7011 {
7013 tree instantiation;
7014 tree targs;
7017 /* We're only looking for templates. */
7022 /* We're not looking for a non-static member, and this is
7023 one, or vice versa. */
7026 /* Try to do argument deduction. */
7031 /* Argument deduction failed. */
7034 /* Instantiate the template. */
7037 /* Instantiation failed. */
7040 /* See if there's a match. */
7043 }
7045 /* Now, remove all but the most specialized of the matches. */
7047 {
7052 NULL_TREE,
7053 NULL_TREE);
7054 }
7055 }
7057 /* Now we should have exactly one function in MATCHES. */
7059 {
7060 /* There were *no* matches. */
7062 {
7065 target_type);
7068 }
7070 }
7072 {
7073 /* There were too many matches. First check if they're all
7074 the same function. */
7075 tree match;
7083 {
7085 {
7088 target_type);
7090 /* Since print_candidates expects the functions in the
7091 TREE_VALUE slot, we flip them here. */
7096 }
7099 }
7100 }
7102 /* Good, exactly one match. Now, convert it to the correct type. */
7107 {
7115 {
7118 }
7119 }
7121 /* If we're doing overload resolution purely for the purpose of
7122 determining conversion sequences, we should not consider the
7123 function used. If this conversion sequence is selected, the
7124 function will be marked as used at this point. */
7126 {
7127 /* Make =delete work with SFINAE. */
7132 }
7134 /* We could not check access to member functions when this
7135 expression was originally created since we did not know at that
7136 time to which function the expression referred. */
7139 {
7142 }
7146 else
7147 {
7148 /* The target must be a REFERENCE_TYPE. Above, cp_build_unary_op
7149 will mark the function as addressed, but here we must do it
7150 explicitly. */
7154 }
7155 }
7157 /* This function will instantiate the type of the expression given in
7158 RHS to match the type of LHSTYPE. If errors exist, then return
7159 error_mark_node. FLAGS is a bit mask. If TF_ERROR is set, then
7160 we complain on errors. If we are not complaining, never modify rhs,
7161 as overload resolution wants to try many possible instantiations, in
7162 the hope that at least one will work.
7164 For non-recursive calls, LHSTYPE should be a function, pointer to
7165 function, or a pointer to member function. */
7167 tree
7169 {
7176 {
7180 }
7183 {
7189 /* Microsoft allows `A::f' to be resolved to a
7190 pointer-to-member. */
7191 ;
7192 else
7193 {
7198 }
7199 }
7202 {
7205 }
7207 /* If we are in a template, and have a NON_DEPENDENT_EXPR, we cannot
7208 deduce any type information. */
7210 {
7214 }
7216 /* There only a few kinds of expressions that may have a type
7217 dependent on overload resolution. */
7223 /* This should really only be used when attempting to distinguish
7224 what sort of a pointer to function we have. For now, any
7225 arithmetic operation which is not supported on pointers
7226 is rejected as an error. */
7229 {
7231 {
7237 /* Do not lose object's side effects. */
7241 }
7248 /* This can happen if we are forming a pointer-to-member for a
7249 member template. */
7252 /* Fall through. */
7255 {
7259 return
7263 }
7267 return
7271 access_path);
7274 {
7279 }
7286 }
7288 }
7289 \f
7290 /* Return the name of the virtual function pointer field
7291 (as an IDENTIFIER_NODE) for the given TYPE. Note that
7292 this may have to look back through base types to find the
7293 ultimate field name. (For single inheritance, these could
7294 all be the same name. Who knows for multiple inheritance). */
7296 static tree
7298 {
7305 {
7311 }
7319 }
7321 void
7323 {
7324 #ifdef GATHER_STATISTICS
7328 {
7333 }
7334 #endif
7335 }
7337 /* Build a dummy reference to ourselves so Derived::Base (and A::A) works,
7338 according to [class]:
7339 The class-name is also inserted
7340 into the scope of the class itself. For purposes of access checking,
7341 the inserted class name is treated as if it were a public member name. */
7343 void
7345 {
7348 tree saved_cas;
7363 }
7365 /* Returns 1 if TYPE contains only padding bytes. */
7367 int
7369 {
7376 /* In G++ 3.2, whether or not a class was empty was determined by
7377 looking at its size. */
7380 else
7382 }
7384 /* Returns true if TYPE contains an empty class. */
7386 static bool
7388 {
7392 {
7393 tree field;
7394 tree binfo;
7395 tree base_binfo;
7407 }
7411 }
7413 /* Returns true if TYPE contains no actual data, just various
7414 possible combinations of empty classes and possibly a vptr. */
7416 bool
7418 {
7420 {
7421 tree field;
7422 tree binfo;
7423 tree base_binfo;
7426 /* CLASSTYPE_EMPTY_P isn't set properly until the class is actually laid
7427 out, but we'd like to be able to check this before then. */
7441 }
7445 }
7447 /* Note that NAME was looked up while the current class was being
7448 defined and that the result of that lookup was DECL. */
7450 void
7452 {
7453 splay_tree names_used;
7455 /* If we're not defining a class, there's nothing to do. */
7461 /* If there's already a binding for this NAME, then we don't have
7462 anything to worry about. */
7475 }
7477 /* Note that NAME was declared (as DECL) in the current class. Check
7478 to see that the declaration is valid. */
7480 void
7482 {
7483 splay_tree names_used;
7484 splay_tree_node n;
7486 /* Look to see if we ever used this name. */
7487 names_used
7491 /* The C language allows members to be declared with a type of the same
7492 name, and the C++ standard says this diagnostic is not required. So
7493 allow it in extern "C" blocks unless predantic is specified.
7494 Allow it in all cases if -ms-extensions is specified. */
7500 {
7501 /* [basic.scope.class]
7503 A name N used in a class S shall refer to the same declaration
7504 in its context and when re-evaluated in the completed scope of
7505 S. */
7509 }
7510 }
7512 /* Returns the VAR_DECL for the complete vtable associated with BINFO.
7513 Secondary vtables are merged with primary vtables; this function
7514 will return the VAR_DECL for the primary vtable. */
7516 tree
7518 {
7519 tree decl;
7523 {
7526 }
7530 }
7533 /* Returns the binfo for the primary base of BINFO. If the resulting
7534 BINFO is a virtual base, and it is inherited elsewhere in the
7535 hierarchy, then the returned binfo might not be the primary base of
7536 BINFO in the complete object. Check BINFO_PRIMARY_P or
7537 BINFO_LOST_PRIMARY_P to be sure. */
7539 static tree
7541 {
7542 tree primary_base;
7549 }
7551 /* If INDENTED_P is zero, indent to INDENT. Return nonzero. */
7553 static int
7555 {
7559 }
7561 /* Dump the offsets of all the bases rooted at BINFO to STREAM.
7562 INDENT should be zero when called from the top level; it is
7563 incremented recursively. IGO indicates the next expected BINFO in
7564 inheritance graph ordering. */
7566 static tree
7569 tree binfo,
7570 tree igo,
7572 {
7574 tree base_binfo;
7582 {
7585 }
7600 {
7604 TFF_PLAIN_IDENTIFIER),
7606 }
7608 {
7611 }
7616 {
7620 {
7624 TFF_PLAIN_IDENTIFIER));
7625 }
7627 {
7631 TFF_PLAIN_IDENTIFIER));
7632 }
7634 {
7638 TFF_PLAIN_IDENTIFIER));
7639 }
7641 {
7645 TFF_PLAIN_IDENTIFIER));
7646 }
7650 }
7656 }
7658 /* Dump the BINFO hierarchy for T. */
7660 static void
7662 {
7674 }
7676 /* Debug interface to hierarchy dumping. */
7678 void
7680 {
7682 }
7684 static void
7686 {
7691 {
7694 }
7695 }
7697 static void
7699 {
7700 tree value;
7702 HOST_WIDE_INT elt;
7710 TFF_PLAIN_IDENTIFIER));
7717 }
7719 static void
7721 {
7729 {
7736 {
7740 }
7744 }
7747 }
7749 static void
7751 {
7759 {
7764 }
7767 }
7769 /* Dump a function or thunk and its thunkees. */
7771 static void
7773 {
7776 tree thunks;
7784 {
7794 else
7800 }
7804 }
7806 /* Dump the thunks for FN. */
7808 void
7810 {
7812 }
7814 /* Virtual function table initialization. */
7816 /* Create all the necessary vtables for T and its base classes. */
7818 static void
7820 {
7821 tree vbase;
7825 /* We lay out the primary and secondary vtables in one contiguous
7826 vtable. The primary vtable is first, followed by the non-virtual
7827 secondary vtables in inheritance graph order. */
7831 /* Then come the virtual bases, also in inheritance graph order. */
7833 {
7837 }
7841 }
7843 /* Initialize the vtable for BINFO with the INITS. */
7845 static void
7847 {
7848 tree decl;
7854 }
7856 /* Build the VTT (virtual table table) for T.
7857 A class requires a VTT if it has virtual bases.
7859 This holds
7860 1 - primary virtual pointer for complete object T
7861 2 - secondary VTTs for each direct non-virtual base of T which requires a
7862 VTT
7863 3 - secondary virtual pointers for each direct or indirect base of T which
7864 has virtual bases or is reachable via a virtual path from T.
7865 4 - secondary VTTs for each direct or indirect virtual base of T.
7867 Secondary VTTs look like complete object VTTs without part 4. */
7869 static void
7871 {
7872 tree type;
7873 tree vtt;
7874 tree index;
7877 /* Build up the initializers for the VTT. */
7882 /* If we didn't need a VTT, we're done. */
7886 /* Figure out the type of the VTT. */
7890 /* Now, build the VTT object itself. */
7893 /* Add the VTT to the vtables list. */
7898 }
7900 /* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
7901 PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
7902 and CHAIN the vtable pointer for this binfo after construction is
7903 complete. VALUE can also be another BINFO, in which case we recurse. */
7905 static tree
7907 {
7908 tree vt;
7911 {
7917 else
7919 }
7922 }
7924 /* Data for secondary VTT initialization. */
7926 {
7927 /* Is this the primary VTT? */
7930 /* Current index into the VTT. */
7931 tree index;
7933 /* Vector of initializers built up. */
7936 /* The type being constructed by this secondary VTT. */
7937 tree type_being_constructed;
7940 /* Recursively build the VTT-initializer for BINFO (which is in the
7941 hierarchy dominated by T). INITS points to the end of the initializer
7942 list to date. INDEX is the VTT index where the next element will be
7943 replaced. Iff BINFO is the binfo for T, this is the top level VTT (i.e.
7944 not a subvtt for some base of T). When that is so, we emit the sub-VTTs
7945 for virtual bases of T. When it is not so, we build the constructor
7946 vtables for the BINFO-in-T variant. */
7948 static void
7950 {
7952 tree b;
7953 tree init;
7954 secondary_vptr_vtt_init_data data;
7957 /* We only need VTTs for subobjects with virtual bases. */
7961 /* We need to use a construction vtable if this is not the primary
7962 VTT. */
7964 {
7967 /* Record the offset in the VTT where this sub-VTT can be found. */
7969 }
7971 /* Add the address of the primary vtable for the complete object. */
7975 {
7978 }
7981 /* Recursively add the secondary VTTs for non-virtual bases. */
7986 /* Add secondary virtual pointers for all subobjects of BINFO with
7987 either virtual bases or reachable along a virtual path, except
7988 subobjects that are non-virtual primary bases. */
7998 /* data.inits might have grown as we added secondary virtual pointers.
7999 Make sure our caller knows about the new vector. */
8003 /* Add the secondary VTTs for virtual bases in inheritance graph
8004 order. */
8006 {
8011 }
8012 else
8013 /* Remove the ctor vtables we created. */
8015 }
8017 /* Called from build_vtt_inits via dfs_walk. BINFO is the binfo for the base
8018 in most derived. DATA is a SECONDARY_VPTR_VTT_INIT_DATA structure. */
8020 static tree
8022 {
8025 /* We don't care about bases that don't have vtables. */
8029 /* We're only interested in proper subobjects of the type being
8030 constructed. */
8034 /* We're only interested in bases with virtual bases or reachable
8035 via a virtual path from the type being constructed. */
8040 /* We're not interested in non-virtual primary bases. */
8044 /* Record the index where this secondary vptr can be found. */
8046 {
8051 {
8052 /* It's a primary virtual base, and this is not a
8053 construction vtable. Find the base this is primary of in
8054 the inheritance graph, and use that base's vtable
8055 now. */
8058 }
8059 }
8061 /* Add the initializer for the secondary vptr itself. */
8064 /* Advance the vtt index. */
8069 }
8071 /* Called from build_vtt_inits via dfs_walk. After building
8072 constructor vtables and generating the sub-vtt from them, we need
8073 to restore the BINFO_VTABLES that were scribbled on. DATA is the
8074 binfo of the base whose sub vtt was generated. */
8076 static tree
8078 {
8082 /* If this class has no vtable, none of its bases do. */
8086 /* This might be a primary base, so have no vtable in this
8087 hierarchy. */
8090 /* If we scribbled the construction vtable vptr into BINFO, clear it
8091 out now. */
8097 }
8099 /* Build the construction vtable group for BINFO which is in the
8100 hierarchy dominated by T. */
8102 static void
8104 {
8105 tree type;
8106 tree vtbl;
8107 tree id;
8108 tree vbase;
8111 /* See if we've already created this construction vtable group. */
8117 /* Build a version of VTBL (with the wrong type) for use in
8118 constructing the addresses of secondary vtables in the
8119 construction vtable group. */
8127 /* Add the vtables for each of our virtual bases using the vbase in T
8128 binfo. */
8130 vbase;
8132 {
8133 tree b;
8140 }
8142 /* Figure out the type of the construction vtable. */
8150 /* Initialize the construction vtable. */
8154 }
8156 /* Add the vtbl initializers for BINFO (and its bases other than
8157 non-virtual primaries) to the list of INITS. BINFO is in the
8158 hierarchy dominated by T. RTTI_BINFO is the binfo within T of
8159 the constructor the vtbl inits should be accumulated for. (If this
8160 is the complete object vtbl then RTTI_BINFO will be TYPE_BINFO (T).)
8161 ORIG_BINFO is the binfo for this object within BINFO_TYPE (RTTI_BINFO).
8162 BINFO is the active base equivalent of ORIG_BINFO in the inheritance
8163 graph of T. Both BINFO and ORIG_BINFO will have the same BINFO_TYPE,
8164 but are not necessarily the same in terms of layout. */
8166 static void
8168 tree orig_binfo,
8169 tree rtti_binfo,
8170 tree vtbl,
8171 tree t,
8173 {
8175 tree base_binfo;
8180 /* If it doesn't have a vptr, we don't do anything. */
8184 /* If we're building a construction vtable, we're not interested in
8185 subobjects that don't require construction vtables. */
8191 /* Build the initializers for the BINFO-in-T vtable. */
8194 /* Walk the BINFO and its bases. We walk in preorder so that as we
8195 initialize each vtable we can figure out at what offset the
8196 secondary vtable lies from the primary vtable. We can't use
8197 dfs_walk here because we need to iterate through bases of BINFO
8198 and RTTI_BINFO simultaneously. */
8200 {
8201 /* Skip virtual bases. */
8207 inits);
8208 }
8209 }
8211 /* Called from accumulate_vtbl_inits. Adds the initializers for the
8212 BINFO vtable to L. */
8214 static void
8216 tree orig_binfo,
8217 tree rtti_binfo,
8218 tree orig_vtbl,
8219 tree t,
8221 {
8228 {
8229 /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a
8230 primary virtual base. If it is not the same primary in
8231 the hierarchy of T, we'll need to generate a ctor vtable
8232 for it, to place at its location in T. If it is the same
8233 primary, we still need a VTT entry for the vtable, but it
8234 should point to the ctor vtable for the base it is a
8235 primary for within the sub-hierarchy of RTTI_BINFO.
8237 There are three possible cases:
8239 1) We are in the same place.
8240 2) We are a primary base within a lost primary virtual base of
8241 RTTI_BINFO.
8242 3) We are primary to something not a base of RTTI_BINFO. */
8244 tree b;
8247 /* First, look through the bases we are primary to for RTTI_BINFO
8248 or a virtual base. */
8251 {
8256 }
8257 /* If we run out of primary links, keep looking down our
8258 inheritance chain; we might be an indirect primary. */
8262 found:
8264 /* If we found RTTI_BINFO, this is case 1. If we found a virtual
8265 base B and it is a base of RTTI_BINFO, this is case 2. In
8266 either case, we share our vtable with LAST, i.e. the
8267 derived-most base within B of which we are a primary. */
8270 /* Just set our BINFO_VTABLE to point to LAST, as we may not have
8271 set LAST's BINFO_VTABLE yet. We'll extract the actual vptr in
8272 binfo_ctor_vtable after everything's been set up. */
8275 /* Otherwise, this is case 3 and we get our own. */
8276 }
8283 {
8284 tree index;
8287 /* Add the initializer for this vtable. */
8291 /* Figure out the position to which the VPTR should point. */
8297 }
8300 /* For a construction vtable, we can't overwrite BINFO_VTABLE.
8301 So, we make a TREE_LIST. Later, dfs_fixup_binfo_vtbls will
8302 straighten this out. */
8305 /* Throw away any unneeded intializers. */
8307 else
8308 /* For an ordinary vtable, set BINFO_VTABLE. */
8310 }
8314 /* Construct the initializer for BINFO's virtual function table. BINFO
8315 is part of the hierarchy dominated by T. If we're building a
8316 construction vtable, the ORIG_BINFO is the binfo we should use to
8317 find the actual function pointers to put in the vtable - but they
8318 can be overridden on the path to most-derived in the graph that
8319 ORIG_BINFO belongs. Otherwise,
8320 ORIG_BINFO should be the same as BINFO. The RTTI_BINFO is the
8321 BINFO that should be indicated by the RTTI information in the
8322 vtable; it will be a base class of T, rather than T itself, if we
8323 are building a construction vtable.
8325 The value returned is a TREE_LIST suitable for wrapping in a
8326 CONSTRUCTOR to use as the DECL_INITIAL for a vtable. If
8327 NON_FN_ENTRIES_P is not NULL, *NON_FN_ENTRIES_P is set to the
8328 number of non-function entries in the vtable.
8330 It might seem that this function should never be called with a
8331 BINFO for which BINFO_PRIMARY_P holds, the vtable for such a
8332 base is always subsumed by a derived class vtable. However, when
8333 we are building construction vtables, we do build vtables for
8334 primary bases; we need these while the primary base is being
8335 constructed. */
8337 static void
8339 tree orig_binfo,
8340 tree t,
8341 tree rtti_binfo,
8344 {
8345 tree v;
8346 vtbl_init_data vid;
8348 tree vbinfo;
8352 /* Initialize VID. */
8360 /* The first vbase or vcall offset is at index -3 in the vtable. */
8363 /* Add entries to the vtable for RTTI. */
8366 /* Create an array for keeping track of the functions we've
8367 processed. When we see multiple functions with the same
8368 signature, we share the vcall offsets. */
8370 /* Add the vcall and vbase offset entries. */
8373 /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
8374 build_vbase_offset_vtbl_entries. */
8379 /* If the target requires padding between data entries, add that now. */
8381 {
8387 /* Move data entries into their new positions and add padding
8388 after the new positions. Iterate backwards so we don't
8389 overwrite entries that we would need to process later. */
8392 ix--)
8393 {
8401 {
8406 null_pointer_node);
8407 }
8408 }
8409 }
8414 /* The initializers for virtual functions were built up in reverse
8415 order. Straighten them out and add them to the running list in one
8416 step. */
8426 /* Go through all the ordinary virtual functions, building up
8427 initializers. */
8429 {
8430 tree delta;
8431 tree vcall_index;
8438 {
8442 {
8445 }
8447 }
8449 /* If the only definition of this function signature along our
8450 primary base chain is from a lost primary, this vtable slot will
8451 never be used, so just zero it out. This is important to avoid
8452 requiring extra thunks which cannot be generated with the function.
8454 We first check this in update_vtable_entry_for_fn, so we handle
8455 restored primary bases properly; we also need to do it here so we
8456 zero out unused slots in ctor vtables, rather than filling them
8457 with erroneous values (though harmless, apart from relocation
8458 costs). */
8463 {
8464 /* Pull the offset for `this', and the function to call, out of
8465 the list. */
8472 /* You can't call an abstract virtual function; it's abstract.
8473 So, we replace these functions with __pure_virtual. */
8475 {
8478 {
8480 abort_fndecl_addr
8484 }
8485 }
8486 /* Likewise for deleted virtuals. */
8488 {
8493 NULL_TREE);
8497 }
8498 else
8499 {
8501 {
8505 }
8506 /* Take the address of the function, considering it to be of an
8507 appropriate generic type. */
8511 }
8512 }
8514 /* And add it to the chain of initializers. */
8516 {
8521 else
8523 {
8529 }
8530 }
8531 else
8533 }
8534 }
8536 /* Adds to vid->inits the initializers for the vbase and vcall
8537 offsets in BINFO, which is in the hierarchy dominated by T. */
8539 static void
8541 {
8542 tree b;
8544 /* If this is a derived class, we must first create entries
8545 corresponding to the primary base class. */
8550 /* Add the vbase entries for this base. */
8552 /* Add the vcall entries for this base. */
8554 }
8556 /* Returns the initializers for the vbase offset entries in the vtable
8557 for BINFO (which is part of the class hierarchy dominated by T), in
8558 reverse order. VBASE_OFFSET_INDEX gives the vtable index
8559 where the next vbase offset will go. */
8561 static void
8563 {
8564 tree vbase;
8565 tree t;
8566 tree non_primary_binfo;
8568 /* If there are no virtual baseclasses, then there is nothing to
8569 do. */
8575 /* We might be a primary base class. Go up the inheritance hierarchy
8576 until we find the most derived class of which we are a primary base:
8577 it is the offset of that which we need to use. */
8580 {
8581 tree b;
8583 /* If we have reached a virtual base, then it must be a primary
8584 base (possibly multi-level) of vid->binfo, or we wouldn't
8585 have called build_vcall_and_vbase_vtbl_entries for it. But it
8586 might be a lost primary, so just skip down to vid->binfo. */
8588 {
8591 }
8597 }
8599 /* Go through the virtual bases, adding the offsets. */
8601 vbase;
8603 {
8604 tree b;
8605 tree delta;
8610 /* Find the instance of this virtual base in the complete
8611 object. */
8614 /* If we've already got an offset for this virtual base, we
8615 don't need another one. */
8620 /* Figure out where we can find this vbase offset. */
8629 /* The vbase offset had better be the same. */
8632 /* The next vbase will come at a more negative offset. */
8636 /* The initializer is the delta from BINFO to this virtual base.
8637 The vbase offsets go in reverse inheritance-graph order, and
8638 we are walking in inheritance graph order so these end up in
8639 the right order. */
8646 }
8647 }
8649 /* Adds the initializers for the vcall offset entries in the vtable
8650 for BINFO (which is part of the class hierarchy dominated by VID->DERIVED)
8651 to VID->INITS. */
8653 static void
8655 {
8656 /* We only need these entries if this base is a virtual base. We
8657 compute the indices -- but do not add to the vtable -- when
8658 building the main vtable for a class. */
8661 /* If BINFO is RTTI_BINFO, then (since BINFO does not
8662 correspond to VID->DERIVED), we are building a primary
8663 construction virtual table. Since this is a primary
8664 virtual table, we do not need the vcall offsets for
8665 BINFO. */
8667 {
8668 /* We need a vcall offset for each of the virtual functions in this
8669 vtable. For example:
8671 class A { virtual void f (); };
8672 class B1 : virtual public A { virtual void f (); };
8673 class B2 : virtual public A { virtual void f (); };
8674 class C: public B1, public B2 { virtual void f (); };
8676 A C object has a primary base of B1, which has a primary base of A. A
8677 C also has a secondary base of B2, which no longer has a primary base
8678 of A. So the B2-in-C construction vtable needs a secondary vtable for
8679 A, which will adjust the A* to a B2* to call f. We have no way of
8680 knowing what (or even whether) this offset will be when we define B2,
8681 so we store this "vcall offset" in the A sub-vtable and look it up in
8682 a "virtual thunk" for B2::f.
8684 We need entries for all the functions in our primary vtable and
8685 in our non-virtual bases' secondary vtables. */
8687 /* If we are just computing the vcall indices -- but do not need
8688 the actual entries -- not that. */
8691 /* Now, walk through the non-virtual bases, adding vcall offsets. */
8693 }
8694 }
8696 /* Build vcall offsets, starting with those for BINFO. */
8698 static void
8700 {
8702 tree primary_binfo;
8703 tree base_binfo;
8705 /* Don't walk into virtual bases -- except, of course, for the
8706 virtual base for which we are building vcall offsets. Any
8707 primary virtual base will have already had its offsets generated
8708 through the recursion in build_vcall_and_vbase_vtbl_entries. */
8712 /* If BINFO has a primary base, process it first. */
8717 /* Add BINFO itself to the list. */
8720 /* Scan the non-primary bases of BINFO. */
8724 }
8726 /* Called from build_vcall_offset_vtbl_entries_r. */
8728 static void
8730 {
8731 /* Make entries for the rest of the virtuals. */
8733 {
8734 tree orig_fn;
8736 /* The ABI requires that the methods be processed in declaration
8737 order. G++ 3.2 used the order in the vtable. */
8739 orig_fn;
8743 }
8744 else
8745 {
8746 tree derived_virtuals;
8747 tree base_virtuals;
8748 tree orig_virtuals;
8749 /* If BINFO is a primary base, the most derived class which has
8750 BINFO as a primary base; otherwise, just BINFO. */
8751 tree non_primary_binfo;
8753 /* We might be a primary base class. Go up the inheritance hierarchy
8754 until we find the most derived class of which we are a primary base:
8755 it is the BINFO_VIRTUALS there that we need to consider. */
8758 {
8759 tree b;
8761 /* If we have reached a virtual base, then it must be vid->vbase,
8762 because we ignore other virtual bases in
8763 add_vcall_offset_vtbl_entries_r. In turn, it must be a primary
8764 base (possibly multi-level) of vid->binfo, or we wouldn't
8765 have called build_vcall_and_vbase_vtbl_entries for it. But it
8766 might be a lost primary, so just skip down to vid->binfo. */
8768 {
8772 }
8778 }
8781 /* For a ctor vtable we need the equivalent binfo within the hierarchy
8782 where rtti_binfo is the most derived type. */
8783 non_primary_binfo
8789 base_virtuals;
8793 {
8794 tree orig_fn;
8796 /* Find the declaration that originally caused this function to
8797 be present in BINFO_TYPE (binfo). */
8800 /* When processing BINFO, we only want to generate vcall slots for
8801 function slots introduced in BINFO. So don't try to generate
8802 one if the function isn't even defined in BINFO. */
8807 }
8808 }
8809 }
8811 /* Add a vcall offset entry for ORIG_FN to the vtable. */
8813 static void
8815 {
8817 tree vcall_offset;
8818 tree derived_entry;
8820 /* If there is already an entry for a function with the same
8821 signature as FN, then we do not need a second vcall offset.
8822 Check the list of functions already present in the derived
8823 class vtable. */
8825 {
8827 /* We only use one vcall offset for virtual destructors,
8828 even though there are two virtual table entries. */
8832 }
8834 /* If we are building these vcall offsets as part of building
8835 the vtable for the most derived class, remember the vcall
8836 offset. */
8838 {
8841 NULL);
8844 }
8846 /* The next vcall offset will be found at a more negative
8847 offset. */
8851 /* Keep track of this function. */
8855 {
8856 tree base;
8857 tree fn;
8859 /* Find the overriding function. */
8863 else
8864 {
8867 /* The vbase we're working on is a primary base of
8868 vid->binfo. But it might be a lost primary, so its
8869 BINFO_OFFSET might be wrong, so we just use the
8870 BINFO_OFFSET from vid->binfo. */
8876 vcall_offset);
8877 }
8878 /* Add the initializer to the vtable. */
8880 }
8881 }
8883 /* Return vtbl initializers for the RTTI entries corresponding to the
8884 BINFO's vtable. The RTTI entries should indicate the object given
8885 by VID->rtti_binfo. */
8887 static void
8889 {
8890 tree b;
8891 tree t;
8892 tree offset;
8893 tree decl;
8894 tree init;
8898 /* To find the complete object, we will first convert to our most
8899 primary base, and then add the offset in the vtbl to that value. */
8903 {
8904 tree primary_base;
8910 }
8914 /* The second entry is the address of the typeinfo object. */
8917 else
8920 /* Convert the declaration to a type that can be stored in the
8921 vtable. */
8925 /* Add the offset-to-top entry. It comes earlier in the vtable than
8926 the typeinfo entry. Convert the offset to look like a
8927 function pointer, so that we can put it in the vtable. */
8930 }