Studying note of GCC-3.4.6 source (142 - continue)

OK. Now let’s see the output of GCC for our instance 1.

Example 1:

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

 

… // no VTT for A

VTT for B1

B1::_ZTT2B1: 2u entries

0     ((& B1::_ZTV2B1) + 16u)

4     ((& B1::_ZTV2B1) + 16u)

…

VTT for B2

B2::_ZTT2B2: 2u entries

0     ((& B2::_ZTV2B2) + 16u)

4     ((& B2::_ZTV2B2) + 16u)

…

Construction vtable for B1 (0xb7f2d980 instance) in C

C::_ZTC1C0_2B1: 6u entries

0     0u

4     0u

8     (int (*)(...))0

12    (int (*)(...))(& _ZTI2B1)

16    B1::_ZTcv0_n12_v0_n16_N2B11fEv         // C::B1::f

20    B1::f

 

Construction vtable for B2 (0xb7f2da00 instance) in C

C::_ZTC1C4_2B2: 10u entries

0     -4u

4     0u

8     (int (*)(...))0

12    (int (*)(...))(& _ZTI2B2)

16    B2::_ZTcv0_n12_v0_n16_N2B21fEv         // C::B2::f

20    B2::f

24    4u

28    (int (*)(...))4

32    (int (*)(...))(& _ZTI2B2)

36     B2::_ZTcv0_n12_v0_n16_N2B21fEv         // C::B2::f

 

VTT for C

C::_ZTT1C: 7u entries

0     ((& C::_ZTV1C) + 16u)             // vptr for C

4     ((& C::_ZTC1C0_2B1) + 16u)    // construction vtable used for B1

8     ((& C::_ZTC1C0_2B1) + 16u)    // construction vtable used for B1::A

12    ((& C::_ZTC1C4_2B2) + 16u)    // construction vtable used for B2

16    ((& C::_ZTC1C4_2B2) + 36u)    // construction vtable used for B2::A

20    ((& C::_ZTV1C) + 16u)             // vptr for secondary vtable of B2

24    ((& C::_ZTV1C) + 40u)             // vptr for secondary vtable of A

Constructing VTT is done by below function.

 

6829   static void

6830   build_vtt (tree t)                                                                                      in class.c

6831   {

6832     tree inits;

6833     tree type;

6834     tree vtt;

6835     tree index;

6836  

6837     /* Build up the initializers for the VTT.  */

6838     inits = NULL_TREE;

6839     index = size_zero_node;

6840     build_vtt_inits (TYPE_BINFO (t), t, &inits, &index);

6841  

6842     /* If we didn't need a VTT, we're done.  */

6843     if (!inits)

6844       return ;

6845  

6846     /* Figure out the type of the VTT.  */

6847     type = build_index_type (size_int (list_length (inits) - 1));

6848     type = build_cplus_array_type (const_ptr_type_node, type);

6849                            

6850     /* Now, build the VTT object itself.  */

6851     vtt = build_vtable (t, get_vtt_name (t), type);

6852     initialize_array (vtt, inits);

6853     /* Add the VTT to the vtables list.  */

6854     TREE_CHAIN (vtt) = TREE_CHAIN (CLASSTYPE_VTABLES (t));

6855     TREE_CHAIN (CLASSTYPE_VTABLES (t)) = vtt;

6856  

6857     dump_vtt (t, vtt);

6858   }

 

So for our example, for class B1, B2 and C, VTT is expected, and its body is constructed by build_vtt_init bleow, in which argument binfo is the binfo of the most derived class, t is the most derived class, and index is the last index the VTT entries occupied.

 

6892   static tree *

6893   build_vtt_inits (tree binfo, tree t, tree* inits, tree* index)                              in class.c

6894   {

6895     int i;

6896     tree b;

6897     tree init;

6898     tree secondary_vptrs;

6899     int top_level_p = same_type_p (TREE_TYPE (binfo), t);

6900  

6901     /* We only need VTTs for subobjects with virtual bases.  */

6902     if (!TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo)))

6903       return inits;

6904  

6905     /* We need to use a construction vtable if this is not the primary

6906        VTT.  */

6907     if (!top_level_p)

6908     {

6909       build_ctor_vtbl_group (binfo, t);

6910  

6911       /* Record the offset in the VTT where this sub-VTT can be found.  */

6912       BINFO_SUBVTT_INDEX (binfo) = *index;

6913     }

6914  

