GCC-3.4.6源代码学习笔记（142-续1）

好了，现在让我们看一下
GCC
对我们例
1
的输出。

例
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

VTT
的构造由下面的函数完成。

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

}

在我们的例子中
，
对于类
B1
，
B2
及
C
，
VTT
是期望的
，
其主体由下面的
build_vtt_init

构建。其中参数
binfo

是最后派生类的
binfo
，
t

是最后派生类
，
而
index

是在
VTT
中最后占用的索引。

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

}

在前一节中，类的
BINFO_VTABLE
在
dfs_accumulate_vtbl_inits

中设置了
vtable
初始值。它是一个
PLUS_EXPR
，指定了作为
vtable
开头的初始值的位置。在上面的
6916
行，
binfo_ctor_vtable

从类得到这个表达式。

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

}

在上面的
6917
行，由
binfo_ctor_vtable

返回的
init

被构建入一个
tree_list
；而在
6918
行，
inits

又指向了这个
tree_list
的
chain

域的地址，那么在
6931
行递归进入这个函数时，将继续往这个链表上添加节点。上面的参数
index

是
VTT
中下一个成员的索引（它也是字节数），一开始它为
size_zero_node

。

在
6922
行的
BINFO_VPTR_INDEX
保存了
VTT
的索引，在那里可以找到该子对象的虚指针。对于最后派生类
C
，其虚指针在
VTT
索引为
0
的地方。首先，对非虚拟基类，
build_ctor_vtbl_group

执行以下的处理。

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

}

在上面的
7109
行
，
mangle_ctor_vtbl_for_type

返回用于链接目的的
vtable
修饰名。接着的断言确保只有基类才会进入这个函数。然后一个新构建的
vtable
对象被封装入一个
tree_list
节点，并在
7119
行作为最后的参数传给下面的函数。注意
rtti_binfo

是合资格直接基类的
binfo
，该函数将为这个基类准备初始值。

这里，
accumulate_vtbl_inits

按前序的次序处理感兴趣的基类及它的非虚拟基类，然后在
build_ctor_vblt_group

中，以在派生树中出现的次序，调用该函数处理基类的虚拟基类。出于方便，我们在下面重新显示相关的函数。

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

}

这一次
，
上面
7167
行的
ctor_vtbl_p

是
true
，
因为参数
t

总是指向最后派生类
，
而
rtti_binfo

总是其基类。
7179
行的条件滤除不从虚拟基类派生的非虚拟基类。

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

}

参数
orig_binfo

应该总是指向感兴趣基类类型的
binfo
。而在
7273
行的断言
BINFO_NEW_VTABLE_MARKED
返回
true
，如果类型有属于自己的
vtable
。现在
rtti_binfo

是感兴趣直接基类的
binfo
。在我们的例子里，当处理
C
时，
B1
，
B2
就是这样的基类。而
t

指向最后派生类的
binfo
，在我们的例子中，它是类
C
。另外
binfo

是正在处理的基类的
binfo
。

这里当
accumulate_vtbl_inits

处理
B1
时，在
dfs_accumulate_vtbl_inits

的
7224
行条件，
TREE_VIA_VIRTUAL
及
BINFO_PRIMARY_P
对于
orig_binfo

都是不成立的（这里是
B1
的
binfo
）；而在
7273
行的条件，
orig_binfo

显然具有自己的
vtable
，该条件亦不成立。因此将进入
7276
行的
IF
块，这里面的处理在前一节已经看过，大同小异。因为
ctor_vtbl_p

是
true
，因而
7305
行得到执行，注意
binfo

是
B1-in-C
的
binfo
，它的
BINFO_VTABLE
是
NULL
。因为这里得到的
vtable
是构造（
construction
）
vtable
，它只能暂时借用
BINFO_VTABLE
，所以把它构建入一个
tree_list
。为之配合的函数有：
binfo_ctor_vtable

，
dfs_fixup_binfo_vtbls

。

在
7119
行，当从
accumulate_vtbl_inits

退出时，例
1
的
B1-in-C
应该在其构造（
construction
）
vtable
里，具有如下的项（保存在
build_ctor_vtbl_group

中
7118
行的
list

的
TREE_PURPOSE
域，及
BINFO_VTABLE (B1-in-C
的
binfo)
）。

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

接着在
7134
行对
accumulate_vtbl_inits

的调用中，
binfo

是
C::B1
的
binfo
，而
7124
行获得了类型
B1
的
binfo
，因此
vbase

是
B1::A
的
binfo
，而
b

是
C::B1::A
的
binfo
，而
t

仍然是类型
C
。它们被传递给
dfs_accumulate_vtbl_inits

，按如下的映射关系：
binfo

（
b

），
orig_binfo

（
vbase

），
rtti_binfo

（
binfo

）及
t

（
t

）。

那么
7223
行条件满足。在
7241
行，
b

是
C::B1
的
binfo
；而
last

在
7248
行得到
C::B1
的
binfo
。结果
vtbl

在
7269
行被设置为
C::B1
的
binfo
。最后，在
7305
行，
BINFO_VTABLE (C::B1::A
的
binfo)
被加入一个包含
C::B1
的
binfo
的
tree_list
节点。并且为
NULL
的
inits

