Studying note of GCC-3.4.6 source (135)

5.12.5.2.2.2.1.3.2.


Instantiate
base class – finish


After processing the bases (they are chained tegother), in instantiate_class_template

at line 5452, xref_basetype

is called to fill the binfo part, in which parameter ref

is the RECORD_TYPE of the
derived, and base_list

contains the RECORD_TYPE of the bases and their accessbility.

The RECORD_TYPE of base is incomplete as the type

field is empty, so it needs be
completed first by complete_type_or_else

at line 9645 in xref_basetype

.

4210

#define
complete_type_or_else
(T,V)
(complete_type_or_diagnostic ((T), (V), 0))

147

tree

148

complete_type_or_diagnostic

(tree type,
tree value, int diag_type)

in typeck.c

149

{

150

type = complete_type (type);

151

if (type == error_mark_node)

152

/* We already
issued an error.
*/

153

return
NULL_TREE;

154

else if (!COMPLETE_TYPE_P (type))

155

{

156

cxx_incomplete_type_diagnostic (value,
type, diag_type);

157

return
NULL_TREE;

158

}

159

else

160

return
type;

161

}

See complete_type

is recursed at the beginning the function
(we come here inside the complete_type

called
for the derived), in which also calls instantiate_class_template

to instantiate the
base. If the base also derives from certain template class, this procedure
would be repeated till arrives at the bottom template class (we just see the
first part of the instantiating, in the rear part the template will invoke finish_struct

to complete its RECORD_TYPE), or the bottom non-template class (such type has
invoked finsih_struct

,
its RECORD_TYPE is complete). Here we just skip the detail of the handling of
the base class in complete_type

and assume this node of
RECORD_TYPE is completed after that.

The detail of xref_basetype

can be seen in previous section, for our case, real deep copy is executed as
base class is a node of RECORD_TYPE. And it gets following layout.

(Click
here for open
)

5.12.5.2.2.2.1.3.3.


Finish the derived
RECORD_TYPE –members subsititution


Now the instantiation of base class is ready, and the binfo of the
derived is setup, following it needs fill in the member of the class as type

here is an empty RECORD_TYPE for the instantiation. Further the member of the
derived class as some of them may depend on the template parameters, so they
need be subsitituted by the arguments too. It’s worth our attention to see how
to generate these types. The function though is lengthy but quite straight
forward.

instantiate_class_template (continue)

5458

/* Now that our
base classes are set up, enter the scope of the

5459

class, so that name lookups
into base classes, etc. will work

5460

correctly. This is precisely
analogous to what we do in

5461

begin_class_definition when
defining an ordinary non-template

5462

class.
*/

5463

pushclass
(type);

5464

5465

/* Now members are
processed in the order of declaration.

*/

5466

for
(member =
CLASSTYPE_DECL_LIST (pattern);

5467

member; member = TREE_CHAIN (member))

5468