6915     /* Add the address of the primary vtable for the complete object.  */

6916     init = binfo_ctor_vtable (binfo);

6917     *inits = build_tree_list (NULL_TREE, init);

6918     inits = &TREE_CHAIN (*inits);

6919     if (top_level_p)

6920     {

6921       my_friendly_assert (!BINFO_VPTR_INDEX (binfo), 20010129);

6922       BINFO_VPTR_INDEX (binfo) = *index;

6923     }

6924     *index = size_binop (PLUS_EXPR, *index, TYPE_SIZE_UNIT (ptr_type_node));

6925                     

6926     /* Recursively add the secondary VTTs for non-virtual bases.  */

6927     for (i = 0; i < BINFO_N_BASETYPES (binfo); ++i)

6928     {

6929       b = BINFO_BASETYPE (binfo, i);

6930       if (!TREE_VIA_VIRTUAL (b))

6931         inits = build_vtt_inits (BINFO_BASETYPE (binfo, i), t,

6932                            inits, index);

6933     }

 

In previous section, BINFO_VTABLE of the class is set in dfs_accumulate_vtbl_inits with vtable initializers. It is a PLUS_EXPR specifies the position in the initializers for the start point of vtable. At line 6916 above, binfo_ctor_vtable gets this expression from the class.

 

6865   static tree

6866   binfo_ctor_vtable (tree binfo)                                                                    in class.c

6867   {

6868     tree vt;

6869  

6870     while (1)

6871     {

6872       vt = BINFO_VTABLE (binfo);

6873       if (TREE_CODE (vt) == TREE_LIST)

6874         vt = TREE_VALUE (vt);

6875       if (TREE_CODE (vt) == TREE_VEC)

6876         binfo = vt;

6877       else

6878         break ;

6879     }

6880  

6881     return vt;

6882   }

 

Above at line 6917, init returned by binfo_ctor_vtable is built in a tree_list; and at line 6917, inits points to the address of chain field of this tree_list, so in recursion at line 6931, new nodes will be added into this chain. Above argument index is the VTT index where the next element will be replaced (it is also number of bytes), at beginning it is size_zero_node .

BINFO_VPTR_INDEX holds the index in the VTT where the vptr for the subobject can be found. For the most derived class C, its vptr is saved at index 0. And to non-virtual bases, build_ctor_vtbl_group does below processing.

 

7098   static void

7099   build_ctor_vtbl_group (tree binfo, tree t)                                                    in class.c

7100   {

7101     tree list;

7102     tree type;

7103     tree vtbl;

7104     tree inits;

7105     tree id;

7106     tree vbase;

7107  

7108     /* See if we've already created this construction vtable group.  */

7109     id = mangle_ctor_vtbl_for_type (t, binfo);

7110     if (IDENTIFIER_GLOBAL_VALUE (id))

7111       return ;

7112  

7113     my_friendly_assert (!same_type_p (BINFO_TYPE (binfo), t), 20010124);

7114     /* Build a version of VTBL (with the wrong type) for use in

7115       constructing the addresses of secondary vtables in the

7116       construction vtable group.  */

7117     vtbl = build_vtable (t, id, ptr_type_node);

7118     list = build_tree_list (vtbl, NULL_TREE);

7119     accumulate_vtbl_inits (binfo, TYPE_BINFO (TREE_TYPE (binfo)),

7120                         binfo, t, list);

7121  

7122     /* Add the vtables for each of our virtual bases using the vbase in T

7123       binfo.  */

7124     for (vbase = TYPE_BINFO (BINFO_TYPE (binfo));

7125         vbase;

7126         vbase = TREE_CHAIN (vbase))

7127     {

7128       tree b;

7129  

7130       if (!TREE_VIA_VIRTUAL (vbase))

7131         continue ;

7132       b = copied_binfo (vbase, binfo);

7133        

7134       accumulate_vtbl_inits (b, vbase, binfo, t, list);

7135     }

7136     inits = TREE_VALUE (list);

7137  

7138     /* Figure out the type of the construction vtable.  */

7139     type = build_index_type (size_int (list_length (inits) - 1));

7140     type = build_cplus_array_type (vtable_entry_type, type);

7141     TREE_TYPE (vtbl) = type;

7142  

7143     /* Initialize the construction vtable.  */

7144     CLASSTYPE_VTABLES (t) = chainon (CLASSTYPE_VTABLES (t), vtbl);

7145     initialize_array (vtbl, inits);

7146     dump_vtable (t, binfo, vtbl);

7147   }

 

