When finishing handling of B1, build_vcall_and_vbase_vtbl_entries returns to the invocation of handling class C. This time build_vbase_offset_vtbl_entries does nothing, as base A has been processed with BINFO_VTABLE_PATH_MARKED set. And in build_vcall_offset_vtbl_entries , vid->generate_vcall_entries is set in false for class C, and vid->vbase is set to binfo of C. Below call stack would be involved.
build_vcall_and_vbase_vtbl_entries: for C
build_vcall_offset_vtbl_entries: for C
add_vcall_offset_vtbl_entries_r: for C
add_vcall_offset_vtbl_entries_r: for B1
add_vcall_offset_vtbl_entries_r: for A
add_vcall_offset_vtbl_entries_1: for B1
add_vcall_offset: for B1
add_vcall_offset_vtbl_entries_1: for C
add_vcall_offset: for C
add_vcall_offset_vtbl_entries_r: for B2
add_vcall_offset_vtbl_entries_r: for A
add_vcall_offset_vtbl_entries_1: for B2
add_vcall_offset: for B2
In above call stack, add_vcall_offset_vtbl_entries_r first recurses for C’s A, but it does nothing as condition at line 7680 satisified. In following add_vcall_offset , vid->fns now holds virtual functions seen above, so same_signature_p at line 7805 returns true for B1’s virtual, and exits the function at line 7810. After returning from add_vcall_offset_vtbl_entries_r handling B1, invoking add_vcall_offset_vtbl_entries_1 for C. Similiarly, same_signature_p returns true for C’s virtual. Then add_vcall_offset_vtbl_entries_r at line 7698 is recursed for B2 (the non-primary base), it’s original primary base A is filtered out by conidtion at line 7680, also in add_vcall_offset , same_signature_p returns true for B2’s virtual.
When exitting from build_vcall_and_vbase_vtbl_entries for C, we will get following vtable initializers and CLASSTYPE_VCALL_INDICES.
In above figure, in the chain of CLASSTYPE_VCALL_INDICES, value field of node A::f is -3; it coordinate with A::f given in chain of last_init.
Back build_vtbl_initializer , it is still handling C.
build_vtbl_initializer (continue)
7378 /* If the target requires padding between data entries, add that now. */
7379 if (TARGET_VTABLE_DATA_ENTRY_DISTANCE > 1)
7380 {
…
7395 }
7396
7397 if (non_fn_entries_p)
7398 *non_fn_entries_p = list_length (vid.inits);
7399
7400 /* Go through all the ordinary virtual functions, building up
7401 initializers. */
7402 vfun_inits = NULL_TREE;
7403 for (v = BINFO_VIRTUALS (orig_binfo); v; v = TREE_CHAIN (v))
7404 {
7405 tree delta;
7406 tree vcall_index;
7407 tree fn, fn_original;
7408 tree init = NULL_TREE;
7409
7410 fn = BV_FN (v);
7411 fn_original = fn;
7412 if (DECL_THUNK_P (fn))
7413 {
7414 if (!DECL_NAME (fn))
7415 finish_thunk (fn);
7416 if (THUNK_ALIAS (fn))
7417 {
7418 fn = THUNK_ALIAS (fn);
7419 BV_FN (v) = fn;
7420 }
7421 fn_original = THUNK_TARGET (fn);
7422 }
7423
7424 /* If the only definition of this function signature along our
7425 primary base chain is from a lost primary, this vtable slot will
7426 never be used, so just zero it out. This is important to avoid
7427 requiring extra thunks which cannot be generated with the function.
7428
7429 We first check this in update_vtable_entry_for_fn, so we handle
7430 restored primary bases properly; we also need to do it here so we
7431 zero out unused slots in ctor vtables, rather than filling themff
7432 with erroneous values (though harmless, apart from relocation
7433 costs). */
7434 for (b = binfo; ; b = get_primary_binfo (b))
7435 {
7436 /* We found a defn before a lost primary; go ahead as normal. */
7437 if (look_for_overrides_here (BINFO_TYPE (b), fn_original))
7438 break ;
7439
7440 /* The nearest definition is from a lost primary; clear the
7441 slot. */
7442 if (BINFO_LOST_PRIMARY_P (b))
7443 {
7444 init = size_zero_node;
7445 break ;
7446 }
7447 }
7448
7449 if (! init)
7450 {
7451 /* Pull the offset for `this', and the function to call, out of
7452 the list. */
7453 delta = BV_DELTA (v);
7454 vcall_index = BV_VCALL_INDEX (v);
7455
7456 my_friendly_assert (TREE_CODE (delta) == INTEGER_CST, 19990727);
7457 my_friendly_assert (TREE_CODE (fn) == FUNCTION_DECL, 19990727);
7458
7459 /* You can't call an abstract virtual function; it's abstract.
7460 So, we replace these functions with __pure_virtual. */
7461 if (DECL_PURE_VIRTUAL_P (fn_original))
7462 fn = abort_fndecl;
7463 else if (!integer_zerop (delta) || vcall_index)
7464 {
7465 fn = make_thunk (fn, /*this_adjusting=*/ 1, delta, vcall_index);
7466 if (!DECL_NAME (fn))
7467 finish_thunk (fn);
7468 }
7469 /* Take the address of the function, considering it to be of an
7470 appropriate generic type. */
7471 init = build1 (ADDR_EXPR, vfunc_ptr_type_node , fn);
7472 /* The address of a function can't change. */
7473 TREE_CONSTANT (init) = 1;
7474 }
7475
7476 /* And add it to the chain of initializers. */
7477 if (TARGET_VTABLE_USES_DESCRIPTORS)
7478 {
…
7493 }
7494 else
7495 vfun_inits = tree_cons (NULL_TREE, init, vfun_inits);
7496 }
7497
7498 /* The initializers for virtual functions were built up in reverse
7499 order; straighten them out now. */
7450 vfun_inits = nreverse (vfun_inits);
7451
7452 /* The negative offset initializers are also in reverse order. */
7453 vid.inits = nreverse (vid.inits);
7454
7455 /* Chain the two together. */
7456 return chainon (vid.inits, vfun_inits);
7457 }
Above orig_binfo comes from current class, whose BINFO_VIRTUALS has been process by update_vtable_entry_for_fn (see previous section). Virtuals in BINFO_VIRTUALS can be a thunk, which is constructed in update_vtable_entry_for_fn , and only of result-adjustmnet. Here it is constructing this-adjustment thunk, and information BV_DELTA, BV_VCALL_INDEX (from CLASSTYPE_VCALL_INDICES of the virtual base. Above can see C also prepared it for future being virtual base) is also collected by update_vtable_entry_for_fn .
Now all thunks are still anonymous. In the front-end, that indicates the thunk is incomplete.
194 void
195 finish_thunk (tree thunk) in method.c
196 {
197 tree function, name;
198 tree fixed_offset = ssize_int (THUNK_FIXED_OFFSET (thunk));
199 tree virtual_offset = THUNK_VIRTUAL_OFFSET (thunk);
200
201 my_friendly_assert (!DECL_NAME (thunk) && DECL_THUNK_P (thunk), 20021127);
202 if (virtual_offset && DECL_RESULT_THUNK_P (thunk))
203 virtual_offset = BINFO_VPTR_FIELD (virtual_offset);
204 function = THUNK_TARGET (thunk);
205 name = mangle_thunk (function, DECL_THIS_THUNK_P (thunk),
206 fixed_offset, virtual_offset);
207
208 /* We can end up with declarations of (logically) different
209 covariant thunks, that do identical adjustments. The two thunks
210 will be adjusting between within different hierarchies, which
211 happen to have the same layout. We must nullify one of them to
212 refer to the other. */
213 if (DECL_RESULT_THUNK_P (thunk))
214 {
215 tree cov_probe;
216
217 for (cov_probe = DECL_THUNKS (function);
218 cov_probe; cov_probe = TREE_CHAIN (cov_probe))
219 if (DECL_NAME (cov_probe) == name)
220 {
221 my_friendly_assert (!DECL_THUNKS (thunk), 20031023);
222 THUNK_ALIAS (thunk) = (THUNK_ALIAS (cov_probe)
223 ? THUNK_ALIAS (cov_probe) : cov_probe);
224 break ;
225 }
226 }
227
228 DECL_NAME (thunk) = name;
229 SET_DECL_ASSEMBLER_NAME (thunk, name);
230 }
THUNK_VIRTUAL_OFFSET, for this-adjusting thunk, it is the number of bytes to be added to the vtable to find the vcall offset; for a result adjusting thunk, it is the binfo of the relevant virtual base. BINFO_VPTR_FIELD at line 203 is an INTEGER_CST giving an offset into the vtable where the offset to the virtual base can be found. So for result adjusting thunk, needs treatment at line 203 to get the offset of the virtual base. At line 205, mangle_thunk returns the mangled name for the thunk (at section beginning, we have seen examples of thunk’s mangled name). After setting the name with the thunk, it can be regarded as finished. As thunk’s name is constructed by its action, it’s possible there exists thunk of same name, at which treats the thunk built later as the alias of the former one, they share the same thunk function.
dfs_accumulate_vtbl_inits (continue)
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 }
Back to dfs_accumulate_vtbl_inits , note that we are still handling class C. above l is list in finish_vtbls , in its TREE_PURPOSE is the TYPE_BINFO_VTABLE (vtable saved in the binfo of the type, which is VAR_DECL generated by build_primary_vtable ). And originally, TREE_VALUE of l is NULL (but at line 7185 in accumulate_vtbl_inits , it chains l with the list returned by dfs_accumulate_vtbl_inits ). See that non_fn_entries records the number of entries of negative index. So it can know where to begin the entries visible to programmer.
When returns back to accumulate_vtbl_inits , after chaining into list in finish_vtt , we get following figure (remember in create_vtable_ptr , every virtual function has an extra node generated with 0 delta).
Next, in accumulate_vtbl_inits , at line 7195, in FOR block, binfo B1 within C is not handled as its BINFO_NEW_VTABLE_MARKED unset (see dfs_accumulate_vtbl_inits line 7273). While for B2 in C, it has secondary vtable generated, so passes the line successfully. At that time, ctor_vtbl_p is false, binfo from class B2, orig_binfo from B2 in C, and rtti_binfo is C’s binfo, it undergoes similar processing as that for C above. Then when back finish_vtbls , A in C is processed by accumulate_vtbl_inits at line 6780, in which ctor_vtbl_p is still false. But this A hasn’t flag BINFO_NEW_VTABLE_MARKED set, so exits dfs_accumulate_vtbl_inits immediately.
So before invoking initialize_vtable at line 6784, list is given in below figure.
(Click here for open )
Figure 117 : initializer for vtable
Above B1 and A don’t have their part of vtable as they share the same part with C.
In below function, now argument inits is the chain referred by value slot of list in above figure. This chain holds all initializers for class C’s vtable. Note that at last vtbl at line 7297 in dfs_accumulate_vtbl_inits , points to the start point of vtable of specified class which is a PLUS_EXPR of vtbl+4 for C, vtbl+8 for base B2.
6789 static void
6790 initialize_vtable (tree binfo, tree inits) in class.c
6791 {
6792 tree decl;
6793
6794 layout_vtable_decl (binfo, list_length (inits));
6795 decl = get_vtbl_decl_for_binfo (binfo);
6796 initialize_array (decl, inits);
6797 dump_vtable (BINFO_TYPE (binfo), binfo, decl);
6798 }
Originally in build_vtable , vtable is created as type of vtbl_type_node which is the array of type vtable_entry_type with empty dimension. Now the size of the array is settled down, we can create the exact type by layout_vtable_decl .
1778 static void
1779 layout_vtable_decl (tree binfo, int n) in class.c
1780 {
1781 tree atype;
1782 tree vtable;
1783
1784 atype = build_cplus_array_type (vtable_entry_type ,
1785 build_index_type (size_int (n - 1)));
1786 layout_type (atype);
1787
1788 /* We may have to grow the vtable. */
1789 vtable = get_vtbl_decl_for_binfo (binfo);
1790 if (!same_type_p (TREE_TYPE (vtable), atype))
1791 {
1792 TREE_TYPE (vtable) = atype;
1793 DECL_SIZE (vtable) = DECL_SIZE_UNIT (vtable) = NULL_TREE;
1794 layout_decl (vtable, 0);
1795 }
1796 }
So at line 6795, the vtable VAR_DECL fetched has correct type defined. And it is passed as argument decl in below function.
6803 static void
6804 initialize_array (tree decl, tree inits) in class.c
6805 {
6806 tree context;
6807
6808 context = DECL_CONTEXT (decl);
6809 DECL_CONTEXT (decl) = NULL_TREE;
6810 DECL_INITIAL (decl) = build_constructor (NULL_TREE, inits);
6811 TREE_HAS_CONSTRUCTOR (DECL_INITIAL (decl)) = 1;
6812 cp_finish_decl (decl, DECL_INITIAL (decl), NULL_TREE, 0);
6813 DECL_CONTEXT (decl) = context;
6814 }
See node of CONSTRUCTOR is built for initializing this VAR_DECL. Note that this node has empty type field (it is treated as unknown).
444 tree
445 build_constructor (tree type, tree vals) in tree.c
446 {
447 tree c = make_node (CONSTRUCTOR);
448 TREE_TYPE (c) = type;
449 CONSTRUCTOR_ELTS (c) = vals;
450
451 /* ??? May not be necessary. Mirrors what build does. */
452 if (vals)
453 {
454 TREE_SIDE_EFFECTS (c) = TREE_SIDE_EFFECTS (vals);
455 TREE_READONLY (c) = TREE_READONLY (vals);
456 TREE_CONSTANT (c) = TREE_CONSTANT (vals);
457 }
458 else
459 TREE_CONSTANT (c) = 0; /* safe side */
460
461 return c;
462 }
Being a VAR_DECL, it is completed by cp_finish_decl . Note that we are still within another cp_finish_decl for the template instantiation of SmallObject.
4768 void
4769 cp_finish_decl (tree decl, tree init, tree asmspec_tree, int flags) in decl.c
4770 {
4771 tree type;
4772 tree ttype = NULL_TREE;
4773 tree cleanup;
4774 const char *asmspec = NULL;
4775 int was_readonly = 0;
4776 bool var_definition_p = false;
4777
4778 if (decl == error_mark_node)
4779 return ;
4780 else if (! decl)
4781 {
4782 if (init)
4783 error ("assignment (not initialization) in declaration");
4784 return ;
4785 }
4786
4787 my_friendly_assert (TREE_CODE (decl) != RESULT_DECL, 20030619);
4788
4789 /* Assume no cleanup is required. */
4790 cleanup = NULL_TREE;
4791
4792 /* If a name was specified, get the string. */
4793 if (global_scope_p (current_binding_level ))
4794 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
4795 if (asmspec_tree)
4796 asmspec = TREE_STRING_POINTER (asmspec_tree);
4797
4798 if (init && TREE_CODE (init) == NAMESPACE_DECL)
4799 {
4800 error ("cannot initialize `%D' to namespace `%D'",
4802 decl, init);
4803 init = NULL_TREE;
4804 }
4805
4806 if (current_class_type
4807 && CP_DECL_CONTEXT (decl) == current_class_type
4808 && TYPE_BEING_DEFINED (current_class_type )
4809 && (DECL_INITIAL (decl) || init))
4810 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
4811
4812 if (TREE_CODE (decl) == VAR_DECL
4813 && DECL_CONTEXT (decl)
4814 && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
4815 && DECL_CONTEXT (decl) != current_namespace
4816 && init)
4817 {
4818 /* Leave the namespace of the object. */
4819 pop_decl_namespace ();
4820 }
4821
4822 type = TREE_TYPE (decl);
4823
4824 if (type == error_mark_node)
4825 goto finish_end0;
4826
4827 if (TYPE_HAS_MUTABLE_P (type))
4828 TREE_READONLY (decl) = 0;
4829
4830 if (processing_template_decl )
4831 {
…
4842 }
4843
4844 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
4845 my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
4846
4847 /* Take care of TYPE_DECLs up front. */
4848 if (TREE_CODE (decl) == TYPE_DECL)
4849 {
…
4868 }
4869
4870 if (TREE_CODE (decl) != FUNCTION_DECL)
4871 ttype = target_type (type);
4872
4873
4874 /* Currently, GNU C++ puts constants in text space, making them
4875 impossible to initialize. In the future, one would hope for
4876 an operating system which understood the difference between
4877 initialization and the running of a program. */
4878 if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl))
4879 {
4880 was_readonly = 1;
4881 if (TYPE_NEEDS_CONSTRUCTING (type)
4882 || TREE_CODE (type) == REFERENCE_TYPE)
4883 TREE_READONLY (decl) = 0;
4884 }
4885
4886 if (TREE_CODE (decl) == VAR_DECL)
4887 {
4888 /* Only PODs can have thread-local storage. Other types may require
4889 various kinds of non-trivial initialization. */
4890 if (DECL_THREAD_LOCAL (decl) && !pod_type_p (TREE_TYPE (decl)))
4891 error ("`%D' cannot be thread-local because it has non-POD type `%T'",
4892 decl, TREE_TYPE (decl));
4893 /* Convert the initializer to the type of DECL, if we have not
4894 already initialized DECL. */
4895 if (!DECL_INITIALIZED_P (decl)
4896 /* If !DECL_EXTERNAL then DECL is being defined. In the
4897 case of a static data member initialized inside the
4898 class-specifier, there can be an initializer even if DECL
4899 is *not* defined. */
4900 && (!DECL_EXTERNAL (decl) || init))
4901 {
4902 init = check_initializer (decl, init, flags, &cleanup);
4903 /* Thread-local storage cannot be dynamically initialized. */
4904 if (DECL_THREAD_LOCAL (decl) && init)
4905 {
4906 error ("`%D' is thread-local and so cannot be dynamically "
4907 "initialized", decl);
4908 init = NULL_TREE;
4909 }
4910 if (DECL_EXTERNAL (decl) && init)
4911 {
4912 /* The static data member cannot be initialized by a
4913 non-constant when being declared. */
4914 error ("`%D' cannot be initialized by a non-constant expression"
4915 " when being declared", decl);
4916 DECL_INITIALIZED_IN_CLASS_P (decl) = 0;
4917 init = NULL_TREE;
4918 }
4919
4920 /* Handle:
4921
4922 [dcl.init]
4923
4924 The memory occupied by any object of static storage
4925 duration is zero-initialized at program startup before
4926 any other initialization takes place.
4927
4928 We cannot create an appropriate initializer until after
4929 the type of DECL is finalized. If DECL_INITIAL is set,
4930 then the DECL is statically initialized, and any
4931 necessary zero-initialization has already been performed. */
4932 if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
4933 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
4934 /*nelts=*/ NULL_TREE,
4935 /*static_storage_p=*/ true);
4936 /* Remember that the initialization for this variable has
4937 taken place. */
4938 DECL_INITIALIZED_P (decl) = 1;
4939 /* This declaration is the definition of this variable,
4940 unless we are initializing a static data member within
4941 the class specifier. */
4942 if (!DECL_EXTERNAL (decl))
4943 var_definition_p = true;
4944 }
…
4951 }
Before entering the function, we clean DELC_CONTEXT of decl . At line 4794, maybe_apply_renaming_pragma is only useful for Solaris and Tru64 UNIX system for compatibility with the system headers.
