Studying note of GCC-3.4.6 source (133)

5.12.5.2.2.2.1.3.


Generate
RECORD_TYPE for the instantiation


At last, at
line 10181 in cp_parser_init_declarator

,
cp_finish_decl

closes the declaration. As it is the declaration within a function, a new
DECL_STMT is inserted into the stmt-tree at line 4957 below, and after that we
gets following intermediate tree.

(Click
here for open
)

4786

void

4787

cp_finish_decl

(tree decl, tree init,
tree asmspec_tree, int flags)

in decl.c

4788

{

4789

tree type;

4790

tree ttype = NULL_TREE;

4791

tree cleanup;

4792

const
char
*asmspec = NULL;

4793

int was_readonly = 0;

4794

bool var_definition_p = false;

4795

4796

if (decl == error_mark_node)

4797

return
;

4798

else if (! decl)

4799

{

4800

if (init)

4801

error ("assignment (not
initialization) in declaration");

4802

return
;

4803

}

4804

4805

my_friendly_assert (TREE_CODE (decl) !=
RESULT_DECL, 20030619);

…

4821

type = TREE_TYPE (decl);

…

4844

/* Parameters are
handled by store_parm_decls, not cp_finish_decl.
*/

4845

my_friendly_assert (TREE_CODE (decl) !=
PARM_DECL, 19990828);

…

4953

/* Add this
declaration to the statement-tree. This needs to happen

4954

after the call to
check_initializer so that the DECL_STMT for a

4955

reference temp is added before
the DECL_STMT for the reference itself.

*/

4956

if (at_function_scope_p ())

4957

add_decl_stmt (decl);

4958

4959

if (TREE_CODE (decl) == VAR_DECL)

4960

layout_var_decl
(decl);

Next it needs complete the definition of the type and the
declaration as layout_var_decl

in below.

4043

static
void

4044

layout_var_decl

(tree decl)

in decl.c

4045

{

4046

tree type = TREE_TYPE (decl);

4047

#if
0

4048

tree ttype = target_type (type);

4049

#endif

4050

4051

/* If we haven't
already layed out this declaration, do so now.

4052

Note that we must not call
complete type for an external object

4053

because it's type might
involve templates that we are not

4054

supposed to instantiate yet.
(And it's perfectly valid to say

4055

`extern X x' for some
incomplete type `X'.)
*/

4056

if (!DECL_EXTERNAL (decl))

4057

complete_type
(type);

4058

if (!DECL_SIZE (decl)

4059

&& TREE_TYPE (decl) != error_mark_node

4060

&& (COMPLETE_TYPE_P (type)

4061

|| (TREE_CODE (type) == ARRAY_TYPE

4062

&& !TYPE_DOMAIN (type)

4063

&& COMPLETE_TYPE_P
(TREE_TYPE (type)))))

4064

layout_decl
(decl, 0);

4065

4066

if (!DECL_EXTERNAL (decl) &&
DECL_SIZE (decl) == NULL_TREE)

4067

{

4068

/* An automatic
variable with an incomplete type: that is an error.

4069

Don't talk about array types
here, since we took care of that

4070

message in
grokdeclarator.
*/

4071

error ("storage size of `%D' isn't
known", decl);

4072

TREE_TYPE (decl) = error_mark_node;

4073

}

4074

#if
0

…

4084

#endif

4085

4086

if ((DECL_EXTERNAL (decl) || TREE_STATIC
(decl))

4087

&& DECL_SIZE (decl) != NULL_TREE

4088

&& ! TREE_CONSTANT (DECL_SIZE
(decl)))

4089

{

4090

if (TREE_CODE (DECL_SIZE (decl)) ==
INTEGER_CST)

4091

constant_expression_warning (DECL_SIZE
(decl));

4092

else

4093

error ("storage size of `%D' isn't
constant", decl);

4094

}

4095

4096

if (TREE_STATIC (decl)

4097

&& !DECL_ARTIFICIAL (decl)

4098

&& current_function_decl

4099

&& DECL_CONTEXT (decl) == current_function_decl

)

4100

push_local_name
(decl);

4101

}

At here, type

is the RECORD_TYPE just created above, and decl

is
a non-external declaration. So type

is already defined within this
translation-unit, and can be completed now.

116

tree

117

complete_type

(tree type)

in typeck.c

118

{

119

if (type == NULL_TREE)

120

/* Rather than
crash, we return something sure to cause an error

121

at some
point.
*/

122

return
error_mark_node;

123

124

if (type == error_mark_node ||
COMPLETE_TYPE_P (type))

125

;

126

else if (TREE_CODE (type) == ARRAY_TYPE
&& TYPE_DOMAIN (type))

127

{

128

tree t = complete_type (TREE_TYPE (type));

129

if (COMPLETE_TYPE_P (t) &&
!dependent_type_p (type))

130

layout_type (type);

131

TYPE_NEEDS_CONSTRUCTING (type)

132

= TYPE_NEEDS_CONSTRUCTING
(TYPE_MAIN_VARIANT (t));

133

TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)

134

= TYPE_HAS_NONTRIVIAL_DESTRUCTOR
(TYPE_MAIN_VARIANT (t));

135

}

136

else if (CLASS_TYPE_P (type)
&& CLASSTYPE_TEMPLATE_INSTANTIATION (type))

137

instantiate_class_template
(TYPE_MAIN_VARIANT (type));

138

139

return
type;

140

}

For template definition, a new type is generated at point of
instantiation. And the new type’s definition is completed at that point too (it
is a incomplete type because its TREE_SIZE field is NULL).

5274

tree

5275

instantiate_class_template

(tree type)

in pt.c

5276

{

5277

tree template, args, pattern, t, member;

5278

tree typedecl;

5279

tree pbinfo;

5280

5281

if (type == error_mark_node)

5282

return
error_mark_node;

5283

5284

if (TYPE_BEING_DEFINED (type)

5285

|| COMPLETE_TYPE_P (type)

5286

|| dependent_type_p (type))

5287

return
type;

5288

5289

/* Figure out which
template is being instantiated.
*/

5290

template = most_general_template
(CLASSTYPE_TI_TEMPLATE (type));

5291

my_friendly_assert (TREE_CODE (template) ==
TEMPLATE_DECL, 279);

5292

5293

/* Figure out which
arguments are being used to do the

5294

instantiation.
*/

5295

args = CLASSTYPE_TI_ARGS (type);

5296

5297

/* Determine what
specialization of the original template to

5298

instantiate.
*/

5299

t = most_specialized_class (template, args);

5300

if (t == error_mark_node)

5301

{

…

5315

}

5316

5317

if (t)

5318

pattern = TREE_TYPE (t);

5319

else

5320

pattern = TREE_TYPE (template);

5321

5322

/* If the template
we're instantiating is incomplete, then clearly

5323

there's nothing we can
do.
*/

5324

if (!COMPLETE_TYPE_P (pattern))

5325

return
type;

5326

5327

/* If we've
recursively instantiated too many templates, stop.
*/

5328

if (! push_tinst_level
(type))

5329

return
type;

5330

5331

/* Now we're really
doing the instantiation. Mark the type as in

5332

the process of being
defined.
*/

5333

TYPE_BEING_DEFINED (type) = 1;

Note that at line 5320 above, pattern

refers to the RECORD_TYPE of the most
general template (i.e., “SmallObject” in the template definition), its
TYPE_SIZE field is initialized as bitsize_zero_node and size_zero_node in finish_struct

for class template definition. At line 5299, most_specialized_class

returns the matching most specialized defintion, and in case of no matching or
no defining specialization returns NULL.

Though in therory the level of instantiation depth is unlimited, but
in implementation it must prevent infinite template instantiation due to
mistaken in program or implementation. This instantiation level must be
restricted. In GCC, version 3.4.6, global
variable max_tinst_depth

holds this limitation. Its value now is 500.

4850

int

4851

push_tinst_level

(tree d)

in pt.c

4852

{

4853

tree new;

4854

4855

if (tinst_depth

>= max_tinst_depth

)

4856

{

4857

/* If the
instantiation in question still has unbound template parms,

4858

we don't really care if we
can't instantiate it, so just return.

4859

This happens with base
instantiation for implicit `typename'.

*/

4860

if (uses_template_parms
(d))

4861

return
0;

4862

4863

last_template_error_tick

= tinst_level_tick

;

4864

error ("template instantiation depth
exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating
`%D'",

4865

max_tinst_depth

, d);

4866

4867

print_instantiation_context ();

4868

4869

return
0;

4870

}

4871

4872

new = build_expr_wfl (d, input_filename,
input_line, 0);

4873

TREE_CHAIN (new) = current_tinst_level

;

4874

current_tinst_level

= new;

4875

4876

++tinst_depth

;

4877

#ifdef
GATHER_STATISTICS

4878

if (tinst_depth

> depth_reached

)

4879

depth_reached

= tinst_depth

;

4880

#endif

4881

4882

++tinst_level_tick

;

4883

return
1;

4884

}

Above at line 4872, tree node of EXPR_WITH_FILE_LOCATION is
generated to record the file and the line number at point of instantiation. And
this node is chained into the global list current_tinst_level

for diagnosis purpose.

instantiate_class_template (continue)

5335

/* We may be in the
middle of deferred access check. Disable

5336

it now.
*/

5337

push_deferring_access_checks
(dk_no_deferred);

5338

5339

push_to_top_level
();

5340

5341

if (t)

5342

{

…

5367

}

5368

5369

SET_CLASSTYPE_INTERFACE_UNKNOWN (type);

5370

5371

/* Set the input
location to the template definition. This is needed

5372

if tsubsting causes an
error.
*/

5373

input_location = DECL_SOURCE_LOCATION
(TYPE_NAME (pattern));

5374

5375

TYPE_HAS_CONSTRUCTOR (type) =
TYPE_HAS_CONSTRUCTOR (pattern);

5376

TYPE_HAS_DESTRUCTOR (type) =
TYPE_HAS_DESTRUCTOR (pattern);

5377

TYPE_HAS_NEW_OPERATOR (type) =
TYPE_HAS_NEW_OPERATOR (pattern);

5378

TYPE_HAS_ARRAY_NEW_OPERATOR
(type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern);

5379

TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE
(pattern);

5380

TYPE_HAS_ASSIGN_REF (type) =
TYPE_HAS_ASSIGN_REF (pattern);

5381

TYPE_HAS_CONST_ASSIGN_REF
(type) = TYPE_HAS_CONST_ASSIGN_REF (pattern);

5382

TYPE_HAS_ABSTRACT_ASSIGN_REF
(type) = TYPE_HAS_ABSTRACT_ASSIGN_REF (pattern);

5383

TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF
(pattern);

5384

TYPE_HAS_CONST_INIT_REF (type) =
TYPE_HAS_CONST_INIT_REF (pattern);

5385

TYPE_HAS_DEFAULT_CONSTRUCTOR
(type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);

5386

TYPE_HAS_CONVERSION (type) =
TYPE_HAS_CONVERSION (pattern);

5387

TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type)

5388

= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P
(pattern);

5389

TYPE_USES_MULTIPLE_INHERITANCE (type)

5390

= TYPE_USES_MULTIPLE_INHERITANCE (pattern);

5391

TYPE_USES_VIRTUAL_BASECLASSES (type)

5392

= TYPE_USES_VIRTUAL_BASECLASSES (pattern);

5393

TYPE_PACKED (type) = TYPE_PACKED (pattern);

5394

TYPE_ALIGN (type) = TYPE_ALIGN (pattern);

5395

TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN
(pattern);

5396

TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA
(pattern); /* For libjava's JArray<T> */

5397

if (ANON_AGGR_TYPE_P (pattern))

5398

SET_ANON_AGGR_TYPE_P (type);

Note that above pattern

refers to the RECORD_TYPE generated from
the template defintion, while type

points to the RECORD_TYPE created at
instantiation. Then during instantiation, we need enter the scope the class and
its bases (if there is any), which will change the current scope. So at first
step, we need return back to the top level of binding scope – global namespace
(push_to_top_level

at line 5339) and cache the current scope. In below, push_scope

and pushclass

will build appropriate context for us (see that context of type

and pattern

are both NAMESPACE_DECL of “Loki”
– every instantiation is regarded as a variant within the same context).

instantiate_class_template (continue)

5400

pbinfo = TYPE_BINFO (pattern);

5401

5402

#ifdef
ENABLE_CHECKING

5403

if (DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL
(pattern))

5404

&& ! COMPLETE_TYPE_P
(TYPE_CONTEXT (type))

5405

&& ! TYPE_BEING_DEFINED
(TYPE_CONTEXT (type)))

5406

/* We should
never instantiate a nested class before its enclosing

5407

class; we need to look up
the nested class by name before we can

5408

instantiate it, and that
lookup should instantiate the enclosing

5409

class.
*/

5410

abort ();

5411

#endif

5412

5413

if (BINFO_BASETYPES (pbinfo))

5414

{

5415

tree base_list = NULL_TREE;

5416

tree pbases = BINFO_BASETYPES (pbinfo);

5417

tree paccesses = BINFO_BASEACCESSES
(pbinfo);

5418

tree context = TYPE_CONTEXT (type);

5419

bool pop_p;

5420

int i;

5421

5422

/* We must enter
the scope containing the type, as that is where

5423

the accessibility of types
named in dependent bases are

5424

looked up from.
*/

5425

pop_p = push_scope (context ? context : global_namespace

);

5426

5427

/* Substitute
into each of the bases to determine the actual

5428

basetypes.
*/

5429

for
(i = 0;
i < TREE_VEC_LENGTH (pbases); ++i)

5430

{

5431

tree base;

5432

tree access;

5433

tree pbase;

5434

5435

pbase = TREE_VEC_ELT (pbases, i);

5436

access = TREE_VEC_ELT (paccesses, i);

5437

5438

/* Substitute
to figure out the base class.
*/

5439

base = tsubst (BINFO_TYPE (pbase), args,
tf_error, NULL_TREE);

5440

if (base == error_mark_node)

5441

continue
;

5442

5443

base_list = tree_cons (access, base,
base_list);

5444

TREE_VIA_VIRTUAL (base_list) =
TREE_VIA_VIRTUAL (pbase);

5445

}

5446

5447

/* The list is
now in reverse order; correct that.
*/

5448

base_list = nreverse (base_list);

5449

5450

/* Now call
xref_basetypes to set up all the base-class

5451

information.
*/

5452

xref_basetypes

(type, base_list);

5453

5454

if (pop_p)

5455

pop_scope (context ? context : global_namespace

);

5456

}