被返回。

不过对于
B2-in-C
，事情稍有不同。同样在
7119
行退出
accumulate_vtbl_inits

时，例
1
中的
B2-in-C
应该在其构造（
construction
）
vtable
里，具有如下的项（保存在
build_ctor_vtbl_group

中
7118
行的
list

的
TREE_PURPOSE
域）。

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

但在为
B2::A
调用的
dfs_accumulate_vtbl_inits

中，
binfo

：
C::B2
的
binfo
（参数：
rtti_binfo

），
vbase

：
B2::A
的
binfo
（参数：
orig_binfo

），
b

：
C::B2::A
的
binfo
（参数：
binfo

），
t

：
C
（参数：
t

）。

那么在
7241
行，
b

这次是
C::B2
的
binfo
；而在
7248
行的
last

得到
NULL
，因为它沿着路径
A
à

B1
à

C
攀升。因此在
7276
行的条件中，
vtbl

保持为
NULL
。因而为
B2::A
产生的构造（
construction
）
vtable
具有如下的项：

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

在
build_ctor_vtbl_group

的
7140
行为这些构造（
construction
）
vtable
重新构建了数组类型。接着在
7144
行，这个用于基类构造的
vtable
串接入最后派生类的
CLASSTYPE_VTABLES
。而在
7145
行的
initialize_array

为
vtable
项确切的类型准备初始值。

从
build_ctor_vtbl_group

回到
build_vtt_inits

时，
6916
行的
binfo_ctor_vtable

从
C::B1
得到
C::B1
的构造（
construction
）
vtable
（
index
为
1
）。

6927
行的
FOR

循环对于
B1
或
B2
不做任何事，那么我们来到下面的代码。

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

}

上面的
secondary_vptrs

正如其名字所表示的，是在最后派生类的
VTT
中指向次要
vtable
的指针；而
index

指出这个指针所在的
VTT
的项。在
6943
行的遍历从
binfo

所指定的基类
binfo
开始（这里，即是
C::B1
的
binfo
或
C::B2
的
binfo
），并步入这个节点。下面的函数则以前序的次序处理访问的节点，看到参数
data

是
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

}

当遍历以
C::B1
的
binfo
为根的子树时，上面的
top_level_p

是
false
，
7006
行的
t

是类型
B1
。这个节点被跳过，因为满足
7016
行的条件；在访问
C::B1::A
的
binfo
时，在
7048
行，因为
C::B1::A
的
binfo
的
BINFO_VTABLE
中保存的是
C::B1
的
binfo
，
binfo_ctor_vtable

辗转地再一次获得了
C::B1
的构造（
construction
）
vtable
（保存在
index
为
2
的位置）。注意到这个函数总是返回
NULL
，它将强制进行整棵子树的遍历。

记得在
dfs_accumulate_vtbl_inits

的
7305
行，构造（
construction
）
vtable
暂时栖身在
BINFO_VTABLE
中。现在构造（
construction
）
vtable
已经记录在
VTT
中，不再需要在
BINFO_VTABLE
里混了。现在要通过尝试把
BINFO_VTABLE
恢复过来。注意其参数
data
的构成，在我们这里，上面由
C::B1::A
暂存的节点被移走了（对
C::B2
则是
C::B2::A
）。

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

}

回过去看上面提到的
C::B2
的处理，在其
build_ctor_vtbl_group

返回到
build_vtt_inits

时，其构造（
construction
）
vtable
被保存在
VTT
中
index
为
3
的地方。而在其后对
C::B2
的
dfs_build_secondary_vptr_vtt_inits

的调用中，在
7048
行，
binfo_ctor_vtable

得到了
B2::A
的构造（
construction
）
vtable
（
index
为
4
）。

当完成了
B1
及
B2
的处理后，在
build_vtt_inits

的
6938
行，继续处理
C
。在
6943
行，开始遍历以
C
为根节点的派生树。那么在
dfs_build_secondary_vptr_vtt_inits

中，
top_level_p

是
true
，
t

是最后派生类
C
。在这个前序遍历中，
C
满足
7016
行条件，
C::B1
满足
7020
行条件，退出该函数。对于
C::B2
，
VTT
的索引
5
被置为
C::B2
的
vptr
，而其
vtable
（这是个次要
vtable
）的初始值则是上一节中得到的
BINFO_VTABLE(C::B2)
；同样对于
C::B1::A
，它的
vptr
在
VTT
索引为
6
的地方，其
vtable
（也是次要
vtable
）的初始值也是前一节中保存在
BINFO_VTABLE(A-in-C)
的内容。
C::B2::A
跳过，因为
A
已经在
C::B1::A
中访问了。

在
build_vtt_inits

的
6972
行，最后处理
A
，不过因为
A
不包含虚拟基类，
build_vtt_inits

对它不做处理。

回到
build_vtt

，如果处理成功，
inits

不为
NULL
。接下来就是为
VTT
构建正确的类型，及
VTT
类型的静态成员对象，并且把这个
VTT
对象置入最后派生类
CLASSTYPE_VTABLES
的链头。