5.12.5.2.2.2.1.3.10. 完成派生类的 RECORD_TYPE – 构建 vtable
记得在 determine_primary_base 中，如果我们找到一个主要基类，我们只是记住它的 vtable （记住它必须有 vtable ，否则我们不会有主要基类），现在我们需要属于自己的 vtable 。注意 5057 到 5064 行的断言，它们可以帮助我们尽早地发现不一致的情况。
finish_struct_1 (continue)
5051 /* Make sure that we get our own copy of the vfield FIELD_DECL. */
5052 vfield = TYPE_VFIELD (t);
5053 if (vfield && CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5054 {
5055 tree primary = CLASSTYPE_PRIMARY_BINFO (t);
5056
5057 my_friendly_assert (same_type_p (DECL_FIELD_CONTEXT (vfield),
5058 BINFO_TYPE (primary)),
5059 20010726);
5060 /* The vtable better be at the start. */
5061 my_friendly_assert (integer_zerop (DECL_FIELD_OFFSET (vfield)),
5062 20010726);
5063 my_friendly_assert (integer_zerop (BINFO_OFFSET (primary)),
5064 20010726);
5065
5066 vfield = copy_decl (vfield);
5067 DECL_FIELD_CONTEXT (vfield) = t;
5068 TYPE_VFIELD (t) = vfield;
5069 }
5070 else
5071 my_friendly_assert (!vfield || DECL_FIELD_CONTEXT (vfield) == t, 20010726);
5072
5073 virtuals = modify_all_vtables (t, nreverse (virtuals));
5074
5075 /* If we created a new vtbl pointer for this class, add it to the
5076 list. */
5077 if (TYPE_VFIELD (t) && !CLASSTYPE_HAS_PRIMARY_BASE_P (t))
5078 CLASSTYPE_VFIELDS (t)
5079 = chainon (CLASSTYPE_VFIELDS (t), build_tree_list (NULL_TREE, t));
记得上面的 virtuals 记录了 t 中的虚函数，如果有的话。但它是倒序的，所以用 nreverse 先恢复次序。注意到 t 是当前类，而且在调用 dfs_walk 时，它被传作 data 。而 virtuals 通过遍历 TYPE_METHOD 链选出虚函数来构建其内容（参见 create_vtable_ptr ），那么当前类的 binfo 的 BINFO_VIRTUAL 是什么呢？在 set_primary_base 里，当确定了主要基类时，当前类的 TYPE_BINFO_VIRTUALS 被设置为主要基类的 TYPE_BINFO_VIRTUALS （ TYPE_BINFO_VIRTUALS (t) 被定义为 BINFO_VIRTUALS (TYPE_BINFO (t)) ）。那么， B1 （主要基类）的 TYPE_BINFO_VIRTUALS 又是什么呢？一开始，它从 A （参见这一节开头的例 1 和例 2 ）的 TYPE_BINFO_VIRTUALS 得到其内容。
让我们回到更早一些时候，在那时类 A 正在完成。毫无疑问，一开始， A 具有空的 TYPE_BINFO_VIRTUALS 。对这个类型，下面的 dfs_modify_vtables 不做任何事，而接着 modify_all_vtables 把 A::f 返回作 virtuals 。接着回到下面的 finish_struct_1 部分，在 5086 行，通过 build_primary_vtable 为 A 构建了主 vtable ，在 5106 行其 TYPE_BINFO_VIRTUALS 包含了 A::f 。
因此，在完成 B1 时，其 TYPE_BINFO_VIRTUALS 也是包含了 A 的部分，即 A::f 。然后在下面的 dfs_modify_vtables 中的 2314 行，为 A 准备了次要的（ secondary ）。注意到 dfs_modify_vtables 在派生树中（ B1 为根），由下至上地访问基类的 binfo ，因此第一个得到处理的是 B1 中的 A 。在后面可以看到， A::f 为 B1::f 所替代，并且带有一个 thunk 。接着处理 B1 本身， B1 的 A::f 同样被带有一个 thunk 的 B1::f 所替代（ 2 个替代的地点不同，前者在 A 的次要 vtable ，后者在 B1 的主 vtable ）。在下面的 modify_all_vtables ，因为 vrituals 中 B1::f 的 DECL_VINDEX 不是 error_mark_node （参见 check_for_override ， error_mark_node 表示该函数不是一个重载），而现在 BINFO_VIRTUALS (B1) 包含了带 thunk 的 B1::f ，而且因为 value_member 当且仅当 fn 与链中某个实体的地址相同时返回 true ，因此在 virutals 中的 B1::f 被保留，并在 5106 添加到 B1 的 TYPE_BINFO_VIRTUALS 末尾。从而该链表中包含了带 thunk 的 B1::f ，其后是 B1::f （不带 thunk ）。
现在轮到处理 C ，我们知道在 C 的 TYPE_BINFO_VIRTUALS 中，包含了带有结果指针调整 thunk 的 B1::f ，其后是 B1::f ；同样 C 持有 B1 到 binfo 的拷贝。下面我们将结合代码，仔细地查看这一过程。
2344 static tree
2345 modify_all_vtables (tree t, tree virtuals) in class.c
2346 {
2347 tree binfo = TYPE_BINFO (t);
2348 tree *fnsp;
2349
2350 /* Update all of the vtables. */
2351 dfs_walk (binfo, dfs_modify_vtables , unmarkedp , t);
2352 dfs_walk (binfo, dfs_unmark, markedp, t);
2353
2354 /* Add virtual functions not already in our primary vtable. These
2355 will be both those introduced by this class, and those overridden
2356 from secondary bases. It does not include virtuals merely
2357 inherited from secondary bases. */
2358 for (fnsp = &virtuals; *fnsp; )
2359 {
2360 tree fn = TREE_VALUE (*fnsp);
2361
2362 if (!value_member (fn, BINFO_VIRTUALS (binfo))
2363 || DECL_VINDEX (fn) == error_mark_node)
2364 {
2365 /* We don't need to adjust the `this' pointer when
2366 calling this function. */
2367 BV_DELTA (*fnsp) = integer_zero_node;
2368 BV_VCALL_INDEX (*fnsp) = NULL_TREE;
2369
2370 /* This is a function not already in our vtable. Keep it. */
2371 fnsp = &TREE_CHAIN (*fnsp);
2372 }
2373 else
2374 /* We've already got an entry for this function. Skip it. */
2375 *fnsp = TREE_CHAIN (*fnsp);
2376 }
2377
2378 return virtuals;
2379 }
函数 dfs_modfiy_vtables 在 dfs_walk 遍历派生树时，以后序次序执行。注意到该函数总是返回 NULL 来强制完整的遍历，并且在遍历过程中得到处理的是虚拟基类或非主要基类，如果当前类没有 vtable （ CLASSTYPE_VFIELDS ，它可能由 determine_primary_base 设置）也不在处理之列。对于例 1 和例 2 ，类 C ， B2 和 A 在这里将被以 A ， B2 ，然后 C 的次序处理。同样需要强调的是，当处理 A 时，所有的改变都发生在 C 里 A 的 binfo 拷贝中；而当处理 B2 时，改变也仅限于 C 里 B2 的 binfo 拷贝中；两者的处理实际上与 B1 的处理十分类似。下面我们只看 C 的处理过程，记住在 2319 行， C 的 BINFO_VIRTUALS 包含了带有 thunk （从 A 到 B1 的 this 指针调整（ this-adjustment ）及结果调整（ result-adjustment ））的 B::f 。
2298 static tree
2299 dfs_modify_vtables (tree binfo, void* data) in class.c
2300 {
2301 if (/* There's no need to modify the vtable for a non-virtual
2302 primary base; we're not going to use that vtable anyhow.
2303 We do still need to do this for virtual primary bases, as they
2304 could become non-primary in a construction vtable. */
2305 (!BINFO_PRIMARY_P (binfo) || TREE_VIA_VIRTUAL (binfo))
2306 /* Similarly, a base without a vtable needs no modification. */
2307 && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo)))
2308 {
2309 tree t = (tree) data;
2310 tree virtuals;
2311 tree old_virtuals;
2312 unsigned ix;
2313
2314 make_new_vtable (t, binfo);
2315
2316 /* Now, go through each of the virtual functions in the virtual
2317 function table for BINFO. Find the final overrider, and
2318 update the BINFO_VIRTUALS list appropriately. */
2319 for (ix = 0, virtuals = BINFO_VIRTUALS (binfo),
2320 old_virtuals = BINFO_VIRTUALS (TYPE_BINFO (BINFO_TYPE (binfo)));
2321 virtuals;
2322 ix++, virtuals = TREE_CHAIN (virtuals),
2323 old_virtuals = TREE_CHAIN (old_virtuals))
2324 update_vtable_entry_for_fn (t,
2325 binfo,
2326 BV_FN (old_virtuals),
2327 &virtuals, ix);
2328 }
2329
2330 BINFO_MARKED (binfo) = 1;
2331
2332 return NULL_TREE;
2333 }
注意到参数 t 在过程不改变，总是指向正在完成的当前类。而 binfo 是当前访问的基类。首先，根据需要构建 vtable 。在这里为 A ， B2 及 C 构建 vtable 。
658 static int
659 make_new_vtable (tree t, tree binfo) in class.c
660 {
661 if (binfo == TYPE_BINFO (t))
662 /* In this case, it is *type*'s vtable we are modifying. We start
663 with the approximation that its vtable is that of the
664 immediate base class. */
665 /* ??? This actually passes TYPE_BINFO (t), not the primary base binfo,
666 since we've updated DECL_CONTEXT (TYPE_VFIELD (t)) by now. */
667 return build_primary_vtable (TYPE_BINFO (DECL_CONTEXT (TYPE_VFIELD (t))),
668 t);
669 else
670 /* This is our very own copy of `basetype' to play with. Later,
671 we will fill in all the virtual functions that override the
672 virtual functions in these base classes which are not defined
673 by the current type. */
674 return build_secondary_vtable (binfo);
675 }
对于 A 及 B2 ，因为它们的 binfo 不同于 TYPE_BINFO (C) ， build_secondary_vtable 被调用。并且因为这些 binfo 中的虚函数是从对应类的 binfo 中借来的（参见 xref_basetypes 中的 copy_base_binfos ）。现在是时候拥有自己那一份了。
634 static int
635 build_secondary_vtable (tree binfo) in class.c
636 {
637 if (BINFO_NEW_VTABLE_MARKED (binfo))
638 /* We already created a vtable for this base. There's no need to
639 do it again. */
640 return 0;
641
642 /* Remember that we've created a vtable for this BINFO, so that we
643 don't try to do so again. */
644 SET_BINFO_NEW_VTABLE_MARKED (binfo);
645
646 /* Make fresh virtual list, so we can smash it later. */
647 BINFO_VIRTUALS (binfo) = copy_virtuals (binfo);
648
649 /* Secondary vtables are laid out as part of the same structure as
650 the primary vtable. */
651 BINFO_VTABLE (binfo) = NULL_TREE;
652 return 1;
653 }
BV_VCALL_INDEX 如果不是 NULL ，保存了 vtable 的索引，在该位置是调用这个虚函数时所需要的 vcall 偏移量（通过把这个值加到 this 指针上）。它需要被清除以准备重新索引。
562 static tree
563 copy_virtuals (tree binfo) in class.c
564 {
565 tree copies;
566 tree t;
567
568 copies = copy_list (BINFO_VIRTUALS (binfo));
569 for (t = copies; t; t = TREE_CHAIN (t))
570 BV_VCALL_INDEX (t) = NULL_TREE;
571
572 return copies;
573 }
而对于类 C ， build_primary_vtable 被调用，因为此处的参数 binfo 就是 C 的 binfo 。记得 C 现在仍然使用其主要基类的 TYPE_BINFO_VTABLE 和 TYPE_BINFO_VIRTUALS ，现在它需要属于自己的那一份。
581 static int
582 build_primary_vtable (tree binfo, tree type) in class.c
583 {
584 tree decl;
585 tree virtuals;
586
587 decl = get_vtable_decl (type, /*complete=*/ 0);
588
589 if (binfo)
590 {
591 if (BINFO_NEW_VTABLE_MARKED (binfo))
592 /* We have already created a vtable for this base, so there's
593 no need to do it again. */
594 return 0;
595
596 virtuals = copy_virtuals (binfo);
597 TREE_TYPE (decl) = TREE_TYPE (get_vtbl_decl_for_binfo (binfo));
598 DECL_SIZE (decl) = TYPE_SIZE (TREE_TYPE (decl));
599 DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (TREE_TYPE (decl));
600 }
601 else
602 {
603 my_friendly_assert (TREE_TYPE (decl) == vtbl_type_node, 20000118);
604 virtuals = NULL_TREE;
605 }
606
607 #ifdef GATHER_STATISTICS
608 n_vtables += 1;
609 n_vtable_elems += list_length (virtuals);
610 #endif
611
612 /* Initialize the association list for this type, based
613 on our first approximation. */
614 TYPE_BINFO_VTABLE (type) = decl;
615 TYPE_BINFO_VIRTUALS (type) = virtuals;
616 SET_BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (type));
617 return 1;
618 }
如果 vtable 已经被创建，它保存在 CLASSTYPE_VTABLES 域；否则这个域就是空的。参数 complete 如果是非 0 值，则表示完成在这个函数中创建的 vtable 的定义——通过调用 cp_finish_decl ，我们当前正在这个函数中完成模板类“ SmallObject ”具现。
539 tree
540 get_vtable_decl (tree type, int complete) in class.c
541 {
542 tree decl;
543
544 if (CLASSTYPE_VTABLES (type))
545 return CLASSTYPE_VTABLES (type);
546
547 decl = build_vtable (type, get_vtable_name (type), vtbl_type_node );
548 CLASSTYPE_VTABLES (type) = decl;
549
550 if (complete)
551 {
552 DECL_EXTERNAL (decl) = 1;
553 cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
554 }
555
556 return decl;
557 }
Vtable 应该为该类型的所有实例共享（基类是例外，看到其 BINFO_VTABLE 在 build_secondary_vtable 中创建），因此它应该被创建为静态数据成员。上面的 get_vtable_name 获取 vtable 的修饰名（例 1 及例 2 GCC 的输出给出了修饰名的一些例子），而 vtbl_type_node 具有 vtable_entry_type 类型的数组常量类型（在 cxx_init_decl_processing 中构建）。
506 static tree
507 build_vtable (tree class_type, tree name, tree vtable_type) in class.c
508 {
509 tree decl;
510
511 decl = build_lang_decl (VAR_DECL, name, vtable_type);
512 /* vtable names are already mangled; give them their DECL_ASSEMBLER_NAME
513 now to avoid confusion in mangle_decl. */
514 SET_DECL_ASSEMBLER_NAME (decl, name);
515 DECL_CONTEXT (decl) = class_type;
516 DECL_ARTIFICIAL (decl) = 1;
517 TREE_STATIC (decl) = 1;
518 TREE_READONLY (decl) = 1;
519 DECL_VIRTUAL_P (decl) = 1;
520 DECL_ALIGN (decl) = TARGET_VTABLE_ENTRY_ALIGN;
521 DECL_VTABLE_OR_VTT_P (decl) = 1;
522
523 /* At one time the vtable info was grabbed 2 words at a time. This
524 fails on sparc unless you have 8-byte alignment. (tiemann) */
525 DECL_ALIGN (decl) = MAX (TYPE_ALIGN (double_type_node),
526 DECL_ALIGN (decl));
527
528 import_export_vtable (decl, class_type, 0);
529
530 return decl;
531 }
在 528 行， import_export_vtable 为构建的 VARL_DECL 设置了 TREE_PUBLIC 及 DECL_EXTERNAL 。注意到在 build_primary_vtable 的 614 行， TYPE_BINFO_VIRTUALS 获取作为其参数的类的 binfo 的 BINFO_VIRTUALS 。
在 build_primary_vtabl 的 597 行， get_vtbl_decl_for_binfo 获取对应 binfo 的 vtable 的 VAR_DECL 。
6446 tree
6447 get_vtbl_decl_for_binfo (tree binfo) in class.c
6448 {
6449 tree decl;
6450
6451 decl = BINFO_VTABLE (binfo);
6452 if (decl && TREE_CODE (decl) == PLUS_EXPR)
6453 {
6454 my_friendly_assert (TREE_CODE (TREE_OPERAND (decl, 0)) == ADDR_EXPR,
6455 2000403);
6456 decl = TREE_OPERAND (TREE_OPERAND (decl, 0), 0);
6457 }
6458 if (decl)
6459 my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 20000403);
6460 return decl;
6461 }
现在回到 dfs_modify_vtables ，注意 virtuals 及 orig_virtuals ； virtuals 来自当前类派生树中的 binfo ，而 orig_virtuals 来自基类对应类型中的 binfo 。现在它们是不同的，因为相应的 BINFO_VIRTUALS 在上面已经被拷贝了。
那么对于每个定义在该类中的虚函数，必需的 thunk 及其所携带的调整信息将被在 update_vtable_entry_for_fn 中计算并记录。
2071 static void
2072 update_vtable_entry_for_fn (tree t, tree binfo, tree fn, tree* virtuals, in class.c
2073 unsigned ix)
2074 {
2075 tree b;
2076 tree overrider;
2077 tree delta;
2078 tree virtual_base;
2079 tree first_defn;
2080 tree overrider_fn, overrider_target;
2081 tree target_fn = DECL_THUNK_P (fn) ? THUNK_TARGET (fn) : fn;
2082 tree over_return, base_return;
2083 bool lost = false;
2084
2085 /* Find the nearest primary base (possibly binfo itself) which defines
2086 this function; this is the class the caller will convert to when
2087 calling FN through BINFO. */
2088 for (b = binfo; ; b = get_primary_binfo (b))
2089 {
2090 my_friendly_assert (b, 20021227);
2091 if (look_for_overrides_here (BINFO_TYPE (b), target_fn))
2092 break ;
2093
2094 /* The nearest definition is from a lost primary. */
2095 if (BINFO_LOST_PRIMARY_P (b))
2096 lost = true;
2097 }
2098 first_defn = b;
2099
2100 /* Find the final overrider. */
2101 overrider = find_final_overrider (TYPE_BINFO (t), b, target_fn);
2102 if (overrider == error_mark_node)
2103 {
2104 error ("no unique final overrider for `%D' in `%T'", target_fn, t);
2105 return ;
2106 }
2107 overrider_target = overrider_fn = TREE_PURPOSE (overrider);
因为 dfs_modify_vtables 在 dfs_walk_real 中被用作 postfn ，在派生树中它从底部开始处理基类，即首先是非派生类的基类。这个次序对于虚拟主要基类来说是重要的（但非虚拟主要基类不要求这个次序，因为每个派生类都有自己的基类 binfo 拷贝）。
因此对于类 C ， dfs_modify_vtables 首先处理 C 中的 A 的 binfo 。在上面 2088 行的 FOR 循环中，对于指定的函数（即，带有 thunk 的 B1::f ），它进入这个指定基类的主要基类链，并选出定义了这个函数的最靠近的主要基类。对于我们例子中的带有 thunk 的 B1::f ，找出的 b 是 B1 ，并且 lost 是 false 。
当调用 find_final_overrider 时，注意到如果函数正在被处理的是一个 thunk ，需要提取真正的函数，并由下面的 fn 所指向。这里 fn 指向 C 中属于 A 的 B1::f 。
1194 static tree
1195 find_final_overrider (tree derived, tree binfo, tree fn) in class.c
1196 {
1197 find_final_overrider_data ffod;
1198 count_depth_data cd;
1199
1200 /* Getting this right is a little tricky. This is valid:
1201
1202 struct S { virtual void f (); };
1203 struct T { virtual void f (); };
1204 struct U : public S, public T { };
1205
1206 even though calling `f' in `U' is ambiguous. But,
1207
1208 struct R { virtual void f(); };
1209 struct S : virtual public R { virtual void f (); };
1210 struct T : virtual public R { virtual void f (); };
1211 struct U : public S, public T { };
1212
1213 is not -- there's no way to decide whether to put `S::f' or
1214 `T::f' in the vtable for `R'.
1215
1216 The solution is to look at all paths to BINFO. If we find
1217 different overriders along any two, then there is a problem. */
1218 if (DECL_THUNK_P (fn))
1219 fn = THUNK_TARGET (fn);
1220
1221 /* Determine the depth of the hierarchy. */
1222 cd.depth = 0;
1223 cd.max_depth = 0;
1224 dfs_walk (derived, dfs_depth_post , dfs_depth_q , &cd);
1225
1226 ffod.fn = fn;
1227 ffod.declaring_base = binfo;
1228 ffod.most_derived_type = BINFO_TYPE (derived);
1229 ffod.candidates = NULL_TREE;
1230 ffod.vpath_list = (tree *) xcalloc (cd.max_depth, sizeof (tree));
1231 ffod.vpath = ffod.vpath_list;
1232
1233 dfs_walk_real (derived,
1234 dfs_find_final_overrider ,
1235 dfs_find_final_overrider_post ,
1236 dfs_find_final_overrider_q ,
1237 &ffod);
1238
1239 free (ffod.vpath_list);
1240
1241 /* If there was no winner, issue an error message. */
1242 if (!ffod.candidates || TREE_CHAIN (ffod.candidates))
1243 return error_mark_node;
1244
1245 return ffod.candidates;
1246 }
具有类型 count_depth_data 的变量 cd 用在派生树的遍历过程。其类型定义如下。
1856 typedef struct count_depth_data { in class.c
1857 /* The depth of the current subobject, with "1" as the depth of the
1858 most derived object in the hierarchy. */
1859 size_t depth;
1860 /* The maximum depth found so far. */
1861 size_t max_depth;
1862 } count_depth_data ;
在 dfs_walk_real 中，函数 dfs_depth_q 被用作参数 qfn ，它自顶向下执行计算该类的派生层数（ find_final_overrider 的参数 derived 在这里，是当前类，即 C ）。
1886 static tree
1887 dfs_depth_q (tree derived, int i, void *data) in class.c
1888 {
1889 count_depth_data *cd = (count_depth_data *) data;
1890 cd->depth++;
1891 return BINFO_BASETYPE (derived, i);
1892 }
而 dfs_depth_post 在 dfs_walk_real 中作为参数 postfn ，它自底向上执行，趋向顶端派生程度最高的类。它在自顶向下访问树的过程中所作的记录里，找出最大派生层数。
1886 static tree
1887 dfs_depth_post (tree binfo ATTRIBUTE_UNUSED, void *data) in class.c
1888 {
1889 count_depth_data *cd = (count_depth_data *) data;
1890 if (cd->depth > cd->max_depth)
1891 cd->max_depth = cd->depth;
1892 cd->depth--;
1893 return NULL_TREE;
1894 }
看到在 1230 行， cd 的这个 max_depth 域被用作中 vpath_list 的维度， ffod 的类型是下面的 find_final_overrider_data 。
1893 typedef struct find_final_overrider_data_s { in class.c
1894 /* The function for which we are trying to find a final overrider. */
1895 tree fn;
1896 /* The base class in which the function was declared. */
1897 tree declaring_base;
1898 /* The most derived class in the hierarchy. */
1899 tree most_derived_type;
1900 /* The candidate overriders. */
1901 tree candidates;
1902 /* Each entry in this array is the next-most-derived class for a
1903 virtual base class along the current path. */
1904 tree *vpath_list;
1905 /* A pointer one past the top of the VPATH_LIST. */
1906 tree *vpath;
1907 } find_final_overrider_data ;
在内层的遍历中， dfs_find_final_overrider 被用作 dfs_walk_real 中的 prefn ，它将以前序次序执行，并且如果它返回非 0 值，将中止遍历。注意到参数 binfo 是 find_final_overrider 中的变量 derived ，并且作为 data 传入的 ffod 的 declaring_base 域最初是被 dfs_modify_vtables 当前以后序访问的基类的 binfo ，而 most_derived_type 域则指向派生程度最高的类（当前类）。
1955 static tree
1956 dfs_find_final_overrider (tree binfo, void* data) in class.c
1957 {
1958 find_final_overrider_data *ffod = (find_final_overrider_data *) data;
1959
1960 if (binfo == ffod->declaring_base)
1961 dfs_find_final_overrider_1 (binfo, ffod->vpath, ffod);
1962
1963 return NULL_TREE;
1964 }
注意到在内层遍历中， dfs_find_final_overrider 是以前序执行的，而 dfs_modify_vtables ，在外层遍历中，是以后序执行，并且 binfo 是正在被内层遍历访问的基类，而 data 记录了在运行内层遍历那一点上外层遍历的快照。因此当内层前序遍历运行到它被触发的那一点时，执行 dfs_find_final_overrider_1 。
不过在 1960 行的条件最终满足前， dfs_find_final_overrider_q 为每个遭遇的基类所执行。
1966 static tree
1967 dfs_find_final_overrider_q (tree derived, int ix, void *data) in class.c
1968 {
1969 tree binfo = BINFO_BASETYPE (derived, ix);
1970 find_final_overrider_data *ffod = (find_final_overrider_data *) data;
1971
1972 if (TREE_VIA_VIRTUAL (binfo))
1973 *ffod->vpath++ = derived;
1974
1975 return binfo;
1976 }
正如我们所期望的，被分析的虚拟基类被按照它们出现的次序来记录在 ffod 的 vpath 中。因此当离开这个基类时，它应该被 dfs_find_final_overrider_post 移除。
1978 static tree
1979 dfs_find_final_overrider_post (tree binfo, void *data) in class.c
1980 {
1981 find_final_overrider_data *ffod = (find_final_overrider_data *) data;
1982
1983 if (TREE_VIA_VIRTUAL (binfo))
1984 ffod->vpath--;
1985
1986 return NULL_TREE;
1987 }
在 dfs_find_final_overrider_1 中，参数 binfo 是在这次内层遍历中正在访问的基类，而 ffod 的 declaring_base 是在外层遍历中正在访问的 binfo ，在这个 binfo 中我们正在确定由 ffod 的 fn 所指定的虚函数的正确的重载版本。而现在 binfo 与 declaring_base 是相同的。
1905 static bool
1906 dfs_find_final_overrider_1 (tree binfo, in class.c
1907 tree *vpath,
1908 find_final_overrider_data *ffod)
1909 {
1910 tree method;
1911
1912 /* If BINFO is not the most derived type, try a more derived class.
1913 A definition there will overrider a definition here. */
1914 if (!same_type_p (BINFO_TYPE (binfo), ffod->most_derived_type))
1915 {
1916 tree derived;
1917
1918 if (TREE_VIA_VIRTUAL (binfo))
1919 derived = *--vpath;
1920 else
1921 derived = BINFO_INHERITANCE_CHAIN (binfo);
1922 if (dfs_find_final_overrider_1 (derived, vpath, ffod))
1923 return true;
1924 }
1925
1926 method = look_for_overrides_here (BINFO_TYPE (binfo), ffod->fn);
1927 if (method)
1928 {
1929 tree *candidate = &ffod->candidates;
1930
1931 /* Remove any candidates overridden by this new function. */
1932 while (*candidate)
1933 {
1934 /* If *CANDIDATE overrides METHOD, then METHOD
1935 cannot override anything else on the list. */
1936 if (base_derived_from (TREE_VALUE (*candidate), binfo))
1937 return true;
1938 /* If METHOD overrides *CANDIDATE, remove *CANDIDATE. */
1939 if (base_derived_from (binfo, TREE_VALUE (*candidate)))
1940 *candidate = TREE_CHAIN (*candidate);
1941 else
1942 candidate = &TREE_CHAIN (*candidate);
1943 }
1944
1945 /* Add the new function. */
1946 ffod->candidates = tree_cons (method, binfo, ffod->candidates);
1947 return true;
1948 }
1949
1950 return false;
1951 }
注意上面 1922 行的递归调用，该函数给了派生程度最高的类比基类更高的优先级。因此在 base_derived_from 的帮助下，它能找出重载了这个函数的派生程度最高的基类。 base_derived_from 确定了它从那里派生来的。
1836 static bool
1837 base_derived_from (tree derived, tree base) in class.c
1838 {
1839 tree probe;
1840
1841 for (probe = base; probe; probe = BINFO_INHERITANCE_CHAIN (probe))
1842 {
1843 if (probe == derived)
1844 return true;
1845 else if (TREE_VIA_VIRTUAL (probe))
1846 /* If we meet a virtual base, we can't follow the inheritance
1847 any more. See if the complete type of DERIVED contains
1848 such a virtual base. */
1849 return purpose_member (BINFO_TYPE (probe),
1850 CLASSTYPE_VBASECLASSES (BINFO_TYPE (derived)))
1851 != NULL_TREE;
1852 }
1853 return false;
1854 }
这个来自派生程度最高的基类中的虚函数被赋予下面的 overrider_target 。对于我们的例子 A 中带有 thunk 的 B::f ， overrider_target 获得的是 C::f 。现在对于这个例子，我们有， target_fn ： B* B::f() ， overrider_target ： C* C::f() 。记住这个 A 中的 B::f 具有一个结果调整的 thunk ，其中 virutal-offset 是： B1 中的 A ， fix-offset 是： 0 （ A -> B1 ）。
看到如果该 thunk 包含了 virtual-offset ，它应该来自以 2140 行的 over_return 为根节点的派生树中。因此我们可以得到正确的虚拟基类偏移（ virtual offset ）。
update_vtable_entry_for_fn (continue)
2109 /* Check for adjusting covariant return types. */
2110 over_return = TREE_TYPE (TREE_TYPE (overrider_target));
2111 base_return = TREE_TYPE (TREE_TYPE (target_fn));
2112
2113 if (POINTER_TYPE_P (over_return)
2114 && TREE_CODE (over_return) == TREE_CODE (base_return)
2115 && CLASS_TYPE_P (TREE_TYPE (over_return))
2116 && CLASS_TYPE_P (TREE_TYPE (base_return)))
2117 {
2118 /* If FN is a covariant thunk, we must figure out the adjustment
2119 to the final base FN was converting to. As OVERRIDER_TARGET might
2120 also be converting to the return type of FN, we have to
2121 combine the two conversions here. */
2122 tree fixed_offset, virtual_offset;
2123
2124 over_return = TREE_TYPE (over_return);
2125 base_return = TREE_TYPE (base_return);
2126
2127 if (DECL_THUNK_P (fn))
2128 {
2129 my_friendly_assert (DECL_RESULT_THUNK_P (fn), 20031211);
2130 fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn));
2131 virtual_offset = THUNK_VIRTUAL_OFFSET (fn);
2132 }
2133 else
2134 fixed_offset = virtual_offset = NULL_TREE;
2135
2136 if (virtual_offset)
2137 /* Find the equivalent binfo within the return type of the
2138 overriding function. We will want the vbase offset from
2139 there. */
2140 virtual_offset =
2141 TREE_VALUE (purpose_member
2142 (BINFO_TYPE (virtual_offset),
2143 CLASSTYPE_VBASECLASSES (over_return)));
2144 else if (!same_type_ignoring_top_level_qualifiers_p
2145 (over_return, base_return))
2146 {
2147 /* There was no existing virtual thunk (which takes
2148 precedence). So find the binfo of the base function's
2149 return type within the overriding function's return type.
2150 We cannot call lookup base here, because we're inside a
2151 dfs_walk, and will therefore clobber the BINFO_MARKED
2152 flags. Fortunately we know the covariancy is valid (it
2153 has already been checked), so we can just iterate along
2154 the binfos, which have been chained in inheritance graph
2155 order. Of course it is lame that we have to repeat the
2156 search here anyway -- we should really be caching pieces
2157 of the vtable and avoiding this repeated work. */
2158 tree thunk_binfo, base_binfo;
2159
2160 /* Find the base binfo within the overriding function's
2161 return type. We will always find a thunk_binfo, except
2162 when the covariancy is invalid (which we will have
2163 already diagnosed). */
2164 for (base_binfo = TYPE_BINFO (base_return),
2165 thunk_binfo = TYPE_BINFO (over_return);
2166 thunk_binfo;
2167 thunk_binfo = TREE_CHAIN (thunk_binfo))
2168 if (same_type_p (BINFO_TYPE (thunk_binfo),
2169 BINFO_TYPE (base_binfo)))
2170 break ;
2171
2172 /* See if virtual inheritance is involved. */
2173 for (virtual_offset = thunk_binfo;
2174 virtual_offset;
2175 virtual_offset = BINFO_INHERITANCE_CHAIN (virtual_offset))
2176 if (TREE_VIA_VIRTUAL (virtual_offset))
2177 break ;
2178
2179 if (virtual_offset
2180 || (thunk_binfo && !BINFO_OFFSET_ZEROP (thunk_binfo)))
2181 {
2182 tree offset = convert (ssizetype, BINFO_OFFSET (thunk_binfo));
2183
2184 if (virtual_offset)
2185 {
2186 /* We convert via virtual base. Adjust the fixed
2187 offset to be from there. */
2188 offset = size_diffop
2189 (offset, convert
2190 (ssizetype, BINFO_OFFSET (virtual_offset)));
2191 }
2192 if (fixed_offset)
2193 /* There was an existing fixed offset, this must be
2194 from the base just converted to, and the base the
2195 FN was thunking to. */
2196 fixed_offset = size_binop (PLUS_EXPR, fixed_offset, offset);
2197 else
2198 fixed_offset = offset;
2199 }
2200 }
2201
2202 if (fixed_offset || virtual_offset)
2203 /* Replace the overriding function with a covariant thunk. We
2204 will emit the overriding function in its own slot as
2205 well. */
2206 overrider_fn = make_thunk (overrider_target, /*this_adjusting=*/ 0,
2207 fixed_offset, virtual_offset);
2208 }
2209 else
2210 my_friendly_assert (!DECL_THUNK_P (fn), 20021231);
3564
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