{

5469

tree t = TREE_VALUE (member);

5470

5471

if (TREE_PURPOSE (member))

5472

{

5473

if (TYPE_P (t))

5474

{

5475

/* Build new
CLASSTYPE_NESTED_UTDS.
*/

5476

5477

tree tag = t;

5478

tree name = TYPE_IDENTIFIER (tag);

5479

tree newtag;

5480

bool class_template_p;

5481

5482

class_template_p = (TREE_CODE (tag) !=
ENUMERAL_TYPE

5483

&&
TYPE_LANG_SPECIFIC (tag)

5484

&&
CLASSTYPE_IS_TEMPLATE (tag));

5485

/* If the member
is a class template, then -- even after

5486

substituition -- there
may be dependent types in the

5487

template argument list
for the class. We increment

5488

PROCESSING_TEMPLATE_DECL
so that dependent_type_p, as

5489

that function will assume that no types
are dependent

5490

when outside of a
template.
*/

5491

if (class_template_p)

5492

++processing_template_decl;

5493

newtag = tsubst (tag, args, tf_error,
NULL_TREE);

5494

if (class_template_p)

5495

--processing_template_decl;

5496

if (newtag == error_mark_node)

5497

continue
;

5498

5499

if (TREE_CODE (newtag) !=
ENUMERAL_TYPE)

5500

{

5501

if (class_template_p)

5502

/*
Unfortunately, lookup_template_class sets

5503

CLASSTYPE_IMPLICIT_INSTANTIATION for a partial

5504

instantiation
(i.e., for the type of a member

5505

template class
nested within a template class.)

5506

This behavior is
required for

5507

maybe_process_partial_specialization to work

5508

correctly, but is
not accurate in this case;

5509

the TAG is not an
instantiation of anything.

5510

(The corresponding
TEMPLATE_DECL is an

5511

instantiation, but
the TYPE is not.) */

5512

CLASSTYPE_USE_TEMPLATE (newtag) =
0;

5513

5514

/* Now, we
call pushtag to put this NEWTAG into the scope of

5515

TYPE. We first set up the
IDENTIFIER_TYPE_VALUE to avoid

5516

pushtag calling
push_template_decl. We don't have to do

5517

this for enums because
it will already have been done in

5518

tsubst_enum.
*/

5519

if (name)

5520

SET_IDENTIFIER_TYPE_VALUE (name,
newtag);

5521

pushtag
(name,
newtag, /*globalize=*/
0);

5522

}

5523

}
// end if (TYPE_P (t))

5524

else if (TREE_CODE (t) == FUNCTION_DECL

5525

|| DECL_FUNCTION_TEMPLATE_P (t))

5526

{

5527

/* Build new
TYPE_METHODS.
*/

5528

tree r;

5529

5530

if (TREE_CODE (t) == TEMPLATE_DECL)

5531

++processing_template_decl;

5532

r = tsubst (t, args, tf_error,
NULL_TREE);

5533

if (TREE_CODE (t) == TEMPLATE_DECL)

5534

--processing_template_decl;

5535

set_current_access_from_decl (r);

5536

grok_special_member_properties (r);

5537

finish_member_declaration
(r);

5538

}

5539

else

5540

{

5541

/* Build new TYPE_FIELDS.
*/

5542

5543

if (TREE_CODE (t) != CONST_DECL)

5544

{

5545

tree r;

5546

5547

/* The the file and
line for this declaration, to

5548

assist in error
message reporting. Since we

5549

called
push_tinst_level above, we don't need to

5550

restore these.
*/

5551

input_location

= DECL_SOURCE_LOCATION (t);

5552

5553

if (TREE_CODE (t) == TEMPLATE_DECL)

5554

++processing_template_decl;

5555

r = tsubst (t, args, tf_error |
tf_warning, NULL_TREE);

5556

if (TREE_CODE (t) == TEMPLATE_DECL)

5557

--processing_template_decl;

5558

if (TREE_CODE (r) == VAR_DECL)

5559

{

5560

tree init;

5561

5562

if (DECL_INITIALIZED_IN_CLASS_P
(r))

5563

init = tsubst_expr (DECL_INITIAL
(t), args,

5564

tf_error | tf_warning,
NULL_TREE);

5565

else

5566

init = NULL_TREE;

5567

5568

finish_static_data_member_decl

5569

(r, init, /*asmspec_tree=*/
NULL_TREE, /*flags=*/
0);

5570

5571

if (DECL_INITIALIZED_IN_CLASS_P (r))

5572

check_static_variable_definition
(r, TREE_TYPE (r));

5573

}

5574

else if (TREE_CODE (r) == FIELD_DECL)

5575

{

5576

/*
Determine whether R has a valid type and can be

5577

completed later. If
R is invalid, then it is

5578

replaced by
error_mark_node so that it will not be

5579

added to
TYPE_FIELDS.
*/

5580

tree rtype = TREE_TYPE (r);

5581

if (can_complete_type_without_circularity
(rtype))

5582

complete_type
(rtype);

5583

5584

if (!COMPLETE_TYPE_P (rtype))

5585

{

5586

cxx_incomplete_type_error (r, rtype);

5587

r = error_mark_node;

5588

}

5589

}

5590

5591

/* If it is
a TYPE_DECL for a class-scoped ENUMERAL_TYPE,

5592

such a thing will
already have been added to the field

5593

list by tsubst_enum in
finish_member_declaration in the

5594

CLASSTYPE_NESTED_UTDS
case above.
*/

5595

if (!(TREE_CODE (r) == TYPE_DECL

5596

&& TREE_CODE (TREE_TYPE
(r)) == ENUMERAL_TYPE

5597

&& DECL_ARTIFICIAL (r)))

5598

{

5599

set_current_access_from_decl (r);

5600

finish_member_declaration
(r);

5601

}

5602

}

5603

}

5604

}
// if (TREE_PURPOSE (member))

5605

else

5606

{

5607

if (TYPE_P (t) || DECL_CLASS_TEMPLATE_P
(t))

5608

{

5609

/* Build new
CLASSTYPE_FRIEND_CLASSES.
*/

5610

5611

tree friend_type = t;

5612

tree new_friend_type;

5613

5614

if (TREE_CODE (friend_type) ==
TEMPLATE_DECL)

5615

new_friend_type = tsubst_friend_class
(friend_type, args);

5616

else if (uses_template_parms
(friend_type))

5617

new_friend_type = tsubst
(friend_type, args,

5618

tf_error |
tf_warning, NULL_TREE);

5619

else if (CLASSTYPE_USE_TEMPLATE
(friend_type))

5620

new_friend_type = friend_type;

5621

else

5622

{

5623

tree ns = decl_namespace_context
(TYPE_MAIN_DECL
(friend_type));

5624

5625

/* The call
to xref_tag_from_type does injection for friend

5626

classes.
*/

5627

push_nested_namespace
(ns);

5628

new_friend_type =

5629

xref_tag_from_type (friend_type,
NULL_TREE, 1);

5630

pop_nested_namespace (ns);

5631

}

5632

5633

if (TREE_CODE (friend_type) ==
TEMPLATE_DECL)

5634

/* Trick
make_friend_class into realizing that the friend

5635

we're adding is a
template, not an ordinary class. It's

5636

important that we use
make_friend_class since it will

5637

perform some
error-checking and output cross-reference

5638

information.
*/

5639

++processing_template_decl;

5640

5641

if (new_friend_type != error_mark_node)

5642

make_friend_class (type,
new_friend_type,

5643

/*complain=*/
false);

5644

5645

if (TREE_CODE (friend_type) ==
TEMPLATE_DECL)

5646

--processing_template_decl;

5647

}

5648

else

5649

{

5650

/* Build new
DECL_FRIENDLIST.
*/

5651

tree r;

5652

5653

if (TREE_CODE (t) == TEMPLATE_DECL)

5654

++processing_template_decl;

5655

r = tsubst_friend_function (t, args);

5656

if (TREE_CODE (t) == TEMPLATE_DECL)

5657

--processing_template_decl;

5658

add_friend (type, r, /*complain=*/
false);

5659

}

5660

}

5661

}