Above at line 7109, mangle_ctor_vtbl_for_type returns the mangled name for the vtable for linkage purpose. Assertion following makes sure that only bases will go into this function. Then a new created vtable object is wrapped into a tree_list node, and at line 7119 passed to the below function as the last argument. See rtti_binfo is the binfo of qualified direct base, the function will prepare the intializers for the base.

Here accumulate_vtbl_inits handles the base in interesting and its non-virtual base in pre-order order, and then the virtual base in order of appearing within inheritance tree later in build_ctor_vblt_group . We reshow related functions in below for convenience.

 

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   }

 

This time, ctor_vtbl_p at line 7167 above is true as argument t always refers to the most derived class but rtti_binfo should never. And condition at line 7179 filters out base that doesn’t derive from virutal base and non-virtual.

 

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     {

7226       /* In the hierarchy of BINFO_TYPE (RTTI_BINFO), this is a

7227          primary virtual base. If it is not the same primary in

7228          the hierarchy of T, we'll need to generate a ctor vtable

7229          for it, to place at its location in T. If it is the same

7230          primary, we still need a VTT entry for the vtable, but it

7231          should point to the ctor vtable for the base it is a

7232          primary for within the sub-hierarchy of RTTI_BINFO.

7233             

7234          There are three possible cases:

7235             

7236          1) We are in the same place.

7237          2) We are a primary base within a lost primary virtual base of

7238           RTTI_BINFO.

7239          3) We are primary to something not a base of RTTI_BINFO.  */

7240         

7241       tree b = BINFO_PRIMARY_BASE_OF (binfo);

7242       tree last = NULL_TREE;

7243  

7244       /* First, look through the bases we are primary to for RTTI_BINFO

7245          or a virtual base.  */

7246       for (; b; b = BINFO_PRIMARY_BASE_OF (b))

7247        {

7248          last = b;

7249          if (TREE_VIA_VIRTUAL (b) || b == rtti_binfo)

7250            break ;

7251       }

7252       /* If we run out of primary links, keep looking down our

7253          inheritance chain; we might be an indirect primary.  */

7254       if (b == NULL_TREE)

7255         for (b = last; b; b = BINFO_INHERITANCE_CHAIN (b))

7256            if (TREE_VIA_VIRTUAL (b) || b == rtti_binfo)

7257              break ;

7258  

7259        /* If we found RTTI_BINFO, this is case 1. If we found a virtual

7260         base B and it is a base of RTTI_BINFO, this is case 2. In

7261          either case, we share our vtable with LAST, i.e. the

7262          derived-most base within B of which we are a primary.  */

7263       if (b == rtti_binfo

7264           || (b && purpose_member (BINFO_TYPE (b),

7265                  CLASSTYPE_VBASECLASSES (BINFO_TYPE (rtti_binfo)))))

7266         /* Just set our BINFO_VTABLE to point to LAST, as we may not have

7267            set LAST's BINFO_VTABLE yet. We'll extract the actual vptr in

7268            binfo_ctor_vtable after everything's been set up.  */

7269         vtbl = last;

7270  

7271        /* Otherwise, this is case 3 and we get our own.  */

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);

7284  

7285       /* Figure out the position to which the VPTR should point.  */

7286       vtbl = TREE_PURPOSE (l);

7287       vtbl = build1 (ADDR_EXPR,

7288                   vtbl_ptr_type_node,

7289                    vtbl);

7290       TREE_CONSTANT (vtbl) = 1;

7291       index = size_binop (PLUS_EXPR,

7292                        size_int (non_fn_entries),

7293                        size_int (list_length (TREE_VALUE (l))));

7294       index = size_binop (MULT_EXPR,

7295                         TYPE_SIZE_UNIT (vtable_entry_type),

7296                        index);

7297       vtbl = build (PLUS_EXPR, TREE_TYPE (vtbl), vtbl, index);

7298       TREE_CONSTANT (vtbl) = 1;

7299     }

7300  

7301     if (ctor_vtbl_p)

7302       /* For a construction vtable, we can't overwrite BINFO_VTABLE.

7303         So, we make a TREE_LIST. Later, dfs_fixup_binfo_vtbls will

7304         straighten this out.  */

7305       BINFO_VTABLE (binfo) = tree_cons (rtti_binfo, vtbl, BINFO_VTABLE (binfo));

