5.12.5.2.2.2.1.3.9. 完成派生类的 RECORD_TYPE – 布局
回到 finish_struct_1 中，下面的 keyed_classes 是一个保存那些在这个编译单元中将可能发布 vtable 的类的 tree_list 。这个链表中的候选者是不含有非内联、非纯虚方法的类。换而言之，是仅含有纯虚方法或（及）内联虚方法的类。对于这样的类，在每个该类定义出现的编译单元中（如，通过 #include ），应该发布其 vtable ；而对于含有其它虚方法的类，每个包含了其虚方法定义的编译单元要发布其 vtable 。
finish_struct_1 (continue)
5033 /* Find the key method. */
5034 if (TYPE_CONTAINS_VPTR_P (t))
5035 {
5036 CLASSTYPE_KEY_METHOD (t) = key_method (t);
5037
5038 /* If a polymorphic class has no key method, we may emit the vtable
5039 i n every translation unit where the class definition appears. */
5040 if (CLASSTYPE_KEY_METHOD (t) == NULL_TREE)
5041 keyed_classes = tree_cons (NULL_TREE, t, keyed_classes );
5042 }
5043
5044 /* Layout the class itself. */
5045 layout_class_type (t, &virtuals);
5046 if (CLASSTYPE_AS_BASE (t) != t)
5047 /* We use the base type for trivial assignments, and hence it
5048 needs a mode. */
5049 compute_record_mode (CLASSTYPE_AS_BASE (t));
CLASSTYPE_KEY_METHOD 保存了类中第一个非内联及非纯虚方法 ，这个域在 vtable 的产生过程中要用到。
4973 static tree
4974 key_method (tree type) in class.c
4975 {
4976 tree method;
4977
4978 if (TYPE_FOR_JAVA (ty pe)
4979 || processing_template_decl
4980 || CLASSTYPE_TEMPLATE_INSTANTIATION (type)
4981 || CLASSTYPE_INTERFACE_KNOWN (type))
4982 return NULL_TREE;
4983
4984 for (method = TYPE_METHODS (type); method != NULL_TREE;
4985 method = TREE_CHAIN (method))
4986 if (DECL_VINDEX (method) != NULL_TREE
4987 && ! DECL_DECLARED_INLINE_P (method)
4988 && ! DECL_PURE_VIRTUAL_P (method))
4989 return method;
4990
4991 return NULL_TREE;
4992 }
记住在类模板中是不允许出现虚函数的。
如果我们已经确定了是否要在该编译单元中产生 vtable ， VTT ， typeinfo 及其他类似的类维护数据， CLASSTYPE_INTERFACE_KNOWN 是 true ，这样的类即便满足上述条件，也不应该被保存在 keyed_classes 中。
接着我们可以为类布局来决定类型的真正的大小，每个数据成员的偏移量，大小，填充字节，甚至由编译器产生的维护数据。毫无疑问，这是一个相当复杂的过程。
在深入到代码之前，我们首先看一下 GCC 为下面的例子所做的布局：
例 1 ：
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 (); };
int main() { return 0; }
用命令 g++ -fdump-class-hierarchy –o test test.cc ， gcc 将把关于类的信息转储到一个转储文件（如： test.01.class ）中，我们可以看到如下的输出（暂时忽略布局以外的信息）：
…
Class A
size=4 align=4
base size=4 base align=4
A (0xb7f2d680) 0 nearly-empty
vptr=((& A::_ZTV1A) + 8u)
…
Class B1
size=4 align=4
base size=4 base align=4
B1 (0xb7f2d700) 0 nearly-empty
vptridx=0u vptr=((& B1::_ZTV2B1) + 16u)
A (0xb7f2d740) 0 nearly-empty virtual
primary-for B1 (0xb7f2d700)
vptridx=4u vbaseoffset=-0x000000010
…
Class B2
size=4 align=4
base size=4 base align=4
B2 (0xb7f2d840) 0 nearly-empty
vptridx=0u vptr=((& B2::_ZTV2B2) + 16u)
A (0xb7f2d880) 0 nearly-empty virtual
primary-for B2 (0xb7f2d840)
vptridx=4u vbaseoffset=-0x000000010
…
Class C
size=8 align=4
base size=8 base align=4
C (0xb7f2d940) 0
vptridx=0u vptr=((& C::_ZTV1C) + 16u)
B1 (0xb7f2d980) 0 nearly-empty
primary-for C (0xb7f2d940)
subvttidx=4u
A (0xb7f2d9c0) 0 nearly-empty virtual
primary-for B1 (0xb7f2d980)
vptridx=20u vbaseoffset=-0x000000010
B2 (0xb7f2da00) 4 nearly-empty
lost-primary
subvttidx=12u vptridx=24u vptr=((& C::_ZTV1C) + 40u)
A (0xb7f2d9c0) alternative-path
在输出“ A (0xb7f2d680) 0 nearly-empty ”中，“ A ”是 binfo 所来自的类，“ (0xb7f2d680) ”是 binfo 的地址，“ 0 ”是 binfo 在类布局中的偏移量，“ nearly-empty ”表明该类是一个几乎空的类。
而输出“ size=8 align=4 ”是该类的大小及对齐量，而“ base size=8 base align=4 ”是该类的 CLASSTYPE_AS_BASE （去除虚拟基类）的大小及对齐量。
例 2 （在类 A 中增加域“ int a ”）：
class A { int 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 (); };
int main() { return 0; }
其输出则是：
…
Class A
size=8 align=4
base size=8 base align=4
A (0xb7fae680) 0
vptr=((& A::_ZTV1A) + 8u)
…
Class B1
size=12 align=4
base size=4 base align=4
B1 (0xb7fae700) 0 nearly-empty
vptridx=0u vptr=((& B1::_ZTV2B1) + 12u)
A (0xb7fae740) 4 virtual
vptridx=4u vbaseoffset=-0x00000000c vptr=((& B1::_ZTV2B1) + 28u)
…
Class B2
size=12 align=4
base size=4 base align=4
B2 (0xb7fae800) 0 nearly-empty
vptridx=0u vptr=((& B2::_ZTV2B2) + 12u)
A (0xb7fae840) 4 virtual
vptridx=4u vbaseoffset=-0x00000000c vptr=((& B2::_ZTV2B2) + 28u)
…
Class C
size=16 align=4
base size=8 base align=4
C (0xb7fae8c0) 0
vptridx=0u vptr=((& C::_ZTV1C) + 12u)
B1 (0xb7fae900) 0 nearly-empty
primary-for C (0xb7fae8c0)
subvttidx=4u
A (0xb7fae940) 8 virtual
vptridx=20u vbaseoffset=-0x00000000c vptr=((& C::_ZTV1C) + 44u)
B2 (0xb7fae980) 4 nearly-empty
subvttidx=12u vptridx=24u vptr=((& C::_ZTV1C) + 28u)
A (0xb7fae940) alternative-path
通过引入域“ int a “，类 A 不再是一个几乎空的类，但 B1 及 B2 还是。这一事实深刻地影响着布局。在下面的代码中我们可以找到其原因。
4637 static void
4638 layout_class_type (tree t, tree *virtuals_p) in class.c
4639 {
4640 tree non_static_data_members;
4641 tree field;
4642 tree vptr;
4643 record_layout_info rli;
4644 /* Maps offsets (represented as INTEGER_CSTs) to a TREE_LIST of
4645 types that appear at that offset. */
4646 splay_tree empty_base_offsets;
4647 /* True if the last field layed out was a bit-field. */
4648 bool last_field_was_bitfield = false;
4649 /* The location at which the next field should be inserted. */
4650 tree *next_field;
4651 /* T, as a base class. */
4652 tree base_t;
4653
4654 /* Keep track of the first non-static data member. */
4655 non_static_data_members = TYPE_FIELDS (t);
4656
4657 /* Start laying out the record. */
4658 rli = start_record_layout (t);
4659
4660 /* If possible, we reuse the virtual function table pointer from one
4661 of our base classes. */
4662 determine_primary_base (t);
在多继承的情况下，在派生类中基类将被依次编排。第一个基类有偏移量 0 ，无疑可以从派生类的头部直接访问其成员，而其它随后的基类，要访问其成员，其成员的偏移量要加上基类本身到派生类头部的偏移量，等于包含了一个额外的间接寻址。加上深度继承的情形，需要仔细选择第一个编排的基类。注意到这里每个类定义都调用了 determine_primary_base 。如果我们为一个复杂类来调用它，其基类应该已经被这个函数处理过了。
1267 static void
1268 determine_primary_base (tree t) in class.c
1269 {
1270 int i, n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
1271 tree vbases;
1272 tree type_binfo;
1273
1274 /* If there are no baseclasses, there is certainly no primary base. */
1275 if (n_baseclasses == 0)
1276 return ;
1277
1278 type_binfo = TYPE_BINFO (t);
1279
1280 for (i = 0; i < n_baseclasses; i++)
1281 {
1282 tree base_binfo = BINFO_BASETYPE (type_binfo, i);
1283 tree basetype = BINFO_TYPE (base_binfo);
1284
1285 if (TYPE_CONTAINS_VPTR_P (basetype))
1286 {
1287 /* We prefer a non-virtual base, although a virtual one will
1288 do. */
1289 if (TREE_VIA_VIRTUAL (base_binfo))
1290 continue ;
1291
1292 if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
1293 {
1294 set_primary_base (t, base_binfo);
1295 CLASSTYPE_VFIELDS (t) = copy_list (CLASSTYPE_VFIELDS (basetype));
1296 }
1297 else
1298 {
1299 tree vfields;
1300
1301 /* Only add unique vfields, and flatten them out as we go. */
1302 for (vfields = CLASSTYPE_VFIELDS (basetype);
1303 vfields;
1304 vfields = TREE_CHAIN (vfields))
1305 if (VF_BINFO_VALUE (vfields) == NULL_TREE
1306 || ! TREE_VIA_VIRTUAL (VF_BINFO_VALUE (vfields)))
1307 CLASSTYPE_VFIELDS (t)
1308 = tree_cons (base_binfo,
1309 VF_BASETYPE_VALUE (vfields),
1310 CLASSTYPE_VFIELDS (t));
1311 }
1312 }
1313 }
含有 vtable 的非虚拟基类是最好的选择。碰到的第一个这样的基类被下面的 set_primary_base 与派生类绑定起来。注意 TYPE_VFIELD 是由编译器产生的指向 vtable 的域。
1253 static void
1254 set_primary_base (tree t, tree binfo) in class.c
1255 {
1256 tree basetype;
1257
1258 CLASSTYPE_PRIMARY_BINFO (t) = binfo;
1259 basetype = BINFO_TYPE (binfo);
1260 TYPE_BINFO_VTABLE (t) = TYPE_BINFO_VTABLE (basetype);
1261 TYPE_BINFO_VIRTUALS (t) = TYPE_BINFO_VIRTUALS (basetype);
1262 TYPE_VFIELD (t) = TYPE_VFIELD (basetype);
1263 }
上面的域 CLASSTYPE_VFIELDS 是这个类型所持有的 vtable 链表（主要及次要 vtable ）。其节点中的 TREE_VALUE 是引入这个 vtable 的类型。对于引入该 vtable ，或从其主要基类继承该 vtable 的类，节点的 TREE_PURPOSE 则是 NULL 。对于其它 vtable （来自次要基类），其节点的 TREE_PURPOSE 是该 vtable 所来自的基类的 BINFO 。
注意派生类的 CLASSTYPE_VFIELDS 开始是空的；而且虚拟基类，除非它几乎是空的（这时它不可能有 vtable ），是不能作为派生类的主要基类（就算它是唯一有 vtable 的基类）。因此上面对 vtable 的拷贝能确保只对非虚拟基类进行。并且注意如果是主要基类，派生类直接拷贝其 CLASSTYPE_VFIELDS （用于这个主要基类 vtable 的节点的 PURPOSE 域为 NULL ）。这是因为主要基类就在派生类的头部，如果其有 vtable ，这个 vtable 的地址也就是派生类 vtable 所在地址，派生类将直接把这个 vtable 据为己有。
determine_primary_base (continue)
1315 if (!TYPE_VFIELD (t))
1316 CLASSTYPE_PRIMARY_BINFO (t) = NULL_TREE;
1317
1318 /* Find the indirect primary bases - those virtual bases which are primary
1319 bases of something else in this hierarchy. */
1320 for (vbases = CLASSTYPE_VBASECLASSES (t);
1321 vbases;
1322 vbases = TREE_CHAIN (vbases))
1323 {
1324 tree vbase_binfo = TREE_VALUE (vbases);
1325
1326 /* See if this virtual base is an indirect primary base. To be so,
1327 it must be a primary base within the hierarchy of one of our
1328 direct bases. */
1329 for (i = 0; i < n_baseclasses; ++i)
1330 {
1331 tree basetype = TYPE_BINFO_BASETYPE (t, i);
1332 tree v;
1333
1334 for (v = CLASSTYPE_VBASECLASSES (basetype);
1335 v;
1336 v = TREE_CHAIN (v))
1337 {
1338 tree base_vbase = TREE_VALUE (v);
1339
1340 if (BINFO_PRIMARY_P (base_vbase)
1341 && same_type_p (BINFO_TYPE (base_vbase),
1342 BINFO_TYPE (vbase_binfo)))
1343 {
1344 BINFO_INDIRECT_PRIMARY_P (vbase_binfo) = 1;
1345 break ;
1346 }
1347 }
1348
1349 /* If we've discovered that this virtual base is an indirect
1350 primary base, then we can move on to the next virtual
1351 base. */
1352 if (BINFO_INDIRECT_PRIMARY_P (vbase_binfo))
1353 break ;
1354 }
1355 }
1356
1357 /* A "nearly-empty" virtual base class can be the primary base
1358 class, if no non-virtual polymorphic base can be found. */
1359 if (!CLASSTYPE_HAS_PRIMARY_BASE_P (t))
1360 {
1361 /* If not NULL, this is the best primary base candidate we have
1362 found so far. */
1363 tree candidate = NULL_TREE;
1364 tree base_binfo;
1365
1366 /* Loop over the baseclasses. */
1367 for (base_binfo = TYPE_BINFO (t);
1368 base_binfo;
1369 base_binfo = TREE_CHAIN (base_binfo))
1370 {
1371 tree basetype = BINFO_TYPE (base_binfo);
1372
1373 if (TREE_VIA_VIRTUAL (base_binfo)
1374 && CLASSTYPE_NEARLY_EMPTY_P (basetype))
1375 {
1376 /* If this is not an indirect primary base, then it's
1377 definitely our primary base. */
1378 if (!BINFO_INDIRECT_PRIMARY_P (base_binfo))
1379 {
1380 candidate = base_binfo;
1381 break ;
1382 }
1383
1384 /* If this is an indirect primary base, it still could be
1385 our primary base -- unless we later find there's another
1386 nearly-empty virtual base that isn't an indirect
1387 primary base. */
1388 if (!candidate)
1389 candidate = base_binfo;
1390 }
1391 }
1392
1393 /* If we've got a primary base, use it. */
1394 if (candidate)
1395 {
1396 set_primary_base (t, candidate);
1397 CLASSTYPE_VFIELDS (t)
1398 = copy_list (CLASSTYPE_VFIELDS (BINFO_TYPE (candidate)));
1399 }
1400 }
1401
1402 /* Mark the primary base classes at this point. */
1403 mark_primary_bases (t);
1404 }
如果没有找到含有 vtable 的非虚拟基类，派生类的 TYPE_VFIELD 保持为 NULL （在 set_primary base 中，它会被设置为主要基类的 TYPE_VFIELD ），这时不管以前把 CLASSTYPE_PRIMARY_BINFO 设置成什么，把它置为 NULL 。接着看看能不能在虚拟基类中找到可以作为主要基类的。能作为主要基类的虚拟基类，除了需要是几乎空的之外，没有被用作其基类的主要基类是优先考虑的，否则就将就使用在派生类声明中最后出现的虚拟基类（这样也减少了冲突的机会）。
严格来说，在一个派生类中只有一个主要基类。例如：
class A {…}; class B: public A {…}; class C: public B {…};
此中类 B 的主要基类是 A 。而在类 C 中，主要基类是 B ，不再是 A 。但是 C 中关于 B 的 binfo 是从类 B 中拷贝过来的，拷贝时没有拷入关于主要基类的信息。不过虚拟基类则不然，下面的函数还会对它进行“拨乱反正”。
1218 static void
1219 mark_primary_bases (tree type) in class.c
1220 {
1221 tree binfo;
1222
1223 /* Walk the bases in inheritance graph order. */
1224 for (binfo = TYPE_BINFO (type); binfo; binfo = TREE_CHAIN (binfo))
1225 {
1226 tree base_binfo = get_primary_binfo (binfo);
1227
1228 if (!base_binfo)
1229 /* Not a dynamic base. */ ;
1230 else if (BINFO_PRIMARY_P (base_binfo))
1231 BINFO_LOST_PRIMARY_P (binfo) = 1;
1232 else
1233 {
1234 BINFO_PRIMARY_BASE_OF (base_binfo) = binfo;
1235 /* A virtual binfo might have been copied from within
1236 another hierarchy. As we're about to use it as a primary
1237 base, make sure the offsets match. */
1238 if (TREE_VIA_VIRTUAL (base_binfo))
1239 {
1240 tree delta = size_diffop (convert (ssizetype,
1241 BINFO_OFFSET (binfo)),
1242 convert (ssizetype,
1243 BINFO_OFFSET (base_binfo)));
1244
1245 propagate_binfo_offsets (base_binfo, delta);
1246 }
1247 }
1248 }
1249 }
在 1226 行的 get_primary_binfo 返回参数 binfo 所对应类型的主要基类的 binfo 的拷贝，如果设置了主要基类的话；否则返回 NULL 。
6470 tree
6471 get_primary_binfo (tree binfo) in class.c
6472 {
6473 tree primary_base;
6474 tree result;
6475
6476 primary_base = CLASSTYPE_PRIMARY_BINFO (BINFO_TYPE (binfo));
6477 if (!primary_base)
6478 return NULL_TREE;
6479
6480 result = copied_binfo (primary_base, binfo);
6481 return result;
6482 }
copied_binfo 根据给定的 primary_base ，从 binfo 中找出对应的部分。考虑以下例子：
class A { virtual … };
class B: public A { virtual … };
class C: public A { virtual … };
class D: public B, C { … };
首先，在 mark_primary_bases 的 1224 行， TYPE_BINFO(D) 得到一个链表，其中依次是 D à B à A à C à A 。显然， CLASSTYPE_PRIMARY_BINFO(D) 返回 B 的 binfo 拷贝（它由 set_primary_base 设置）；然后在下面的 2578 行，递归进入 copied_binfo 并得到 D 的 binfo ，接着在 2581 行的 FOR 循环中，在 D 的基类 B 、 C 中查找，找出目标 B 。因为该 B 的 binfo 拷贝来自类 B ， 1230 行的 BINFO_PRIMARY_P (base_binfo) 返回 NULL ，这表示 B 不是主要基类（但现在是！）。因此在 1234 行，我们把它设为 D 的主要基类（注意与 CLASSTYPE_PRIMARY_BINFO 的区别）。
那么对于 B 的 binfo ， A 是其主要基类。在 D 中查找 A 的 binfo 拷贝与查找 B 的 binfo 拷贝类似，除了在 D 中 A 同时出现在 B 及 C 中。不过查找的过程能保证找到的是 B à A 。因为 A 是类 B 的主要基类，但在 A 拷贝的 binfo 中，并没有设置 BINFO_PRIMARY_P ，它满足 1232 行条件，被设置为 B 的拷贝 binfo 的主要基类。
同样的我们可以得到 D 中 C 部分的 A 的 binfo 拷贝，并且它也没有设置 BINFO_PRIMARY_P 。
2556 tree
2557 copied_binfo (tree binfo, tree here) in search.c
2558 {
2559 tree result = NULL_TREE;
2560
2561 if (TREE_VIA_VIRTUAL (binfo))
2562 {
2563 tree t;
2564
2565 for (t = here; BINFO_INHERITANCE_CHAIN (t);
2566 t = BINFO_INHERITANCE_CHAIN (t))
2567 continue ;
2568
2569 result = purpose_member (BINFO_TYPE (binfo),
2570 CLASSTYPE_VBASECLASSES (BINFO_TYPE (t)));
2571 result = TREE_VALUE (result);
2572 }
2573 else if (BINFO_INHERITANCE_CHAIN (binfo))
2574 {
2575 tree base_binfos;
2576 int ix, n;
2577
2578 base_binfos = copied_binfo (BINFO_INHERITANCE_CHAIN (binfo), here);
2579 base_binfos = BINFO_BASETYPES (base_binfos);
2580 n = TREE_VEC_LENGTH (base_binfos);
2581 for (ix = 0; ix != n; ix++)
2582 {
2583 tree base = TREE_VEC_ELT (base_binfos, ix);
2584
2585 if (BINFO_TYPE (base) == BINFO_TYPE (binfo))
2586 {
2587 result = base;
2588 break ;
2589 }
2590 }
2591 }
2592 else
2593 {
2594 my_friendly_assert (BINFO_TYPE (here) == BINFO_TYPE (binfo), 20030202);
2595 result = here;
2596 }
2597
2598 my_friendly_assert (result, 20030202);
2599 return result;
2600 }
进一步考虑如下的例子：
class A { virtual …};
class B: virtual public A { … };
class C: virtual public A { … };
class D: public B, C { … };
在 TYPE_BINFO(D) 链表中，依次是 D à B à A à C ，因为 A 作为虚拟基类在 D 中只能维持一个实例。这个过程是几乎相同的，除了查找虚拟基类的 binfo 拷贝时，是从继承树顶开始向下，而不是从基类开始往上爬。另外，由于虚拟基类 A 不使用拷贝 binfo ，因此在 mark_primary_bases 中，它满足 1230 行条件。
在 copy_base_binfos 中，连同 binfo 拷贝的还有偏移量信息。不过这个偏移量是关于被拷贝的 binfo 。而作为主要基类，虚拟基类（也包括非虚拟基类）必须被放在布局的最前面（事实上紧跟着 vtable ）。这个调整由 propagate_binfo_offsets 来完成（对于非虚拟的基类 binfo ，它的偏移量一直是 0 ，并且在当前类中编排该基类时，其非虚拟基类也维持着不变的相对偏移量）。
4355 static void
4356 propagate_binfo_offsets (tree binfo, tree offset) in class.c
4357 {
4358 int i;
4359 tree primary_binfo;
4360
4361 /* Update BINFO's offset. */
4362 BINFO_OFFSET (binfo)
4363 = convert (sizetype,
4364 size_binop (PLUS_EXPR,
4365 convert (ssizetype, BINFO_OFFSET (binfo)),
4366 offset));
4367
4368 /* Find the primary base class. */
4369 primary_binfo = get_primary_binfo (binfo);
4370
4371 /* Scan all of the bases, pushing the BINFO_OFFSET adjust
4372 downwards. */
4373 for (i = -1; i < BINFO_N_BASETYPES (binfo); ++i)
4374 {
4375 tree base_binfo;
4376
4377 /* On the first time through the loop, do the primary base.
4378 Because the primary base need not be an immediate base, we
4379 must handle the primary base specially. */
4380 if (i == -1)
4381 {
4382 if (!primary_binfo)
4383 continue ;
4384
4385 base_binfo = primary_binfo;
4386 }
4387 else
4388 {
4389 base_binfo = BINFO_BASETYPE (binfo, i);
4390 /* Don't do the primary base twice. */
4391 if (base_binfo == primary_binfo)
4392 continue ;
4393 }
4394
4395 /* Skip virtual bases that aren't our canonical primary base. */
4396 if (TREE_VIA_VIRTUAL (base_binfo)
4397 && BINFO_PRIMARY_BASE_OF (base_binfo) != binfo)
4398 continue ;
4399
4400 propagate_binfo_offsets (base_binfo, offset);
4401 }
4402 }
函数 propagate_binfo_offsets 把偏移量的调整应用到整个基类。记得 BINFO_OFFSET 表示该基类在其派生类中的偏移量。前面看到主要基类不一定是直接基类，因此 4373 行的 FOR 循环需要多一次计数来包括可能不是直接基类的主要基类。
125
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
