Studying note of GCC-3.4.6 source (141 - cont 1)

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.