7306     else if (BINFO_PRIMARY_P (binfo) && TREE_VIA_VIRTUAL (binfo))

7307       inits = NULL_TREE;

7308     else

7309       /* For an ordinary vtable, set BINFO_VTABLE.  */

7310       BINFO_VTABLE (binfo) = vtbl;

7311  

7312     return inits;

7313   }

 

Note that argument orig_binfo should always refer to the binfo of the type of base in interesting. And at line 7273 predicate BINFO_NEW_VTABLE_MARKED returns true if the type has its own vtable. Now rtti_binfo is the binfo of the direct base in interesting. In our example, B1, B2 are such bases when handling C. And t refers to the binfo of the most derived class, in our example, it is class C. Next binfo is the binfo of the base we are processing.

If handles B1 in accumulate_vtbl_inits , in dfs_accumulate_vtbl_inits , to orig_binfo (here it is binfo of B1), at line 7224, condition TREE_VIA_VIRTUAL and BINFO_PRIMARY_P are not hold; But at line 7273, orig_binfo of course has its own vtable, which breaks the condition. So it will enters IF block at line 7276, in which the treatment has been seen in previous section and simliar. As ctor_vtbl_p is true, code at line 7305 is run, see that binfo is binfo of B1-in-C, which has empty BINFO_VTABLE. Because vtable built here is construction vtable, which can only borrow BINFO_VTABLE temperarily, as result it is built in a tree_list. Functions cooperative include: binfo_ctor_vtable , dfs_fixup_binfo_vtbls .

Exitting from accumulate_vtbl_inits at line 7119, B1 in C in example 1 should have following entries in construction vtable (kept in TREE_PURPOSE slot of list at line 7118 in build_ctor_vtbl_group , and BINFO_VTABLE (binfo of B1-in-C)).

Construction vtable for B1 (0xb7f2d980 instance) in C

C::_ZTC1C0_2B1: 6u entries

0     0u

4     0u

8     (int (*)(...))0

12    (int (*)(...))(& _ZTI2B1)

16    B1::_ZTcv0_n12_v0_n16_N2B11fEv         // slot of B1::A::f

20    B1::f     // slot of B1::f

Then in invoking accumulate_vtbl_inits at line 7134, binfo is binfo of C::B1, and line 7124 fetches the binfo of type B1, so vbase is binfo of B1::A, but b is binfo of C::B1::A, and t is still type C. They are passed to dfs_accumulate_vtbl_inits as the mapping: binfo (b ), orig_binfo (vbase ), rtti_binfo (binfo ), and t (t ).

Next in the function, b at line 7241 is binfo of C::B1; and last gets binfo of C::B1 at line 7248. As result, vtbl is set by the binfo of C::B1 at line 7269. Finally, at line 7305, BINFO_VTABLE(binfo of C::B1::A) is extended by a tree_list containing binfo of C::B1. And NULL inits is returned.

However thing is a little different for B2-in-C. Also at exitting from accumulate_vtbl_inits at line 7119, B2-in-C in example 1 should have following extra entries in construction vtable (kept in TREE_PURPOSE slot of list at line 7118 in build_ctor_vtbl_group ).

Construction vtable for B2 (0xb7f2da00 instance) in C

C::_ZTC1C4_2B2: 10u entries

0     -4u

4     0u

8     (int (*)(...))0

12    (int (*)(...))(& _ZTI2B2)

16    B2::_ZTcv0_n12_v0_n16_N2B21fEv

20    B2::f     // slot of B2::f

But in dfs_accumulate_vtbl_inits for B2::A, it gets binfo : binfo of C::B2 (arg: rtti_binfo ), vbase : binfo of B2::A (arg: orig_binfo ), b : binfo of C::B2::A (arg: binfo ), and t : C (arg: t ).

Then b at line 7241 this time is binfo of C::B2; and last at line 7248 gets NULL as it climbs up via path A à B1 à C. So vtbl keeps NULL in condition at line 7276. Thus the construction vtable generated for B2::A has below entries:

24    4u        // part of A in B2 - begin

28    (int (*)(...))4

32    (int (*)(...))(& _ZTI2B2)

36    B2::_ZTcv0_n12_v0_n16_N2B21fEv         // part of A in B2 - end

Line 7140 in build_ctor_vtbl_group rebuilds the array type for those construction vtables. Next at line 7144, this construction vtable for base is linked into CLASSTYPE_VTABLES of the most derived class. And initialize_array at line 7145 prepares initializers with exact types for vtable entry.

