5.12.5.2.2.2.1.3.11. Finish the derived RECORD_TYPE – finish vtable
For our example of template instantiation, it contains no vtable as no virtual functions and virtual bases involved (C++ probits template from having virtual function, but can be used as virtual base). However, concept of polymophism is so important, it worths a deep looking here. So following discussion uses example 1 and 2 in previous section.
At line 5159, CLASSTYPE_VFIELDS is the list of virtual table fields that this type contains (both the primary and secondary). The TREE_VALUE is the class type where the vtable field was introduced. For a vtable field inherited from the primary base, or introduced by this class, the TREE_PURPOSE (aliases by VF_BINFO_VALUE) is NULL. For other vtable fields (those from non-primary bases), the TREE_PURPOSE is the BINFO of the base through which the vtable was inherited. TREE_ADDRESSABLE is set for such vtable fields.
finish_struct_1 (continue)
5129 /* Complete the rtl for any static member objects of the type we're
5130 working on. */
5131 for (x = TYPE_FIELDS (t); x; x = TREE_CHAIN (x))
5132 if (TREE_CODE (x) == VAR_DECL && TREE_STATIC (x)
5133 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (x)), t))
5134 DECL_MODE (x) = TYPE_MODE (t);
5135
5136 /* Done with FIELDS...now decide whether to sort these for
5137 faster lookups later.
5138
5139 We use a small number because most searches fail (succeeding
5140 ultimately as the search bores through the inheritance
5141 hierarchy), and we want this failure to occur quickly. */
5142
5143 n_fields = count_fields (TYPE_FIELDS (t));
5144 if (n_fields > 7)
5145 {
5146 struct sorted_fields_type *field_vec = ggc_alloc (sizeof (struct sorted_fields_type)
5147 + n_fields * sizeof (tree));
5148 field_vec->len = n_fields;
5149 add_fields_to_record_type (TYPE_FIELDS (t), field_vec, 0);
5150 qsort (field_vec->elts, n_fields, sizeof (tree),
5151 field_decl_cmp);
5152 if (! DECL_LANG_SPECIFIC (TYPE_MAIN_DECL (t)))
5153 retrofit_lang_decl (TYPE_MAIN_DECL (t));
5154 DECL_SORTED_FIELDS (TYPE_MAIN_DECL (t)) = field_vec;
5155 }
5156
5157 if (TYPE_HAS_CONSTRUCTOR (t))
5158 {
5159 tree vfields = CLASSTYPE_VFIELDS (t);
5160
5161 for (vfields = CLASSTYPE_VFIELDS (t);
5162 vfields; vfields = TREE_CHAIN (vfields))
5163 /* Mark the fact that constructor for T could affect anybody
5164 inheriting from T who wants to initialize vtables for
5165 VFIELDS's type. */
5166 if (VF_BINFO_VALUE (vfields))
5167 TREE_ADDRESSABLE (vfields) = 1;
5168 }
5169
5170 /* Make the rtl for any new vtables we have created, and unmark
5171 the base types we marked. */
5172 finish_vtbls (t);
For class contains vtable, compiler will enlarge this table to include extra entries that necessary for polymorphism and give out the way to initialize this table. It is a very complex procedure and embodies exquisite consideration. Again we use examples in previous section. At first, let’s see the real output generated by GCC.
Example 1:
Vtable for A
A::_ZTV1A: 3u entries
0 (int (*)(...))0 // vcall offset
4 (int (*)(...))(& _ZTI1A)
8 A ::f // slot for A::f
…
Vtable for B1
B1::_ZTV2B1: 6u entries
0 0u // vbase offset
4 0u // vcall offset
8 (int (*)(...))0
12 (int (*)(...))(& _ZTI2B1)
16 B1::_ZTcv0_n12_v0_n16_N2B11fEv // slot for B1::A::f
20 B1::f // slot for B1::f
…
Vtable for B2
B2::_ZTV2B2: 6u entries
0 0u // vbase offset
4 0u // vcall offset
8 (int (*)(...))0
12 (int (*)(...))(& _ZTI2B2)
16 B2::_ZTcv0_n12_v0_n16_N2B21fEv // slot for B2::A::f
20 B2::f // slot for B2::f
…
Vtable for C
C::_ZTV1C: 12u entries
0 0u // vbase offset
4 0u // vcall offset
8 (int (*)(...))0
12 (int (*)(...))(& _ZTI1C)
16 C ::_ZTcv0_n12_v0_n16_N1C1fEv // slot for C::B1::A::f
20 C ::f // slot for C::f
24 -4u
28 -4u
32 (int (*)(...))-0x000000004
36 (int (*)(...))(& _ZTI1C)
40 C ::_ZTcvn4_n12_v0_n16_N1C1fEv // slot for C::B2::A::f
44 C ::_ZTchn4_h4_N1C1fEv // slot for C::B2::f
In the output “B1::_ZTV2B1: 6u entries”, prefix “_Z” is the common prefix used by GCC, and preifx “TV” is used for vtable, “2” is the size of the name of the class, and “B1” is the name of the class, then “6u” tells the size of the vtable.
And in “B1::_ZTcv0_n12_v0_n16_N2B11fEv”, prefix “_ZTc” is used for thunk of this-adjustment or/and result-adjustment; “v0_n12_” tells the this-adjustment, which follows the formular “v<fixed offset number>_<virtual offset number>_” and “n12” stands for “-12”, in which “n” stands for negative (this value added to the address of vptr to get the entry of the vtable which contains the value of the real adjustment); then “v0_n16_” is the result-adjustment; next “N2B11fE”, “N…E” means nested name present, and “2B11f” is the nested name “B1::f”; the last part “v” means the the function has parameter of void.
Next “C::_ZTchn4_h4_N1C1fEv” is a covariant thunk, “hn4_” is the form of “h<fixed offset number>_”, and “h4_” is the nested thunk.
Then in “_ZTI2B1”, prefix “TI” stands for type-info; in “2B1”, “2” is the length of “B1”, and “B1” is the class the type-info corresponding for.
Now think why it needs such arrangement? Consider an expression: “p->func();” p is a pointer of base type but points to derived, and func is virtual defined in base and derived. As result of member lookup, func defined in base would be found out because it search the member in base referred by p instead of in derived. However, in runtime the function gotten executed should be that defined in derived. Though in runtime we can use the virutal function defined in derived via vtable, but at point of invocation, in the arguments list, the implicit “this” argument and the returned value are tailored for func in the base, which are not the derived virtual wants and will make code generation later incorrect and lead to unexpected runtime result. So thunks here will do the necessary adjustments to set up the correct environment for the virtual really invoked.
Below code reveals the detail in constructing vtable above, in which we just focus on the handling of class C.
6762 static void
6763 finish_vtbls (tree t) in class.c
6764 {
6765 tree list;
6766 tree vbase;
6767
6768 /* We lay out the primary and secondary vtables in one contiguous
6769 vtable. The primary vtable is first, followed by the non-virtual
6770 secondary vtables in inheritance graph order. */
6771 list = build_tree_list (TYPE_BINFO_VTABLE (t), NULL_TREE);
6772 accumulate_vtbl_inits (TYPE_BINFO (t), TYPE_BINFO (t),
6773 TYPE_BINFO (t), t, list);
6774
6775 /* Then come the virtual bases, also in inheritance graph order. */
6776 for (vbase = TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))
6777 {
6778 if (!TREE_VIA_VIRTUAL (vbase))
6779 continue ;
6780 accumulate_vtbl_inits (vbase, vbase, TYPE_BINFO (t), t, list);
6781 }
6782
6783 if (TYPE_BINFO_VTABLE (t))
6784 initialize_vtable (TYPE_BINFO (t), TREE_VALUE (list));
6785 }
If it is the handling of class C, then above argument t is the RECORD_TYPE of C ; and TYPE_BINFO_VTABLE(t) is the C’s vtable object. At line 6771, list is a tree_list node, in its TREE_PURPOSE field is this vtable object, while TREE_VALUE field is empty temperarily (dfs_accumulate_vtbl_inits below will fill it). In below function, at line 7167 ctor_vtbl_p is used to control the creation of constructor vtable group (during building VTT), under our circumstance here as rtti_binfo is gotten from TYPE_BINFO (t ), ctor_vtbl_p is 0.
Pay attention to the order of invocation of accumulate_vtbl_inits , it ensures that the virtual bases are handled in the last.
7159 static void
7160 accumulate_vtbl_inits (tree binfo, in class.c
7161 tree orig_binfo,
7162 tree rtti_binfo,
7163 tree t,
7164 tree inits)
7165 {
7166 int i;
7167 int ctor_vtbl_p = !same_type_p (BINFO_TYPE (rtti_binfo), t);
7168
7169 my_friendly_assert (same_type_p (BINFO_TYPE (binfo),
7170 BINFO_TYPE (orig_binfo)),
7171 20000517);
7172
7173 /* If it doesn't have a vptr, we don't do anything. */
7174 if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
7175 return ;
7176
7177 /* If we're building a construction vtable, we're not interested in
7178 subobjects that don't require construction vtables. */
7179 if (ctor_vtbl_p
7180 && !TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo))
7181 && !binfo_via_virtual (orig_binfo, BINFO_TYPE (rtti_binfo)))
7182 return ;
7183
7184 /* Build the initializers for the BINFO-in-T vtable. */
7185 TREE_VALUE (inits)
7186 = chainon (TREE_VALUE (inits),
7187 dfs_accumulate_vtbl_inits (binfo, orig_binfo,
7188 rtti_binfo, t, inits));
7189
7190 /* Walk the BINFO and its bases. We walk in preorder so that as we
7191 initialize each vtable we can figure out at what offset the
7192 secondary vtable lies from the primary vtable. We can't use
7193 dfs_walk here because we need to iterate through bases of BINFO
7194 and RTTI_BINFO simultaneously. */
7195 for (i = 0; i < BINFO_N_BASETYPES (binfo); ++i)
7196 {
7197 tree base_binfo = BINFO_BASETYPE (binfo, i);
7198
7199 /* Skip virtual bases. */
7200 if (TREE_VIA_VIRTUAL (base_binfo))
7201 continue ;
7202 accumulate_vtbl_inits (base_binfo,
7203 BINFO_BASETYPE (orig_binfo, i),
7204 rtti_binfo, t,
7205 inits);
7206 }
7207 }
See that both binfo and orig_binfo are binfos of the same type, but are not necessarily the same in terms of layout (here they are the strictly same one). Assertion at line 7169 checks for this pre-condition.
For class C, ctor_vtbl_p below is false. And if predicate BINFO_NEW_VTABLE_MARKED fails, it says that the base hasn’t vtable prepared. Remember that in above inheritance tree walk taken by dfs_modify_vtables , non-virtual primary bases are skipped and haven’t vtables prepared, as result, BINFO_NEW_VTABLE_MARKED fails for these bases, and exits at line 7274.
Below we display example in former section again:
class A { virtual A* f (); };
class B1 : virtual public A { virtual B1* f (); };
class B2 : virtual public A { virtual B2* f (); };
class C: public B1, public B2 { virtual C* f (); };
The processing order will be C, B1 will be skipped by dfs_accumulate_vtbl_inits , then B2, and next A.
7212 static tree
7213 dfs_accumulate_vtbl_inits (tree binfo, in class.c
7214 tree orig_binfo,
7215 tree rtti_binfo,
7216 tree t,
7217 tree l)
7218 {
7219 tree inits = NULL_TREE;
7220 tree vtbl = NULL_TREE;
7221 int ctor_vtbl_p = !same_type_p (BINFO_TYPE (rtti_binfo), t);
7222
7223 if (ctor_vtbl_p
7224 && TREE_VIA_VIRTUAL (orig_binfo) && BINFO_PRIMARY_P (orig_binfo))
7225 {
…
7272 }
7273 else if (!BINFO_NEW_VTABLE_MARKED (orig_binfo))
7274 return inits;
7275
7276 if (!vtbl)
7277 {
7278 tree index;
7279 int non_fn_entries;
7280
7281 /* Compute the initializer for this vtable. */
7282 inits = build_vtbl_initializer (binfo, orig_binfo, t, rtti_binfo,
7283 &non_fn_entries);
The object of C’s vtable is smiliar with common object we declare, needs initialization. This initializer is prepared by build_vtbl_initializer . Below argument non_fn_entries_p is used to record the extra non-function entry of the vtable.
7338 static tree
7339 build_vtbl_initializer (tree binfo, in class.c
7340 tree orig_binfo,
7341 tree t,
7342 tree rtti_binfo,
7343 int* non_fn_entries_p)
7344 {
7345 tree v, b;
7346 tree vfun_inits;
7347 tree vbase;
7348 vtbl_init_data vid;
7349
7350 /* Initialize VID. */
7351 memset (&vid, 0, sizeof (vid));
7352 vid.binfo = binfo;
7353 vid.derived = t;
7354 vid.rtti_binfo = rtti_binfo;
7355 vid.last_init = &vid.inits;
7356 vid.primary_vtbl_p = (binfo == TYPE_BINFO (t));
7357 vid.ctor_vtbl_p = !same_type_p (BINFO_TYPE (rtti_binfo), t);
7358 vid.generate_vcall_entries = true;
7359 /* The first vbase or vcall offset is at index -3 in the vtable. */
7360 vid.index = ssize_int (-3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
7361
7362 /* Add entries to the vtable for RTTI. */
7363 build_rtti_vtbl_entries (binfo, &vid);
7364
7365 /* Create an array for keeping track of the functions we've
7366 processed. When we see multiple functions with the same
7367 signature, we share the vcall offsets. */
7368 VARRAY_TREE_INIT (vid.fns, 32, "fns");
7369 /* Add the vcall and vbase offset entries. */
7370 build_vcall_and_vbase_vtbl_entries (binfo, &vid);
7371 /* Clear BINFO_VTABLE_PATH_MARKED; it's set by
7372 build_vbase_offset_vtbl_entries. */
7373 for (vbase = CLASSTYPE_VBASECLASSES (t);
7374 vbase;
7375 vbase = TREE_CHAIN (vbase))
7376 BINFO_VTABLE_PATH_MARKED (TREE_VALUE (vbase)) = 0;
Type vtbl_init_data_s has below definition.
65 typedef struct vtbl_init_data_s in class.c
66 {
67 /* The base for which we're building initializers. */
68 tree binfo;
69 /* The type of the most-derived type. */
70 tree derived;
71 /* The binfo for the dynamic type. This will be TYPE_BINFO (derived),
72 unless ctor_vtbl_p is true. */
73 tree rtti_binfo;
74 /* The negative-index vtable initializers built up so far. These
75 are in order from least negative index to most negative index. */
76 tree inits;
77 /* The last (i.e., most negative) entry in INITS. */
78 tree* last_init;
79 /* The binfo for the virtual base for which we're building
80 vcall offset initializers. */
81 tree vbase;
82 /* The functions in vbase for which we have already provided vcall
83 offsets. */
84 varray_type fns;
85 /* The vtable index of the next vcall or vbase offset. */
86 tree index;
87 /* Nonzero if we are building the initializer for the primary
88 vtable. */
89 int primary_vtbl_p;
90 /* Nonzero if we are building the initializer for a construction
91 vtable. */
92 int ctor_vtbl_p;
93 /* True when adding vcall offset entries to the vtable. False when
94 merely computing the indices. */
95 bool generate_vcall_entries;
96 } vtbl_init_data ;
At line 7355, last_init always points to last node in inits . It will point to negative index vtable initializers (that is the part prior to the part of vtable visible to programmer).
7862 static void
7863 build_rtti_vtbl_entries (tree binfo, vtbl_init_data * vid) in class.c
7864 {
7865 tree b;
7866 tree t;
7867 tree basetype;
7868 tree offset;
7869 tree decl;
7870 tree init;
7871
7872 basetype = BINFO_TYPE (binfo);
7873 t = BINFO_TYPE (vid->rtti_binfo);
7874
7875 /* To find the complete object, we will first convert to our most
7876 primary base, and then add the offset in the vtbl to that value. */
7877 b = binfo;
7878 while (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (b))
7879 && !BINFO_LOST_PRIMARY_P (b))
7880 {
7881 tree primary_base;
7882
7883 primary_base = get_primary_binfo (b);
7884 my_friendly_assert (BINFO_PRIMARY_BASE_OF (primary_base) == b, 20010127);
7885 b = primary_base;
7886 }
7887 offset = size_diffop (BINFO_OFFSET (vid->rtti_binfo), BINFO_OFFSET (b));
7888
7889 /* The second entry is the address of the typeinfo object. */
7890 if (flag_rtti )
7891 decl = build_address (get_tinfo_decl (t));
7892 else
7893 decl = integer_zero_node;
7894
7895 /* Convert the declaration to a type that can be stored in the
7896 vtable. */
7897 init = build_nop (vfunc_ptr_type_node , decl);
7898 *vid->last_init = build_tree_list (NULL_TREE, init);
7899 vid->last_init = &TREE_CHAIN (*vid->last_init);
7900
7901 /* Add the offset-to-top entry. It comes earlier in the vtable that
7902 the the typeinfo entry. Convert the offset to look like a
7903 function pointer, so that we can put it in the vtable. */
7904 init = build_nop (vfunc_ptr_type_node , offset);
7905 *vid->last_init = build_tree_list (NULL_TREE, init);
7906 vid->last_init = &TREE_CHAIN (*vid->last_init);
7907 }
The -1 entry of vtable places the tinfo (type information) object of the type. The necessary entities to support tinfo have been initialized in init_rtti_processing . This tinfo will be declared as static data member of the type.
In build_rtti_vtbl_entries , from the type specified by binfo , stepping down along the primary base path, and finds out the most basic primary base (note that if we encounter base satisifying BINFO_LOST_PRIMARY_P, we are going to step into sub-tree of non-primary base, must stop). The offset from this type to this most basic primary base will be recorded in the -2 entry of the vtable of the class. In our example here, this offset is from C to A.
Back to build_vtbl_initializer , following function is invoked to handle type of virtual base or type contains virtual base.
7512 static void
7513 build_vcall_and_vbase_vtbl_entries (tree binfo, vtbl_init_data * vid) in class.c
7514 {
7515 tree b;
7516
7517 /* If this is a derived class, we must first create entries
7518 corresponding to the primary base class. */
7519 b = get_primary_binfo (binfo);
7520 if (b)
7521 build_vcall_and_vbase_vtbl_entries (b, vid);
7522
7523 /* Add the vbase entries for this base. */
7524 build_vbase_offset_vtbl_entries (binfo, vid);
7525 /* Add the vcall entries for this base. */
7526 build_vcall_offset_vtbl_entries (binfo, vid);
7527 }
Notice that build_vcall_and_vbase_vtbl_entries is executed bottom up from the most basic primary base for the certain type of binfo . In our example, build_vcall_and_vbase_vtbl_entries stops recurring at meeting virtual base A. As A contains no virtual base, build_vbase_offset_vtbl_entries does nothing. And now, we are within following call stack:
build_vcall_and_vbase_vtbl_entries: for C
build_vcall_and_vbase_vtbl_entries: for B1
build_vcall_and_vbase_vtbl_entries: for A
build_vcall_offset_vtbl_entries: for A
7632 static void
7633 build_vcall_offset_vtbl_entries (tree binfo, vtbl_init_data * vid) in class.c
7634 {
7635 /* We only need these entries if this base is a virtual base. We
7636 compute the indices -- but do not add to the vtable -- when
7637 building the main vtable for a class. */
7638 if (TREE_VIA_VIRTUAL (binfo) || binfo == TYPE_BINFO (vid->derived))
7639 {
7640 /* We need a vcall offset for each of the virtual functions in this
7641 vtable. For example:
7642
7643 class A { virtual void f (); };
7644 class B1 : virtual public A { virtual void f (); };
7645 class B2 : virtual public A { virtual void f (); };
7646 class C: public B1, public B2 { virtual void f (); };
7647
7648 A C object has a primary base of B1, which has a primary base of A. A
7649 C also has a secondary base of B2, which no longer has a primary base
7650 of A. So the B2-in-C construction vtable needs a secondary vtable for
7651 A, which will adjust the A* to a B2* to call f. We have no way of
7652 knowing what (or even whether) this offset will be when we define B2,
7653 so we store this "vcall offset" in the A sub-vtable and look it up in
7654 a "virtual thunk" for B2::f.
7655
7656 We need entries for all the functions in our primary vtable and
7657 i n our non-virtual bases' secondary vtables. */
7658 vid->vbase = binfo;
7659 /* If we are just computing the vcall indices -- but do not need
7660 the actual entries -- not that. */
7661 if (!TREE_VIA_VIRTUAL (binfo))
7662 vid->generate_vcall_entries = false;
7663 /* Now, walk through the non-virtual bases, adding vcall offsets. */
7664 add_vcall_offset_vtbl_entries_r (binfo, vid);
7665 }
7666 }
For the qualified candidate in add_vcall_offset_vtbl_entries_r , above at line 7658, vbase field of vid is set with the corresponding binfo which is the vritual base for which we are building the vcall offsets. Below condition at line 7680, filters out virtual base not building vcall offset; and above condition at line 7638, only passes virtual bases and the most derived class.
7670 static void
7671 add_vcall_offset_vtbl_entries_r (tree binfo, vtbl_init_data * vid) in class.c
7672 {
7673 int i;
7674 tree primary_binfo;
7675
7676 /* Don't walk into virtual bases -- except, of course, for the
7677 virtual base for which we are building vcall offsets. Any
7678 primary virtual base will have already had its offsets generated
7679 through the recursion in build_vcall_and_vbase_vtbl_entries. */
7680 if (TREE_VIA_VIRTUAL (binfo) && vid->vbase != binfo)
7681 return ;
7682
7683 /* If BINFO has a primary base, process it first. */
7684 primary_binfo = get_primary_binfo (binfo);
7685 if (primary_binfo)
7686 add_vcall_offset_vtbl_entries_r (primary_binfo, vid);
7687
7688 /* Add BINFO itself to the list. */
7689 add_vcall_offset_vtbl_entries_1 (binfo, vid);
7690
7691 /* Scan the non-primary bases of BINFO. */
7692 for (i = 0; i < BINFO_N_BASETYPES (binfo); ++i)
7693 {
7694 tree base_binfo;
7695
7696 base_binfo = BINFO_BASETYPE (binfo, i);
7697 if (base_binfo != primary_binfo)
7698 add_vcall_offset_vtbl_entries_r (base_binfo, vid);
7699 }
7700 }
Also here, if binfo is of derived class, it recurs into add_vcall_offset_vtbl_entries_r too, till encountering the bottom primrary base. Note that this primary base can be a derived, except it can has base defining virtual function. Above, in handling the derived (only current class, i.e., C; or virtual base, but its bases can’t have virtual function), first is its primary base, then is itselt, which is followed by non-primary base.
7704 static void
7705 add_vcall_offset_vtbl_entries_1 (tree binfo, vtbl_init_data * vid) in class.c
7706 {
7707 /* Make entries for the rest of the virtuals. */
7708 if (abi_version_at_least (2))
7709 {
7710 tree orig_fn;
7711
7712 /* The ABI requires that the methods be processed in declaration
7713 order. G++ 3.2 used the order in the vtable. */
7714 for (orig_fn = TYPE_METHODS (BINFO_TYPE (binfo));
7715 orig_fn;
7716 orig_fn = TREE_CHAIN (orig_fn))
7717 if (DECL_VINDEX (orig_fn))
7718 add_vcall_offset (orig_fn, binfo, vid);
7719 }
7720 else
7721 {
…
7785 }
7786 }
We focus on ABI first used in GCC 3.4. In previous section, we have seen that in finish_struct_1 , at line 5123, DECL_VINDEX of virtual functions have been updated by INTEGER_CST, and this field is empty for non-virtual function. Obviously, add_vcall_offset just processes virtual function, and note that the virtual functions come from class specified by binfo .
7790 static void
7791 add_vcall_offset (tree orig_fn, tree binfo, vtbl_init_data *vid) in class.c
7792 {
7793 size_t i;
7794 tree vcall_offset;
7795
7796 /* If there is already an entry for a function with the same
7797 signature as FN, then we do not need a second vcall offset.
7798 Check the list of functions already present in the derived
7799 class vtable. */
7800 for (i = 0; i < VARRAY_ACTIVE_SIZE (vid->fns); ++i)
7801 {
7802 tree derived_entry;
7803
7804 derived_entry = VARRAY_TREE (vid->fns, i);
7805 if (same_signature_p (derived_entry, orig_fn)
7806 /* We only use one vcall offset for virtual destructors,
7807 even though there are two virtual table entries. */
7808 || (DECL_DESTRUCTOR_P (derived_entry)
7809 && DECL_DESTRUCTOR_P (orig_fn)))
7810 return ;
7811 }
7812
7813 /* If we are building these vcall offsets as part of building
7814 the vtable for the most derived class, remember the vcall
7815 offset. */
7816 if (vid->binfo == TYPE_BINFO (vid->derived))
7817 CLASSTYPE_VCALL_INDICES (vid->derived)
7818 = tree_cons (orig_fn, vid->index,
7819 CLASSTYPE_VCALL_INDICES (vid->derived));
7820
7821 /* The next vcall offset will be found at a more negative
7822 offset. */
7823 vid->index = size_binop (MINUS_EXPR, vid->index,
7824 ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
7825
7826 /* Keep track of this function. */
7827 VARRAY_PUSH_TREE (vid->fns, orig_fn);
7828
7829 if (vid->generate_vcall_entries)
7830 {
7831 tree base;
7832 tree fn;
7833
7834 /* Find the overriding function. */
7835 fn = find_final_overrider (vid->rtti_binfo, binfo, orig_fn);
7836 if (fn == error_mark_node)
7837 vcall_offset = build1 (NOP_EXPR, vtable_entry_type ,
7838 integer_zero_node);
7839 else
7840 {
7841 base = TREE_VALUE (fn);
7842
7843 /* The vbase we're working on is a primary base of
7844 vid->binfo. But it might be a lost primary, so its
7845 BINFO_OFFSET might be wrong, so we just use the
7846 BINFO_OFFSET from vid->binfo. */
7847 vcall_offset = size_diffop (BINFO_OFFSET (base),
7848 BINFO_OFFSET (vid->binfo));
7849 vcall_offset = fold (build1 (NOP_EXPR, vtable_entry_type ,
7850 vcall_offset));
7851 }
7852 /* Add the initializer to the vtable. */
7853 *vid->last_init = build_tree_list (NULL_TREE, vcall_offset);
7854 vid->last_init = &TREE_CHAIN (*vid->last_init);
7855 }
7856 }
At first, vid->fns is an empty arrary, here it is used as a cache to ensure every virtual function can only be handled once. At line 7818, vid->index records the current index (note that it is negative) of vtable of current class (that is class C); if condition at line 7816 is satisfied, it means class C is being handled by dfs_accumulate_vtbl_inits , which is the first processed. It is our scenario now, then CLASSTYPE_VCALL_INDICES records the position of these containing vcall offset functions; at time C being virtual base, it will be set in BV_VCALL_INDEX of the virtual by get_vcall_index (refer to previous section, update_vtable_entry_for_fn ). At line 7827, caches this virtual function. At line 7829, vid->generate_vcall_entries is true for virtual base, which indicates need construct entry in vtable for vcall. Then at line 7835, vid->rtti_binfo is the binfo of current class (binfo of class C), so here found by find_final_overrider is the last overrider (for our example, it is C::f). Note if fn is error_mark_node , it means find_final_overrider detects error (like ambiguity), and here it sets vcall offset as 0. In normal case, fn would be a tree_list node, in its value field is the base defining it. So vcall_offset at line 7847, is the offset from the base preparing vtable entry to the derived last overrides the function. In our current scenario, they are both C.
Then exitting from build_vcall_and_vbase_vtbl_entries handling A, we back in the function handling B1, in which build_vcall_offset_vtbl_entries does nothing for as B1 is not virutal base. But as it has virtual base A, it undergoes build_vbase_offset_vtbl_entries . Now the call stack is:
build_vcall_and_vbase_vtbl_entries: for C
build_vcall_and_vbase_vtbl_entries: for B1
build_vbase_offset_vtbl_entries: for B1
During the processing current class, vid->derived always refers to class C. And line 7543 filters out classes that don’t derive from virtual base.
7534 static void
7535 build_vbase_offset_vtbl_entries (tree binfo, vtbl_init_data * vid) in class.c
7536 {
7537 tree vbase;
7538 tree t;
7539 tree non_primary_binfo;
7540
7541 /* If there are no virtual baseclasses, then there is nothing to
7542 do. */
7543 if (!TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo)))
7544 return ;
7545
7546 t = vid->derived;
7547
7548 /* We might be a primary base class. Go up the inheritance hierarchy
7549 until we find the most derived class of which we are a primary base:
7550 it is the offset of that which we need to use. */
7551 non_primary_binfo = binfo;
7552 while (BINFO_INHERITANCE_CHAIN (non_primary_binfo))
7553 {
7554 tree b;
7555
7556 /* If we have reached a virtual base, then it must be a primary
7557 base (possibly multi-level) of vid->binfo, or we wouldn't
7558 have called build_vcall_and_vbase_vtbl_entries for it. But it
7559 might be a lost primary, so just skip down to vid->binfo. */
7560 if (TREE_VIA_VIRTUAL (non_primary_binfo))
7561 {
7562 non_primary_binfo = vid->binfo;
7563 break ;
7564 }
7565
7566 b = BINFO_INHERITANCE_CHAIN (non_primary_binfo);
7567 if (get_primary_binfo (b) != non_primary_binfo)
7568 break ;
7569 non_primary_binfo = b;
7570 }
7571
7572 /* Go through the virtual bases, adding the offsets. */
7573 for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));
7574 vbase;
7575 vbase = TREE_CHAIN (vbase))
7576 {
7577 tree b;
7578 tree delta;
7579
7580 if (!TREE_VIA_VIRTUAL (vbase))
7581 continue ;
7582
7583 /* Find the instance of this virtual base in the complete
7584 object. */
7585 b = copied_binfo (vbase, binfo);
7586
7587 /* If we've already got an offset for this virtual base, we
7588 don't need another one. */
7589 if (BINFO_VTABLE_PATH_MARKED (b))
7590 continue ;
7591 BINFO_VTABLE_PATH_MARKED (b) = 1;
7592
7593 /* Figure out where we can find this vbase offset. */
7594 delta = size_binop (MULT_EXPR,
7595 vid->index,
7596 convert (ssizetype,
7597 TYPE_SIZE_UNIT (vtable_entry_type)));
7598 if (vid->primary_vtbl_p)
7599 BINFO_VPTR_FIELD (b) = delta;
7600
7601 if (binfo != TYPE_BINFO (t))
7602 {
7603 /* The vbase offset had better be the same. */
7604 my_friendly_assert (tree_int_cst_equal (delta,
7605 BINFO_VPTR_FIELD (vbase)),
7606 20030202);
7607 }
7608
7609 /* The next vbase will come at a more negative offset. */
7610 vid->index = size_binop (MINUS_EXPR, vid->index,
7611 ssize_int (TARGET_VTABLE_DATA_ENTRY_DISTANCE));
7612
7613 /* The initializer is the delta from BINFO to this virtual base.
7614 The vbase offsets go in reverse inheritance-graph order, and
7615 we are walking in inheritance graph order so these end up in
7616 the right order. */
7617 delta = size_diffop (BINFO_OFFSET (b), BINFO_OFFSET (non_primary_binfo));
7618
7619 *vid->last_init
7620 = build_tree_list (NULL_TREE,
7621 fold (build1 (NOP_EXPR,
7622 vtable_entry_type ,
7623 delta)));
7624 vid->last_init = &TREE_CHAIN (*vid->last_init);
7625 }
7626 }
WHILE block at line 7552 finds out most derived class which is the non-virtual primary base within the branch of the hierarchy tree, to which binfo belongs. For example, for class B1 in our example, non_primary_binfo refers to C. We find these types, because as we have seen, bases in primary base path that share the vtable ptr are laid at the same offset from the head of the most derived class.
At line 7598, vid->primary_vtbl_p is true, if we are preparing vtable entry for current class (C). BINFO_VPTR_FIELD of virtual base saves an INTEGER_CST which is an index of vtable, where vcall offset can be found. The significance of this offset is, considering below statements:
A *pa = new C;
pa->f();
Runtime polymorphism must promise C::f get invoked, so offset A à C must be known, which is caculated above.
Condition at line 7601 and assertion at line 7604 ensure index for vbase offset generated by every class containing virtual base is the same.
