layout_class_type (continue)
4664 /* Create a pointer to our virtual function table. */
4665 vptr = create_vtable_ptr (t, virtuals_p);
4666
4667 /* The vptr is always the first thing in the class. */
4668 if (vptr)
4669 {
4670 TREE_CHAIN (vptr) = TYPE_FIELDS (t);
4671 TYPE_FIELDS (t) = vptr;
4672 next_field = &TREE_CHAIN (vptr);
4673 place_field (rli, vptr);
4674 }
4675 else
4676 next_field = &TYPE_FIELDS (t);
回到 layout_class_type ，在对类进行了完整性检查并确定了主要基类后，编译器为 vptr 的生成做准备。这里在 create_vtable_ptr 中，参数 virtuals_p 来自 finish_struct_1 里的局部变量 virtuals ，参数 t 是类本身。注意到 TYPE_VFIELD (t) 不是空的，如果它的主要基类含有 vptr （它在 set_primary_base 中设置）。因此只要该类能从其主要基类中得到 TYPE_VFIELD ，就不需要为其创建 vptr 。
4328 行的 FOR 循环对于 vtable 的构建是非常关键的，它把由该类声明的所有的虚函数拷贝到另一个链表 virtual_p ，并且注意 4245 行的赋值，被拷贝函数的 BV_DELTA 被设为 0 （ BV_DELTA 代表当调用该虚函数时，需要从 this 指针减去的字节数【这时得到声明该虚函数的基类 this 指针】）。
DECL_VINDEX 在 FUNCTION_DECL 中有两个用途。在包含该 FUNCTION_DECL 的类被编排前， DECL_VINDEX 可能指向一个基类中的一个 FUNCTION_DECL ，它是当前的 FUNCTION_DECL 作为虚函数所要替代的。当类编排后，这个指针就改为一个 INTEGER_CST 节点，用作虚函数表的索引。那么对于未编排类的 FUNCTION_DECL ，它们被记录在 virtual_p 所指向的 tree_list 中。
4232 static tree
4233 create_vtable_ptr (tree t, tree* virtuals_p) in class.c
4234 {
4235 tree fn;
4236
4237 /* Collect the virtual functions declared in T. */
4238 for (fn = TYPE_METHODS (t); fn; fn = TREE_CHAIN (fn))
4239 if (DECL_VINDEX (fn) && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn)
4240 && TREE_CODE (DECL_VINDEX (fn)) != INTEGER_CST)
4241 {
4242 tree new_virtual = make_node (TREE_LIST);
4243
4244 BV_FN (new_virtual) = fn;
4245 BV_DELTA (new_virtual) = integer_zero_node;
4246
4247 TREE_CHAIN (new_virtual) = *virtuals_p;
4248 *virtuals_p = new_virtual;
4249 }
4250
4251 /* If we couldn't find an appropriate base class, create a new field
4252 here. Even if there weren't any new virtual functions, we might need a
4253 new virtual function table if we're supposed to include vptrs in
4254 all classes that need them. */
4255 if (!TYPE_VFIELD (t) && (*virtuals_p || TYPE_CONTAINS_VPTR_P (t)))
4256 {
4257 /* We build this decl with vtbl_ptr_type_node, which is a
4258 `vtable_entry_type*'. It might seem more precise to use
4259 `vtable_entry_type (*)[N]' where N is the number of firtual
4260 functions. However, that would require the vtable pointer in
4261 base classes to have a different type than the vtable pointer
4262 i n derived classes. We could make that happen, but that
4263 still wouldn't solve all the problems. In particular, the
4264 type-based alias analysis code would decide that assignments
4265 to the base class vtable pointer can't alias assignments to
4266 the derived class vtable pointer, since they have different
4267 types. Thus, in a derived class destructor, where the base
4268 class constructor was inlined, we could generate bad code for
4269 setting up the vtable pointer.
4270
4271 Therefore, we use one type for all vtable pointers. We still
4272 use a type-correct type; it's just doesn't indicate the array
4273 bounds. That's better than using `void*' or some such; it's
4274 cleaner, and it let's the alias analysis code know that these
4275 stores cannot alias stores to void*! */
4276 tree field;
4277
4278 field = build_decl (FIELD_DECL, get_vfield_name (t), vtbl_ptr_type_node );
4279 SET_DECL_ASSEMBLER_NAME (field, get_identifier (VFIELD_BASE));
4280 DECL_VIRTUAL_P (field) = 1;
4281 DECL_ARTIFICIAL (field) = 1;
4282 DECL_FIELD_CONTEXT (field) = t;
4283 DECL_FCONTEXT (field) = t;
4284
4285 TYPE_VFIELD (t) = field;
4286
4287 /* This class is non-empty. */
4288 CLASSTYPE_EMPTY_P (t) = 0;
4289
4290 if (CLASSTYPE_N_BASECLASSES (t))
4291 /* If there were any baseclasses, they can't possibly be at
4292 offset zero any more, because that's where the vtable
4293 pointer is. So, converting to a base class is going to
4294 take work. */
4295 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (t) = 1;
4296
4297 return field;
4298 }
4299
4300 return NULL_TREE;
4301 }
如果主要基类没有 vtable （或者压根没有主要基类），但派生类本身有虚函数，那么在这里编译器为其生成。在 4279 行的 VFIELD_BASE 是字符串“ $vf ”。而在 4295 行，如果类有基类，编译器还将需要产生转换操作符来执行派生类到基类间的转换。在 4278 行，在 cxx_init_decl_processing 中 vtbl_ptr_type_node 被初始化为 vtable_entry_type * ，也即具有类型 int(*)() 。
看到在 layout_class_type 的 4673 行，如果要新建 vtable ，调用 place_field 首先在类里布局这个 vtable 。
layout_class_type (continue)
4678 /* Build FIELD_DECLs for all of the non-virtual base-types. */
4679 empty_base_offsets = splay_tree_new (splay_tree_compare_integer_csts,
4680 NULL, NULL);
4681 build_base_fields (rli, empty_base_offsets, next_field);
而对于其他部分，一棵伸展树（ splaying tree ） empty_base_offsets 被创建在布局过程中保存空基类的偏移量。把这个伸展树作为 offsets 实参， build_base_fields 开始布局类的基类。
3729 static void
3730 build_base_fields (record_layout_info rli, in class.c
3731 splay_tree offsets, tree *next_field)
3732 {
3733 /* Chain to hold all the new FIELD_DECLs which stand in for base class
3734 subobjects. */
3735 tree t = rli->t;
3736 int n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
3737 int i;
3738
3739 /* The primary base class is always allocated first. */
3740 if (CLASSTYPE_HAS_PRIMARY_BASE_P (t))
3741 next_field = build_base_field (rli, CLASSTYPE_PRIMARY_BINFO (t),
3742 offsets, next_field);
3743
3744 /* Now allocate the rest of the bases. */
3745 for (i = 0; i < n_baseclasses; ++i)
3746 {
3747 tree base_binfo;
3748
3749 base_binfo = BINFO_BASETYPE (TYPE_BINFO (t), i);
3750
3751 /* The primary base was already allocated above, so we don't
3752 need to allocate it again here. */
3753 if (base_binfo == CLASSTYPE_PRIMARY_BINFO (t))
3754 continue ;
3755
3756 /* Virtual bases are added at the end (a primary virtual base
3757 will have already been added). */
3758 if (TREE_VIA_VIRTUAL (base_binfo))
3759 continue ;
3760
3761 next_field = build_base_field (rli, base_binfo,
3762 offsets, next_field);
3763 }
3764 }
看到主要基类是首先被布局的（不管它是否是虚拟基类）——这就是为什么它被称为主要基类。然后其他基类按继承顺序处理。注意在 3758 行的条件，看到非主要虚拟基类不在这里编排，而是在后面的 layout_virtual_bases 里。
接着编译器要为这些基类构建对应的域，这样可以在派生类中采用统一的访问方式。
3628 static tree *
3629 build_base_field (record_layout_info rli, tree binfo, in class.c
3630 splay_tree offsets, tree *next_field)
3631 {
3632 tree t = rli->t;
3633 tree basetype = BINFO_TYPE (binfo);
3634
3635 if (!COMPLETE_TYPE_P (basetype))
3636 /* This error is now reported in xref_tag, thus giving better
3637 location information. */
3638 return next_field;
3639
3640 /* Place the base class. */
3641 if (!is_empty_class (basetype))
3642 {
3643 tree decl;
3644
3645 /* The containing class is non-empty because it has a non-empty
3646 base class. */
3647 CLASSTYPE_EMPTY_P (t) = 0;
3648
3649 /* Create the FIELD_DECL. */
3650 decl = build_decl (FIELD_DECL, NULL_TREE, CLASSTYPE_AS_BASE (basetype));
3651 DECL_ARTIFICIAL (decl) = 1;
3652 DECL_FIELD_CONTEXT (decl) = t;
3653 DECL_SIZE (decl) = CLASSTYPE_SIZE (basetype);
3654 DECL_SIZE_UNIT (decl) = CLASSTYPE_SIZE_UNIT (basetype);
3655 DECL_ALIGN (decl) = CLASSTYPE_ALIGN (basetype);
3656 DECL_USER_ALIGN (decl) = CLASSTYPE_USER_ALIGN (basetype);
3657 DECL_IGNORED_P (decl) = 1;
3658
3659 /* Try to place the field. It may take more than one try if we
3660 have a hard time placing the field without putting two
3661 objects of the same type at the same address. */
3662 layout_nonempty_base_or_field (rli, decl, binfo, offsets);
3663 /* Add the new FIELD_DECL to the list of fields for T. */
3664 TREE_CHAIN (decl) = *next_field;
3665 *next_field = decl;
3666 next_field = &TREE_CHAIN (decl);
3667 }
在 3650 行的 CLASSTYPE_AS_BASE 给出了 basetype 作为基类的类型（后面在 layout_class_type 中，我们将看到这是个什么类型）。这些代表着基类的域，在派生类中如同其他普通域那样，需要布局，确定其位置。
3461 static void
3462 layout_nonempty_base_or_field (record_layout_info rli, in class.c
3463 tree decl,
3464 tree binfo,
3465 splay_tree offsets)
3466 {
3467 tree offset = NULL_TREE;
3468 bool field_p;
3469 tree type;
3470
3471 if (binfo)
3472 {
3473 /* For the purposes of determining layout conflicts, we want to
3474 use the class type of BINFO; TREE_TYPE (DECL) will be the
3475 CLASSTYPE_AS_BASE version, which does not contain entries for
3476 zero-sized bases. */
3477 type = TREE_TYPE (binfo);
3478 field_p = false;
3479 }
3480 else
3481 {
3482 type = TREE_TYPE (decl);
3483 field_p = true;
3484 }
3485
3486 /* Try to place the field. It may take more than one try if we have
3487 a hard time placing the field without putting two objects of the
3488 same type at the same address. */
3489 while (1)
3490 {
3491 struct record_layout_info_s old_rli = *rli;
3492
3493 /* Place this field. */
3494 place_field (rli, decl);
3495 offset = byte_position (decl);
3496
3497 /* We have to check to see whether or not there is already
3498 something of the same type at the offset we're about to use.
3499 For example, consider:
3500
3501 struct S {};
3502 struct T : public S { int i; };
3503 struct U : public S, public T {};
3504
3505 Here, we put S at offset zero in U. Then, we can't put T at
3506 offset zero -- its S component would be at the same address
3507 as the S we already allocated. So, we have to skip ahead.
3508 Since all data members, including those whose type is an
3509 empty class, have nonzero size, any overlap can happen only
3510 with a direct or indirect base-class -- it can't happen with
3511 a data member. */
3512 /* In a union, overlap is permitted; all members are placed at
3513 offset zero. */
3514 if (TREE_CODE (rli->t) == UNION_TYPE)
3515 break ;
3516 /* G++ 3.2 did not check for overlaps when placing a non-empty
3517 virtual base. */
3518 if (!abi_version_at_least (2) && binfo && TREE_VIA_VIRTUAL (binfo))
3519 break ;
3520 if (layout_conflict_p (field_p ? type : binfo, offset,
3521 offsets, field_p))
3522 {
3523 /* Strip off the size allocated to this field. That puts us
3524 at the first place we could have put the field with
3525 proper alignment. */
3526 *rli = old_rli;
3527
3528 /* Bump up by the alignment required for the type. */
3529 rli->bitpos
3530 = size_binop (PLUS_EXPR, rli->bitpos,
3531 bitsize_int (binfo
3532 ? CLASSTYPE_ALIGN (type)
3533 : TYPE_ALIGN (type)));
3534 normalize_rli (rli);
3535 }
3536 else
3537 /* There was no conflict. We're done laying out this field. */
3538 break ;
3539 }
3540
3541 /* Now that we know where it will be placed, update its
3542 BINFO_OFFSET. */
3543 if (binfo && CLASS_TYPE_P (BINFO_TYPE (binfo)))
3544 /* Indirect virtual bases may have a nonzero BINFO_OFFSET at
3545 this point because their BINFO_OFFSET is copied from another
3546 hierarchy. Therefore, we may not need to add the entire
3547 OFFSET. */
3548 propagate_binfo_offsets (binfo,
3549 size_diffop (convert (ssizetype, offset),
3550 convert (ssizetype,
3551 BINFO_OFFSET (binfo))));
3552 }
在 RECORD_TYPE中的 FIELD_DECL 一节中已经给出了域布置的细节，它给处理的域填充 DECL_FIELD_OFFSET （以字节为单位的偏移量）及 DECL_FIELD_BIT_OFFSET （以比特为单位的偏移量），并在 3530 行更新 rli 的 bitpos 域，以显示到类头部偏移的比特数（注意它不总是等于刚布置域的 DECL_FIELD_BIT_OFFSET ，因为可能有填充字节）。
1175 tree
1176 byte_position (tree field) in tree.c
1177 {
1178 return byte_from_pos (DECL_FIELD_OFFSET (field),
1179 DECL_FIELD_BIT_OFFSET (field));
1180 }
在 C++ 里，在布局过程中，空的基类可能不占空间。例如：
class A {}; sizeof (A) 给出 1 ，但在以下的语句中：
class B: public A { public : int temp; };
class C { public : int temp; }; sizeof (B) 及 sizeof (C) 都给出了 4 。
另外还有 class D: public A, C {}; sizeof (D) 亦给出了 4 。空类 A 不占空间，基类 C 可以与 A 共享同一个偏移位置。但是 class D {A a; C c}; sizeof (D) 则给出了 8 。空类 A 与类 C 独自占有自己的空间。出现这种差异的根本原因在于，基类的布局首先考虑非空的基类，然后到空的基类，再到虚拟基类；但域的布局必须按照声明的次序。为了检验新布置的域是否与已有的域发生冲突，调用函数 layout_conflict_p 。
3434 static int
3435 layout_conflict_p (tree type, in class.c
3436 tree offset,
3437 splay_tree offsets,
3438 int vbases_p)
3439 {
3440 splay_tree_node max_node;
3441
3442 /* Get the node in OFFSETS that indicates the maximum offset where
3443 an empty subobject is located. */
3444 max_node = splay_tree_max (offsets);
3445 /* If there aren't any empty subobjects, then there's no point in
3446 performing this check. */
3447 if (!max_node)
3448 return 0;
3449
3450 return walk_subobject_offsets (type, check_subobject_offset , offset,
3451 offsets, (tree) (max_node->key),
3452 vbases_p);
3453 }
我们略过伸展树（ splay tree ）的细节。大致的，在这棵伸展树中，其节点以偏移量来排序（保存在 key 域中），具有同一偏移量的类域（ field ）或基类被链接在同一个树节点的 value 域中。在 3444 行， splay_tree_max 返回当前已布置的最大偏移。这个偏移量划定了 walk_subobject_offsets 的查找范围。而函数 check_subobject_offset 给定一个偏移量，检查该位置是否已经放置了同样的一个类型。如果是，表明发生冲突，返回 1 。
3193 static int
3194 check_subobject_offset (tree type, tree offset, splay_tree offsets) in class.c
3195 {
3196 splay_tree_node n;
3197 tree t;
3198
3199 if (!is_empty_class (type))
3200 return 0;
3201
3202 /* Record the location of this empty object in OFFSETS. */
3203 n = splay_tree_lookup (offsets, (splay_tree_key) offset);
3204 if (!n)
3205 return 0;
3206
3207 for (t = (tree) n->value; t; t = TREE_CHAIN (t))
3208 if (same_type_p (TREE_VALUE (t), type))
3209 return 1;
3210
3211 return 0;
3212 }
在调用 walk_subobject_offsets 时的参数 type 可以是 binfo （基类），或者是 RECORD_TYPE （类类型的域（ field ）），或者内建类型。这 3 种情况并无本质的差别。注意这个时候，该 type 对象已经在前面由 place_fields 做了布局。
3225 static int
3226 walk_subobject_offsets (tree type, in class.c
3227 subobject_offset_fn f,
3228 tree offset,
3229 splay_tree offsets,
3230 tree max_offset,
3231 int vbases_p)
3232 {
3233 int r = 0;
3234 tree type_binfo = NULL_TREE;
3235
3236 /* If this OFFSET is bigger than the MAX_OFFSET, then we should
3237 stop. */
3238 if (max_offset && INT_CST_LT (max_offset, offset))
3239 return 0;
3240
3241 if (!TYPE_P (type))
3242 {
3243 if (abi_version_at_least (2))
3244 type_binfo = type;
3245 type = BINFO_TYPE (type);
3246 }
3247
3248 if (CLASS_TYPE_P (type))
3249 {
3250 tree field;
3251 tree binfo;
3252 int i;
3253
3254 /* Avoid recursing into objects that are not interesting. */
3255 if (!CLASSTYPE_CONTAINS_EMPTY_CLASS_P (type))
3256 return 0;
3257
3258 /* Record the location of TYPE. */
3259 r = (*f) (type, offset, offsets);
3260 if (r)
3261 return r;
3262
3263 /* Iterate through the direct base classes of TYPE. */
3264 if (!type_binfo)
3265 type_binfo = TYPE_BINFO (type);
3266 for (i = 0; i < BINFO_N_BASETYPES (type_binfo); ++i)
3267 {
3268 tree binfo_offset;
3269
3270 binfo = BINFO_BASETYPE (type_binfo, i);
3271
3272 if (abi_version_at_least (2)
3273 && TREE_VIA_VIRTUAL (binfo))
3274 continue ;
3275
3276 if (!vbases_p
3277 && TREE_VIA_VIRTUAL (binfo)
3278 && !BINFO_PRIMARY_P (binfo))
3279 continue ;
3280
3281 if (!abi_version_at_least (2))
3282 binfo_offset = size_binop (PLUS_EXPR,
3283 offset,
3284 BINFO_OFFSET (binfo));
3285 else
3286 {
3287 tree orig_binfo;
3288 /* We cannot rely on BINFO_OFFSET being set for the base
3289 class yet, but the offsets for direct non-virtual
3290 bases can be calculated by going back to the TYPE. */
3291 orig_binfo = BINFO_BASETYPE (TYPE_BINFO (type), i);
3292 binfo_offset = size_binop (PLUS_EXPR,
3293 offset,
3294 BINFO_OFFSET (orig_binfo));
3295 }
3296
3297 r = walk_subobject_offsets (binfo,
3298 f,
3299 binfo_offset,
3300 offsets,
3301 max_offset,
3302 (abi_version_at_least (2)
3303 ? /*vbases_p=*/ 0 : vbases_p));
3304 if (r)
3305 return r;
3306 }
3307
3308 if (abi_version_at_least (2))
3309 {
3310 tree vbase;
3311
3312 /* Iterate through the virtual base classes of TYPE. In G++
3313 3.2, we included virtual bases in the direct base class
3314 loop above, which results in incorrect results; the
3315 correct offsets for virtual bases are only known when
3316 working with the most derived type. */
3317 if (vbases_p)
3318 for (vbase = CLASSTYPE_VBASECLASSES (type);
3319 vbase;
3320 vbase = TREE_CHAIN (vbase))
3321 {
3322 binfo = TREE_VALUE (vbase);
3323 r = walk_subobject_offsets (binfo,
3324 f,
3325 size_binop (PLUS_EXPR,
3326 offset,
3327 BINFO_OFFSET (binfo)),
3328 offsets,
3329 max_offset,
3330 /*vbases_p=*/ 0);
3331 if (r)
3332 return r;
3333 }
3334 else
3335 {
3336 /* We still have to walk the primary base, if it is
3337 virtual. (If it is non-virtual, then it was walked
3338 above.) */
3339 vbase = get_primary_binfo (type_binfo);
3340 if (vbase && TREE_VIA_VIRTUAL (vbase)
3341 && BINFO_PRIMARY_BASE_OF (vbase) == type_binfo)
3342 {
3343 r = (walk_subobject_offsets
3344 (vbase, f, offset,
3345 offsets, max_offset, /*vbases_p=*/ 0));
3346 if (r)
3347 return r;
3348 }
3349 }
3350 }
3351
3352 /* Iterate through the fields of TYPE. */
3353 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3354 if (TREE_CODE (field) == FIELD_DECL && !DECL_ARTIFICIAL (field))
3355 {
3356 tree field_offset;
3357
3358 if (abi_version_at_least (2))
3359 field_offset = byte_position (field);
3360 else
3361 /* In G++ 3.2, DECL_FIELD_OFFSET was used. */
3362 field_offset = DECL_FIELD_OFFSET (field);
3363
3364 r = walk_subobject_offsets (TREE_TYPE (field),
3365 f,
3366 size_binop (PLUS_EXPR,
3367 offset,
3368 field_offset),
3369 offsets,
3370 max_offset,
3371 /*vbases_p=*/ 1);
3372 if (r)
3373 return r;
3374 }
3375 }
3376 else if (TREE_CODE (type) == ARRAY_TYPE)
3377 {
3378 tree element_type = strip_array_types (type);
3379 tree domain = TYPE_DOMAIN (type);
3380 tree index;
3381
3382 /* Avoid recursing into objects that are not interesting. */
3383 if (!CLASS_TYPE_P (element_type)
3384 || !CLASSTYPE_CONTAINS_EMPTY_CLASS_P (element_type))
3385 return 0;
3386
3387 /* Step through each of the elements in the array. */
3388 for (index = size_zero_node;
3389 /* G++ 3.2 had an off-by-one error here. */
3390 (abi_version_at_least (2)
3391 ? !INT_CST_LT (TYPE_MAX_VALUE (domain), index)
3392 : INT_CST_LT (index, TYPE_MAX_VALUE (domain)));
3393 index = size_binop (PLUS_EXPR, index, size_one_node))
3394 {
3395 r = walk_subobject_offsets (TREE_TYPE (type),
3396 f,
3397 offset,
3398 offsets,
3399 max_offset,
3400 /*vbases_p=*/ 1);
3401 if (r)
3402 return r;
3403 offset = size_binop (PLUS_EXPR, offset,
3404 TYPE_SIZE_UNIT (TREE_TYPE (type)));
3405 /* If this new OFFSET is bigger than the MAX_OFFSET, then
3406 there's no point in iterating through the remaining
3407 elements of the array. */
3408 if (max_offset && INT_CST_LT (max_offset, offset))
3409 break ;
3410 }
3411 }
3412
3413 return 0;
3414 }
上面的 abi_version_at_least (2) 返回非 0 值，如果 G++ 是不早于 3.4.0 的版本。 3312 行的注释解释了 G++3.4.0 之后及之前版本间的差别。类的非直接基类的偏移量通过其在该基类的偏移量加上基类的偏移量得到。并且这个处理适用于非虚拟基类及类域（ field ）。
非空类型不在考虑之列，因为它们必定要独占一个空间。如果指定位置已经放置了同一类型的对象， layout_conflict_p 返回 1 ，这将使得偏移量上浮到基类的下一个对齐地址边界（对于类类型，对齐量通常是 4 字节）。
而在 build_base_field 中，空类具有特殊的处理。下面的 rli_size_unit_so_far 计算出已经布置的对象或域的字节大小（忽略多余的比特）因此 eoc 是最靠近已布局大小的对齐边界。
build_base_field (continue)
3668 else
3669 {
3670 tree eoc;
3671 bool atend;
3672
3673 /* On some platforms (ARM), even empty classes will not be
3674 byte-aligned. */
3675 eoc = round_up (rli_size_unit_so_far (rli),
3676 CLASSTYPE_ALIGN_UNIT (basetype));
3677 atend = layout_empty_base (binfo, eoc, offsets);
3678 /* A nearly-empty class "has no proper base class that is empty,
3679 not morally virtual, and at an offset other than zero." */
3680 if (!TREE_VIA_VIRTUAL (binfo) && CLASSTYPE_NEARLY_EMPTY_P (t))
3681 {
3682 if (atend)
3683 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3684 /* The check above (used in G++ 3.2) is insufficient because
3685 an empty class placed at offset zero might itself have an
3686 empty base at a nonzero offset. */
3687 else if (walk_subobject_offsets (basetype,
3688 empty_base_at_nonzero_offset_p,
3689 size_zero_node,
3690 /*offsets=*/ NULL,
3691 /*max_offset=*/ NULL_TREE,
3692 /*vbases_p=*/ true))
3693 {
3694 if (abi_version_at_least (2))
3695 CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
3696 else if (warn_abi )
3697 warning ("class `%T' will be considered nearly empty in a "
3698 "future version of GCC", t);
3699 }
3700 }
3701
3702 /* We do not create a FIELD_DECL for empty base classes because
3703 it might overlap some other field. We want to be able to
3704 create CONSTRUCTORs for the class by iterating over the
3705 FIELD_DECLs, and the back end does not handle overlapping
3706 FIELD_DECLs. */
3707
3708 /* An empty virtual base causes a class to be non-empty
3709 -- but in that case we do not need to clear CLASSTYPE_EMPTY_P
3710 here because that was already done when the virtual table
3711 pointer was created. */
3712 }
3713
3714 /* Record the offsets of BINFO and its base subobjects. */
3715 record_subobject_offsets (binfo,
3716 BINFO_OFFSET (binfo),
3717 offsets,
3718 /*vbases_p=*/ 0);
3719
3720 return next_field;
3721 }
空的基类最好能放在偏移量为 0 （因为它们可以和主要基类共享空间）。在 G++v.3.4, 版本以后，空的基类总是被强制放在偏移量为 0 的地方。
3570 static bool
3571 layout_empty_base (tree binfo, tree eoc, splay_tree offsets) in class.c
3572 {
3573 tree alignment;
3574 tree basetype = BINFO_TYPE (binfo);
3575 bool atend = false;
3576
3577 /* This routine should only be used for empty classes. */
3578 my_friendly_assert (is_empty_class (basetype), 20000321);
3579 alignment = ssize_int (CLASSTYPE_ALIGN_UNIT (basetype));
3580
3581 if (!integer_zerop (BINFO_OFFSET (binfo)))
3582 {
3583 if (abi_version_at_least (2))
3585 (binfo, size_diffop (size_zero_node, BINFO_OFFSET (binfo)));
3586 else if (warn_abi )
3587 warning ("offset of empty base `%T' may not be ABI-compliant and may"
3588 "change in a future version of GCC",
3589 BINFO_TYPE (binfo));
3590 }
3591
3592 /* This is an empty base class. We first try to put it at offset
3593 zero. */
3594 if (layout_conflict_p (binfo,
3595 BINFO_OFFSET (binfo),
3596 offsets,
3597 /*vbases_p=*/ 0))
3598 {
3599 /* That didn't work. Now, we move forward from the next
3600 available spot in the class. */
3601 atend = true;
3602 propagate_binfo_offsets (binfo, convert (ssizetype, eoc));
3603 while (1)
3604 {
3605 if (!layout_conflict_p (binfo,
3606 BINFO_OFFSET (binfo),
3607 offsets,
3608 /*vbases_p=*/ 0))
3609 /* We finally found a spot where there's no overlap. */
3610 break ;
3611
3612 /* There's overlap here, too. Bump along to the next spot. */
3613 propagate_binfo_offsets (binfo, alignment);
3614 }
3615 }
3616 return atend;
3617 }
如果偏移量为 0 的地方已经被同样的类型占据了，这个空的基类就要被放在上面计算出来的偏移量为 eoc 的地方。如果 eoc 也被占据了，把偏移量加上对齐量再尝试，直到这个空的基类可以被放置。注意到如果该空的基类不能放在偏移量为 0 的地方，该函数返回非 0 值。这时，即便该类包含的只是空基类，也被视为非空。不过即便该空基类被放在偏移量为 0 的位置，这也不保证该类是空的。考虑以下例子：
class A {};
class B: public A {};
class C: public A, B {};
基类 B 可以放在 C 中偏移量为 0 的地方，但是它的基类 A 不能放在偏移量为 0 的地方，因为 C 的基类 A 已经在那里了。 C ，按上面的规则，是非空类。 empty_base_at_nonzero_offset_p 检查是否有空基类具有非 0 的偏移量。
3702 行的注释解释了为什么不能为空的基类构建 FIELD_DECL 节点。最后，在解决了冲突之后，需要以下函数把偏移量更新入伸展树。
3420 static void
3421 record_subobject_offsets (tree type, in class.c
3422 tree offset,
3423 splay_tree offsets,
3424 int vbases_p)
3425 {
3426 walk_subobject_offsets (type, record_subobject_offset , offset,
3427 offsets, /*max_offset=*/ NULL_TREE, vbases_p);
3428 }
注意我们仅记录空基类的偏移量。
3168 static int
3169 record_subobject_offset (tree type, tree offset, splay_tree offsets) in class.c
3170 {
3171 splay_tree_node n;
3172
3173 if (!is_empty_class (type))
3174 return 0;
3175
3176 /* Record the location of this empty object in OFFSETS. */
3177 n = splay_tree_lookup (offsets, (splay_tree_key) offset);
3178 if (!n)
3179 n = splay_tree_insert (offsets,
3180 (splay_tree_key) offset,
3181 (splay_tree_value) NULL_TREE);
3182 n->value = ((splay_tree_value)
3183 tree_cons (NULL_TREE,
3184 type,
3185 (tree) n->value));
3186
3187 return 0;
3188 }
在放置了所有的基类之后，接着是数据成员。记得对于非空基类，它们的 FIELD_DECL 被创建并位于 non_static_data_members 之前链入 TYPE_FIELDS 链，因此下面的 FOR 循环将不会再访问这些 FIELD_DECL 。
1402
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