Return build_vtt_inits from build_ctor_vtbl_group , at line 6916 binfo_ctor_vtable gets construction vtable from binfo of C::B1 (recorded at index 1).

FOR block at line 6927 does nothing for B1 or B2, it then arrives below code.

 

build_vtt_inits (continue)

 

6935     /* Add secondary virtual pointers for all subobjects of BINFO with

6936       either virtual bases or reachable along a virtual path, except

6937       subobjects that are non-virtual primary bases.  */

6938     secondary_vptrs = tree_cons (t, NULL_TREE, BINFO_TYPE (binfo));

6939     TREE_TYPE (secondary_vptrs) = *index;

6940     VTT_TOP_LEVEL_P (secondary_vptrs) = top_level_p;

6941     VTT_MARKED_BINFO_P (secondary_vptrs) = 0;

6942    

6943     dfs_walk_real (binfo,

6944                   dfs_build_secondary_vptr_vtt_inits ,

6945                   NULL,

6946                   dfs_ctor_vtable_bases_queue_p,

6947                   secondary_vptrs);

6948     VTT_MARKED_BINFO_P (secondary_vptrs) = 1;

6949     dfs_walk (binfo, dfs_unmark, dfs_ctor_vtable_bases_queue_p,

6950              secondary_vptrs);

6951  

6952     *index = TREE_TYPE (secondary_vptrs);

6953  

6954     /* The secondary vptrs come back in reverse order. After we reverse

6955       them, and add the INITS, the last init will be the first element

6956       of the chain.  */

6957     secondary_vptrs = TREE_VALUE (secondary_vptrs);

6958     if (secondary_vptrs)

6959     {

6960       *inits = nreverse (secondary_vptrs);

6961       inits = &TREE_CHAIN (secondary_vptrs);

6962       my_friendly_assert (*inits == NULL_TREE, 20000517);

6963     }

6964  

6965     /* Add the secondary VTTs for virtual bases.  */

6966     if (top_level_p)

6967       for (b = TYPE_BINFO (BINFO_TYPE (binfo)); b; b = TREE_CHAIN (b))

6968       {

6969         if (!TREE_VIA_VIRTUAL (b))

6970            continue ;

6971       

6972         inits = build_vtt_inits (b, t, inits, index);

6973       }

6974  

6975     if (!top_level_p)

6976     {

6977       tree data = tree_cons (t, binfo, NULL_TREE);

6978       VTT_TOP_LEVEL_P (data) = 0;

6979       VTT_MARKED_BINFO_P (data) = 0;

6980        

6981       dfs_walk (binfo, dfs_fixup_binfo_vtbls ,

6982                dfs_ctor_vtable_bases_queue_p,

6983                data);

6984     }

6985  

6986     return inits;

6987   }

 

Above secondary_vptrs as indicates by its name, is the pointer to secondary vtable in the VTT of the most derived class (that is C for our example); and index tells the slot of the VTT this pointer lies in. The transverse at line 6943, begins at the binfo of base referred by binfo (here, i.e., either binfo of C::B1 or binfo of C::B2) and steps into this node. Routine below then processes the nodes visited in pre-order, see argument data is secondary_vptrs .

 

6996   static tree

6997   dfs_build_secondary_vptr_vtt_inits (tree binfo, void* data)                          in class.c

6998   {

6999     tree l;

7000     tree t;

7001     tree init;

7002     tree index;

7003     int top_level_p;

7004  

7005     l = (tree) data;

7006     t = TREE_CHAIN (l);

7007     top_level_p = VTT_TOP_LEVEL_P (l);

7008    

7009     BINFO_MARKED (binfo) = 1;

7010  

7011     /* We don't care about bases that don't have vtables.  */

7012     if (!TYPE_VFIELD (BINFO_TYPE (binfo)))

7013       return NULL_TREE;

7014  

7015     /* We're only interested in proper subobjects of T.  */

7016     if (same_type_p (BINFO_TYPE (binfo), t))

7017       return NULL_TREE;

7018  

7019     /* We're not interested in non-virtual primary bases.  */

7020     if (!TREE_VIA_VIRTUAL (binfo) && BINFO_PRIMARY_P (binfo))

7021       return NULL_TREE;

7022  

7023     /* If BINFO has virtual bases or is reachable via a virtual path

7024        from T, it'll have a secondary vptr.  */

7025     if (!TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo))

7026         && !binfo_via_virtual (binfo, t))