5662

5663

/* Set the file and
line number information to whatever is given for

5664

the class itself. This puts
error messages involving generated

5665

implicit functions at a
predictable point, and the same point

5666

that would be used for
non-template classes.
*/

5667

typedecl = TYPE_MAIN_DECL (type);

5668

input_location

= DECL_SOURCE_LOCATION (typedecl);

5669

5670

unreverse_member_declarations
(type);

5671

finish_struct_1
(type);

Notice that members declared within the class are recorded by node
of tree_list and chained in field of CLASSTYPE_DECL_LIST. In the tree_list
node, TREE_PURPOSE field records the class it belongs to (and NULL if it is the
friend declaration), and TREE_VALUE field holds the declaration itself.

Also see in previous sections, entities declared within the class
template are considered as template declarations too, with TEMPLATE_DECL
generated. During instantiation, the real template arguments should substitute
the template parameters.

5.12.5.2.2.2.1.3.4.


Finish the derived
RECORD_TYPE – fixup inline methods


As RECORD_TYPE for the class template instantiation is a normal
class, at line 5671 finish_struct_1

must be invoked to finish the
definition.

4997

void

4998

finish_struct_1

(tree t)

in class.c

4999

{

5001

tree x;

5002

/* A TREE_LIST. The
TREE_VALUE of each node is a FUNCTION_DECL.

*/

5003

tree virtuals = NULL_TREE;

5004

int n_fields = 0;

5005

tree vfield;

5006

5007

if (COMPLETE_TYPE_P (t))

5008

{

5009

if (IS_AGGR_TYPE (t))

5010

error ("redefinition of `%#T'",
t);

5011

else

5012

abort ();

5013

popclass ();

5014

return
;

5015

}

5016

5017

/* If this type was
previously laid out as a forward reference,

5018

make sure we lay it out
again.
*/

5019

TYPE_SIZE (t) = NULL_TREE;

5020

CLASSTYPE_PRIMARY_BINFO (t) = NULL_TREE;

5021

5022

fixup_inline_methods
(t);

5023

5024

/* Make assumptions
about the class; we'll reset the flags if

5025

necessary.
*/

5026

CLASSTYPE_EMPTY_P (t) = 1;

5027

CLASSTYPE_NEARLY_EMPTY_P (t) = 1;

5028

CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 0;

5029

5030

/* Do end-of-class
semantic processing: checking the validity of the

5031

bases and members and add
implicitly generated methods.
*/

5032

check_bases_and_members
(t);

Also, remember that for inline method, the associated FUNCTION_DECL
node has its template_info

field filled with the template information. The member subsititution above
subsititues the arguments for methods appropriately, but some relations are
still not updated accordingly.

4323

static
void

4324

fixup_inline_methods

(tree type)

in class.

4325

{

4326

tree method = TYPE_METHODS (type);

4327

4328

if (method && TREE_CODE (method) ==
TREE_VEC)

4329

{

4330

if (TREE_VEC_ELT (method, 1))

4331

method = TREE_VEC_ELT (method, 1);

4332

else if (TREE_VEC_ELT (method, 0))

4333

method = TREE_VEC_ELT (method, 0);

4334

else

4335

method = TREE_VEC_ELT (method, 2);

4336

}

4337

4338

/* Do inline member
functions.
*/

4339

for
(;
method; method = TREE_CHAIN (method))

4340

fixup_pending_inline
(method);

4341

4342

/* Do friends.
*/

4343

for
(method =
CLASSTYPE_INLINE_FRIENDS (type);

4344

method;

4345

method = TREE_CHAIN (method))

4346

fixup_pending_inline (TREE_VALUE (method));

4347

CLASSTYPE_INLINE_FRIENDS (type) = NULL_TREE;

4348

}

Remember the body of inline method is cached within
DECL_PENDING_INLINE_INFO. For arguments of the inline method, they have been
subsititued with those at instantiating, but the context

field remains untouched, it
needs updated for the inline method after subsititution (the new nodes
created).

4306

static
void

4307

fixup_pending_inline

(tree fn)

in class.

4308

{

4309

if (DECL_PENDING_INLINE_INFO (fn))

4310

{

4311

tree args = DECL_ARGUMENTS (fn);

4312

while
(args)

4313

{

4314

DECL_CONTEXT (args) = fn;

4315

args = TREE_CHAIN (args);

4316

}

4317

}

4318

}

5.12.5.2.2.2.1.3.5.


Finish the derived
RECORD_TYPE – verify base classes


At this point, the base class, and the members are subsitituted with
argument appropriately, but no semantic checking at the class level is
performed for the template instantiation. This semantic checking should be
taken as soon as possible. Here is the most early point the semantic checking
can be performed.

4145

static
void

4146

check_bases_and_members

(tree t)

in class.c

4147

{

4148

/* Nonzero if we
are not allowed to generate a default constructor

4149

for this case.
*/

4150

int cant_have_default_ctor;

4151

/* Nonzero if the
implicitly generated copy constructor should take

4152

a non-const reference argument.
*/

4153

int cant_have_const_ctor;

4154

/* Nonzero if the
the implicitly generated assignment operator

4155

should take a non-const
reference argument.
*/

4156

int no_const_asn_ref;

4157

tree access_decls;

4158

4159

/* By default, we
use const reference arguments and generate default

4160

constructors.
*/

4161

cant_have_default_ctor = 0;

4162

cant_have_const_ctor = 0;

4163

no_const_asn_ref = 0;

4164

4165

/* Check all the
base-classes.
*/

4166

check_bases
(t,
&cant_have_default_ctor, &cant_have_const_ctor,

4167

&no_const_asn_ref);

If the class template contains (derives) base classes (remember the
base classes may be class template too, see our example of “SmallObject”), it
is time to see there is any flaw between the class and the base classes.

1109

static
void

1110

check_bases

(tree t,

in class.c

1111

int* cant_have_default_ctor_p,

1112

int* cant_have_const_ctor_p,

1113

int* no_const_asn_ref_p)

1114

{

1115

int n_baseclasses;

1116

int i;

1117

int seen_non_virtual_nearly_empty_base_p;

1118

tree binfos;

1119

1120

binfos = TYPE_BINFO_BASETYPES (t);

1121

n_baseclasses = CLASSTYPE_N_BASECLASSES (t);

1122

seen_non_virtual_nearly_empty_base_p = 0;

1123

1124

/* An aggregate
cannot have baseclasses.

*/

1125

CLASSTYPE_NON_AGGREGATE (t) |= (n_baseclasses !=
0);

1126

1127

for
(i = 0; i < n_baseclasses; ++i)

1128

{

1129

tree base_binfo;

1130

tree basetype;

1131

1132

/* Figure out
what base we're looking at.

*/

1133

base_binfo = TREE_VEC_ELT (binfos, i);

1134

basetype = TREE_TYPE (base_binfo);

1135

1136

/* If the type of
basetype is incomplete, then we already

1137

complained about that fact
(and we should have fixed it up as

1138

well).
*/

1139

if (!COMPLETE_TYPE_P (basetype))

1140

{

1141

int j;

1142

/* The base type is of incomplete type. It is

1143

probably best to pretend
that it does not

1144

exist.
*/

1145

if (i == n_baseclasses-1)

1146

TREE_VEC_ELT (binfos, i) = NULL_TREE;

1147

TREE_VEC_LENGTH (binfos) -= 1;

1148

n_baseclasses -= 1;

1149

for
(j = i; j+1 < n_baseclasses; j++)

1150

TREE_VEC_ELT (binfos, j) = TREE_VEC_ELT (binfos, j+1);

1151

continue
;

1152

}

1153

1154

/* Effective C++
rule 14. We only need to check TYPE_POLYMORPHIC_P

1155

here because the case of
virtual functions but non-virtual

1156

dtor is handled in
finish_struct_1.
*/

1157

if (warn_ecpp

&& ! TYPE_POLYMORPHIC_P
(basetype)

1158

&& TYPE_HAS_DESTRUCTOR
(basetype))

1159

warning ("base class `%#T' has a
non-virtual destructor",

1160

basetype);

1161

1162

/* If the base
class doesn't have copy constructors or

1163

assignment operators that
take const references, then the

1164

derived class cannot have such
a member automatically

1165

generated.
*/

1166

if (! TYPE_HAS_CONST_INIT_REF (basetype))

1167

*cant_have_const_ctor_p = 1;

1168

if (TYPE_HAS_ASSIGN_REF (basetype)

1169

&& !TYPE_HAS_CONST_ASSIGN_REF
(basetype))

1170

*no_const_asn_ref_p = 1;

1171

/* Similarly, if
the base class doesn't have a default

1172

constructor, then the
derived class won't have an

1173

automatically generated
default constructor.
*/

1174

if (TYPE_HAS_CONSTRUCTOR (basetype)

1175

&& !
TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype))

1176

{

1177

*cant_have_default_ctor_p = 1;

1178

if (! TYPE_HAS_CONSTRUCTOR (t))

1179

pedwarn ("base
`%T' with only non-default constructor in class without a constructor",

1180

basetype);

1181

}

1182

1183

if (TREE_VIA_VIRTUAL (base_binfo))

1184

/* A virtual
base does not effect nearly emptiness.

*/

1185

;

1186

else if (CLASSTYPE_NEARLY_EMPTY_P
(basetype))

1187

{

1188

if (seen_non_virtual_nearly_empty_base_p)

1189

/* And if
there is more than one nearly empty base, then the

1190

derived class is not
nearly empty either.
*/

1191

CLASSTYPE_NEARLY_EMPTY_P (t) = 0;

1192

else

1193

/* Remember
we've seen one.
*/

1194

seen_non_virtual_nearly_empty_base_p =
1;

1195

}

1196

else if (!is_empty_class (basetype))

1197

/* If the base
class is not empty or nearly empty, then this

1198

class cannot be nearly
empty.
*/

1199

CLASSTYPE_NEARLY_EMPTY_P (t) = 0;

1200

1201

/* A lot of
properties from the bases also apply to the derived

1202

class.
*/

1203

TYPE_NEEDS_CONSTRUCTING
(t) |= TYPE_NEEDS_CONSTRUCTING (basetype);

1204

TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)

1205

|= TYPE_HAS_NONTRIVIAL_DESTRUCTOR
(basetype);

1206

TYPE_HAS_COMPLEX_ASSIGN_REF (t)

1207

|= TYPE_HAS_COMPLEX_ASSIGN_REF
(basetype);

1208

TYPE_HAS_COMPLEX_INIT_REF
(t) |= TYPE_HAS_COMPLEX_INIT_REF (basetype);

1209

TYPE_POLYMORPHIC_P (t) |=
TYPE_POLYMORPHIC_P (basetype);

1210

CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t)

1211

|= CLASSTYPE_CONTAINS_EMPTY_CLASS_P
(basetype);

1212

}

1213

}

Among the arguments in the invocation, cant_have_default_ctor

is nonzero if
base classes have no default constructor, cant_have_const_ctor

is nonzero if base classes
have no copy constructor that takes constant reference, and no_const_asn_ref

is nonzero if base classes have no assignment operator that takes constant
reference.