7027       return NULL_TREE;

7028  

7029     /* Record the index where this secondary vptr can be found.  */

7030     index = TREE_TYPE (l);

7031     if (top_level_p)

7032     {

7033       my_friendly_assert (!BINFO_VPTR_INDEX (binfo), 20010129);

7034       BINFO_VPTR_INDEX (binfo) = index;

7035     }

7036     TREE_TYPE (l) = size_binop (PLUS_EXPR, index,

7037                               TYPE_SIZE_UNIT (ptr_type_node));

7038  

7039     /* Add the initializer for the secondary vptr itself.  */

7040     if (top_level_p && TREE_VIA_VIRTUAL (binfo))

7041     {

7042        /* It's a primary virtual base, and this is not the construction

7043         vtable. Find the base this is primary of in the inheritance graph,

7044         and use that base's vtable now.  */

7045       while (BINFO_PRIMARY_BASE_OF (binfo))

7046         binfo = BINFO_PRIMARY_BASE_OF (binfo);

7047     }

7048     init = binfo_ctor_vtable (binfo);

7049     TREE_VALUE (l) = tree_cons (NULL_TREE, init, TREE_VALUE (l));

7050  

7051     return NULL_TREE;

7052   }

 

When iterating sub-tree headed by binfo of C::B1, top_level_p above is false, t at line 7006 is the type of B1. This node is skipped as condition at line 7016 is hold; At visiting binfo of C::B1::A, as in binfo BINFO_VTABLE of C::B1::A is the binfo of C::B1, at line 7048 binfo_ctor_vtable gets construction vtable of C::B1 again (kept at index 2). Note this function always returns NULL which forces a full walk within the (sub-)tree. To C::B2, it gets nothing too.

Remember in dfs_accumulate_vtbl_inits at line 7305, construction vtable temperarily stays in BINFO_VTABLE. Now construction vtable has been recorded into VTT, no needs rely upon BINFO_VTABLE any more. Now it is time to restore BINFO_VTABLE. Pay attention to the constructing of its argument data. Here, node temperarily appended by C::B1::A is removed (it is C::B2::A for C::B2).

 

7075   static tree

7076   dfs_fixup_binfo_vtbls (tree binfo, void* data)                                            in class.c

7077   {

7078     BINFO_MARKED (binfo) = 0;

7079  

7080     /* We don't care about bases that don't have vtables.  */

7081     if (!TYPE_VFIELD (BINFO_TYPE (binfo)))

7082       return NULL_TREE;

7083  

7084     /* If we scribbled the construction vtable vptr into BINFO, clear it

7085       out now.  */

7086     if (BINFO_VTABLE (binfo)

7087         && TREE_CODE (BINFO_VTABLE (binfo)) == TREE_LIST

7088         && (TREE_PURPOSE (BINFO_VTABLE (binfo))

7089               == TREE_VALUE ((tree) data)))

7090       BINFO_VTABLE (binfo) = TREE_CHAIN (BINFO_VTABLE (binfo));

7091  

7092     return NULL_TREE;

7093   }

 

In treatment of C::B2 mentioned above, when back build_vtt_inits from build_ctor_vtbl_group , its construction vtable is saved in VTT by index 3. Then in dfs_build_secondary_vptr_vtt_inits for C::B2, binfo_ctor_vtable at line 7048 gets construction vtable of B2::A (at index 4 in VTT).

After finishes handling B1 and B2, it continues on handling C at line 6938 in build_vtt_inits . It begins to transerve inheritance tree rooted by C at line 6943. So dfs_build_secondary_vptr_vtt_inits in, top_level_p is true, and t is the most derived class C. During this pre-order walk, C satisfies condtion at line 7016, C::B1 meets condition at line 7020, and exit the function. For C::B2, index 5 in VTT is set as vptr of C::B2, and its vtable’s (it’s a secondary vtable) initializer is what we got in previous section; similarly for C::B1::A, its vptr is in VTT with index 6, also its vtable’s (secondary vtable too) initialzier is what in BINFO_VTABLE(A-in-C) prepared in previous section. At last, C::B2::A is skipped, as A has been visited via C::B1::A.

A is processed in build_vtt_inits at line 6972 at last, as A hasn’t virtual base, build_vtt_inits does nothing.

Returns build_vtt , if success, inits should not be NULL. Following builds appropriate type for VTT and constructs its static object, then links this object into head of CLASSTYPE_VTABLES of the most derived class.