Studying note of GCC-3.4.6 source (130)

5.12.5.2.2.2.

Handling
the body

Before going deeper into the function-body, which forms a new
binding scope of block-scope, any pendding accessibility checkings should be
performed to find out the illegal visit early.

cp_parser_function_definition_from_specifiers_and_declarator
(continue)

14329

/* If there were
names looked up in the decl-specifier-seq that we

14330

did not check, check them now. We must wait
until we are in the

14331

scope of the function to perform the
checks, since the function

14332

might be a friend.
*/

14333

perform_deferred_access_checks
();

14334

14335

if (!success_p)

14336

{

14337

/* If
begin_function_definition didn't like the definition, skip

14338

the entire function.
*/

14339

error ("invalid function
declaration");

14340

cp_parser_skip_to_end_of_block_or_statement
(parser);

14341

fn = error_mark_node;

14342

}

14343

else

14344

fn = cp_parser_function_definition_after_declarator
(parser,

14345

/*inline_p=*/
false);

14346

14347

return
fn;

14348

}

We have seen cp_parser_function_definition_after_declarator

in section 5.12.3.2.1.2.1.1.Parse
function body
. In it, cp_parser_ctor_initializer_opt_and_function_body

parses the function-body and possible initializer for constructor. And in this
function, begin_function_body

prepares the root of sub-tree for the compound-statement, and the enclosing
scope. After that, the relevant part of the intermediate tree now looks like
below one.

(Click
here for open
)

And cp_parser_function_body

handles the body which is a compound-statement.

11460

static
void

11461

cp_parser_function_body

(cp_parser
*parser)

in parser.c

11462

{

11463

cp_parser_compound_statement

(parser,
false);

11464

}

5651

static
tree

5652

cp_parser_compound_statement

(cp_parser
*parser, bool in_statement_expr_p)

5653

{

5654

tree compound_stmt;

5655

5656

/* Consume the
`{'.
*/

5657

if (!cp_parser_require
(parser, CPP_OPEN_BRACE, "`{'"))

5658

return
error_mark_node;

5659

/* Begin the
compound-statement.
*/

5660

compound_stmt = begin_compound_stmt
(/*has_no_scope=*/
false);

5661

/* Parse an
(optional) statement-seq.
*/

5662

cp_parser_statement_seq_opt
(parser, in_statement_expr_p);

5663

/* Finish the
compound-statement.
*/

5664

finish_compound_stmt (compound_stmt);

5665

/* Consume the
`}'.
*/

5666

cp_parser_require
(parser, CPP_CLOSE_BRACE, "`}'");

5667

5668

return
compound_stmt;

5669

}

Another
enclosing scope is created before handling the tokens following “{“, it is
because former block-scope is built for the optional constructor initializer,
and the one created here is really for the body.

(Click
here for open
)

5677

static
void

5678

cp_parser_statement_seq_opt

(cp_parser*
parser, bool in_statement_expr_p)

in parser.c

5679

{

5680

/* Scan statements
until there aren't any more.
*/

5681

while
(true)

5682

{

5683

/* If we're
looking at a `}', then we've run out of statements.
*/

5684

if (cp_lexer_next_token_is
(parser->lexer, CPP_CLOSE_BRACE)

5685

|| cp_lexer_next_token_is
(parser->lexer, CPP_EOF))

5686

break
;

5687

5688

/* Parse the statement.
*/

5689

cp_parser_statement
(parser, in_statement_expr_p);

5690

}

5691

}

Deep into the
callstack: cp_parser_statement

à

cp_parser_declaration_statement

à

cp_parser_block_declaration

à

cp_parser_simple_declaration

,
cp_parser_decl_specifier_seq

parses the type-specifier for the first declaration by cp_parser_type_specifier

à

cp_parser_simple_type_specifier

à

cp_parser_type_name

à

cp_parser_class_name

to find out the template-id of “SmallObject<>”.

5425

static
void

5426

cp_parser_statement

(cp_parser* parser,
bool in_statement_expr_p)

in parser.c

5427

{

5428

tree statement;

5429

cp_token *token;

5430

int statement_line_number;

5431

5432

/* There is no
statement yet.
*/

5433

statement = NULL_TREE;

5434

/* Peek at the next
token.
*/

5435

token = cp_lexer_peek_token
(parser->lexer);

5436

/* Remember the
line number of the first token in the statement.
*/

5437

statement_line_number =
token->location.line;

5438

/* If this is a
keyword, then that will often determine what kind of

5439

statement we have.
*/

5440

if (token->type == CPP_KEYWORD)

5441

{

…

5479

}

5480

else if (token->type == CPP_NAME)

5481

{

5482

/* If the next
token is a `:', then we are looking at a

5483

labeled-statement.
*/

5484

token = cp_lexer_peek_nth_token
(parser->lexer, 2);

5485

if (token->type == CPP_COLON)

5486

statement = cp_parser_labeled_statement
(parser, in_statement_expr_p);

5487

}

5488

/* Anything that
starts with a `{' must be a compound-statement.

*/

5489

else if (token->type == CPP_OPEN_BRACE)

5490

statement = cp_parser_compound_statement
(parser, false);

5491

5492

/* Everything else
must be a declaration-statement or an

5493

expression-statement. Try for
the declaration-statement

5494

first, unless we are looking
at a `;', in which case we know that

5495

we have an
expression-statement.
*/

5496

if (!statement)

5497

{

5498

if (cp_lexer_next_token_is_not
(parser->lexer, CPP_SEMICOLON))

5499

{

5500

cp_parser_parse_tentatively
(parser);

5501

/* Try to parse
the declaration-statement.
*/

5502

cp_parser_declaration_statement
(parser);

5503

/* If that
worked, we're done.
*/

5504

if (cp_parser_parse_definitely
(parser))

5505

return
;

5506

}

5507

/* Look for an
expression-statement instead.
*/

5508

statement = cp_parser_expression_statement
(parser, in_statement_expr_p);

5509

}

5510

5511

/* Set the line
number for the statement.
*/

5512

if (statement && STATEMENT_CODE_P
(TREE_CODE (statement)))

5513

STMT_LINENO (statement) =
statement_line_number;

5514

}

A declaration statement introduces one or more new identifiers into
a block; it has the form

declaration-statement: block-declaration

If an identifier introduced by a declaration was previously declared
in an outer block, the outer declaration is hidden for the remainder of the
block, after which it resumes its force.

Variables with automatic storage duration are initialized each time
their declaration-statement is executed. Variables with automatic storage
duration declared in the block are destroyed on exit from the block.

It is possible
to transfer into a block, but not in a way that bypasses declarations with
initialization. A program that jumps from a point where a local variable with
automatic storage duration is not in scope to a point where it is in scope is
ill-formed unless the variable has POD
type and is declared without
an initializer.
For example:

void f() {

// ...

goto
lx; // ill-formed: jump into scope of a

// ...

ly:

X a = 1;

// ...

lx:

goto
ly; // OK, jump implies destructor call for a followed by
construction

// again immediately following label ly

}

The zero-initialization of all local objects with static storage
duration is performed before any other initialization takes place. A local
object of POD type with static storage duration initialized with constant-expressions
is initialized before its block is first entered. An implementation is
permitted to perform early initialization of other local objects with static
storage duration under the same conditions that an implementation is permitted
to statically initialize an object with static storage duration in namespace scope.
Otherwise such an object is initialized the first time control passes through
its declaration; such an object is considered initialized upon the completion
of its initialization. If the initialization exits by throwing an exception,
the initialization is not complete, so it will be tried again the next time
control enters the declaration. If control re-enters the declaration
(recursively) while the object is being initialized, the behavior is undefined.
For example:

int foo(int i) {

static
int s = foo(2*i); // recursive call – undefined

return
i+1;

}

The destructor for a local
object with static storage duration will be executed if and only if the
variable was constructed.

6144

static
void

6145

cp_parser_declaration_statement

(cp_parser* parser)

in parser.c

6146

{

6147

/* Parse the
block-declaration.
*/

6148

cp_parser_block_declaration
(parser, /*statement_p=*/
true);

6149

6150

/* Finish off the
statement.
*/

6151

finish_stmt ();

6152

}

For “SmallObject<>
object_;”, it is parsed following rule of block-declaration again.With call
stack: cp_parser_block_declaration

à

cp_parser_simple_declaration

à

cp_parser_type_specifier

à

cp_parser_simple_type_specifier

à

cp_parser_type_name

à

cp_parser_class_name

, template-id “SmallObject”
is recognized.

5.12.5.2.2.2.1.

Template instantation

5.12.5.2.2.2.1.1.


The
template-id


In this invocation of cp_parser_class_name

, the arguments typename_keyword_p

,
template_keyword_p

,
type_p

,
class_head_p

,
and is_declaration

are false; and check_dependency_p

is true. The detail of template-id lookup, refers to section 5.412.4.2.2.2.
Template-id
.

In cp_parser_template_id

,
if the template is a class template or a template template parameter, it will
call finish_template_type

to finish the processing. For our example, in
finish_template_type

,
lookup_template_class

has arguments in_decl

and context

of NULL, arglist

of the template argument-list which is NULL too, dl

of
the node of TEMPLATE_DECL, and entering_scope

of nonzero which means entering the
scope of template-id indicated.

4133

tree

4134

lookup_template_class
(tree d1,

in pt.c

4135

tree arglist,

4136

tree in_decl,

4137

tree context,

4138

int entering_scope,

4139

tsubst_flags_t complain)

4140

{

4141

tree template = NULL_TREE, parmlist;

4142

tree t;

4143

4144

timevar_push (TV_NAME_LOOKUP);

4145

4146

if (TREE_CODE (d1) == IDENTIFIER_NODE)

4147

{

…

4162

}

4163

else if (TREE_CODE (d1) == TYPE_DECL
&& IS_AGGR_TYPE (TREE_TYPE (d1)))

4164

{

…

4177

}

4178

else if (TREE_CODE (d1) == ENUMERAL_TYPE

4179

|| (TYPE_P (d1) && IS_AGGR_TYPE
(d1)))

4180

{

…

4183

}

4184

else if (TREE_CODE (d1) == TEMPLATE_DECL

4185

&& TREE_CODE
(DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL)

4186

{

4187

template = d1;

4188

d1 = DECL_NAME (template);

4189

context = DECL_CONTEXT (template);

4190

}

…

4219

complain &= ~tf_user;

4220

4221

if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))

4222

{

…

4259

}

4260

else

4261

{

4262

tree template_type = TREE_TYPE (template);

4263

tree gen_tmpl;

4264

tree type_decl;

4265

tree found = NULL_TREE;

4266

tree *tp;

4267

int arg_depth;

4268

int parm_depth;

4269

int is_partial_instantiation;

4270

4271

gen_tmpl = most_general_template
(template);

4272

parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);

4273

parm_depth = TMPL_PARMS_DEPTH (parmlist);

4274

arg_depth = TMPL_ARGS_DEPTH (arglist);

4275

4276

if (arg_depth == 1 && parm_depth
> 1)

4277

{

…

4294

}

4295

4296

/* Now we should
have enough arguments.
*/

4297

my_friendly_assert (parm_depth ==
arg_depth, 0);

4298

4299

/* From here on,
we're only interested in the most general

4300

template.
*/

4301

template = gen_tmpl;

4302

4303

/* Calculate the
BOUND_ARGS. These will be the args that are

4304

actually tsubst'd into the
definition to create the

4305

instantiation.
*/

4306

if (parm_depth > 1)

4307

{

…

4344

}

4345

else

4346

arglist

4347

= coerce_template_parms (INNERMOST_TEMPLATE_PARMS
(parmlist),

4348

INNERMOST_TEMPLATE_ARGS (arglist),

4349

template,

4350

complain, /*require_all_args=*/
1);

4351

4352

if (arglist == error_mark_node)

4353

/* We were
unable to bind the arguments.
*/

4354

POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
error_mark_node);

5.12.5.2.2.2.1.1.1.


Replace the first
default arguments


As arglist

is NULL, at line 4348 INNERMOST_TEMPLATE_ARGS returns NULL as result. And template

itself is the most general form, so INNERMOST_TEMPLATE_PARMS returns the
TREE_VEC in below figure for the parameters.

(Click
here for open
)

3805

static
tree

3806

coerce_template_parms
(tree parms,

in pt.c

3807

tree args,

3808

tree in_decl,

3809

tsubst_flags_t complain,

3810

int require_all_arguments)

3811

{

3812

int nparms, nargs, i, lost = 0;

3813

tree inner_args;

3814

tree new_args;

3815

tree new_inner_args;

3816

3817

inner_args = INNERMOST_TEMPLATE_ARGS (args);

3818

nargs = inner_args ? NUM_TMPL_ARGS
(inner_args) : 0;

3819

nparms = TREE_VEC_LENGTH (parms);

3820

3821

if (nargs > nparms

3822

|| (nargs < nparms

3823

&& require_all_arguments

3824

&& TREE_PURPOSE (TREE_VEC_ELT
(parms, nargs)) == NULL_TREE))

3825

{

3826

if (complain & tf_error)

3827

{

3828

error ("wrong number of template
arguments (%d, should be %d)",

3829

nargs, nparms);

3830

3831

if (in_decl)

3832

cp_error_at ("provided for
`%D'", in_decl);

3833

}

3834

3835

return
error_mark_node;

3836

}

3837

3838

new_inner_args = make_tree_vec (nparms);

3839

new_args = add_outermost_template_args (args,
new_inner_args);

3840

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

3841

{

3842

tree arg;

3843

tree parm;

3844

3845

/* Get the Ith
template parameter.
*/

3846

parm = TREE_VEC_ELT (parms, i);

3847

3848

/* Calculate the
Ith argument.
*/

3849

if (i < nargs)

3850

arg = TREE_VEC_ELT (inner_args, i);

3851

else if (require_all_arguments)

3852

/* There must
be a default arg in this case.
*/

3853

arg = tsubst_template_arg
(TREE_PURPOSE (parm), new_args,

3854

complain, in_decl);

3855

else

3856

break
;

3857

3858

my_friendly_assert (arg, 20030727);

3859

if (arg == error_mark_node)

3860

error ("template argument %d is
invalid", i + 1);

3861

else

3862

arg = convert_template_argument
(TREE_VALUE (parm),

3863

arg,
new_args, complain, i,

3864

i
n_decl);

3865

3866

if (arg == error_mark_node)

3867

lost++;

3868

TREE_VEC_ELT (new_inner_args, i) = arg;

3869

}

3870

3871

if (lost)

3872

return
error_mark_node;

3873

3874

return
new_inner_args;

3875

}

Above at line 3839, as args

is NULL, add_outermost_template_args

does nothing but
returns new_inner_args

.
In above figure, we see that TREE_PURPOSE field (the default argument) of first
parameter is the TMEPLATE_DECL of “SingleThreaded”. Then next is the arguments
replacement.

5700

static
tree

5701

tsubst_template_arg

(tree t, tree args,
tsubst_flags_t complain, tree in_decl)

in pt.c

5702

{

5703

tree r;

5704

5705

if (!t)

5706

r = t;

5707

else if (TYPE_P (t))

5708

r = tsubst (t, args, complain, in_decl);

5709

else

5710

{

5711

r = tsubst_expr
(t, args, complain, in_decl);

5712

5713

if (!uses_template_parms
(r))

5714

{

5715

/* Sometimes,
one of the args was an expression involving a

5716

template constant
parameter, like N - 1. Now that we've

5717

tsubst'd, we might have something like 2
- 1. This will

5718

confuse
lookup_template_class, so we do constant folding

5719

here. We have to unset
processing_template_decl, to fool

5720

tsubst_copy_and_build()
into building an actual tree.
*/

5721

5722

/* If the TREE_TYPE of ARG
is not NULL_TREE, ARG is already

5723

as simple as it's going to
get, and trying to reprocess

5724

the trees will break. Once
tsubst_expr et al DTRT for

5725

non-dependent exprs, this
code can go away, as the type

5726

will always be set.
*/

5727

if (!TREE_TYPE (r))

5728

{

5729

int saved_processing_template_decl =
processing_template_decl;

5730

processing_template_decl = 0;

5731

r
= tsubst_copy_and_build (r, /*args=*/
NULL_TREE,

5732

tf_error, /*in_decl=*/
NULL_TREE,

5733

/*function_p=*/
false);

5734

processing_template_decl =
saved_processing_template_decl;

5735

}

5736

r = fold (r);

5737

}

5738

}

5739

return
r;

5740

}

Being a node satisfying DECL_P, tsubst_expr

takes the job.

7822

static
tree

7823

tsubst_expr

(tree t, tree args,
tsubst_flags_t complain, tree in_decl)

in pt.c

7824

{

7825

tree stmt, tmp;

7826

tsubst_flags_t stmt_expr

7827

= complain & (tf_stmt_expr_cmpd |
tf_stmt_expr_body);

7828

7829

complain ^= stmt_expr;

7830

if (t == NULL_TREE || t == error_mark_node)

7831

return
t;

7832

7833

if (!STATEMENT_CODE_P (TREE_CODE (t)))

7834

return
tsubst_copy_and_build
(t, args, complain,
in_decl,

7835

/*function_p=*/
false);

…

8156

}

STATEMENT_CODE_P above returns nonzero if the code of the node
indicates that the node is one of the statements (of course, TEMPLATE_DECL is
not qualified; see section 4.3.1.1.
stmt_codes
for reference).

8180

tree

8181

tsubst_copy_and_build

(tree t,

in pt.c

8182

tree args,

8183

tsubst_flags_t complain,

8184

tree in_decl,

8185

bool function_p)

8186

{

8187

#define
RECUR(NODE) /

8188

tsubst_copy_and_build (NODE, args, complain,
in_decl, /*function_p=*/
false)

8189

8190

tree op1;

8191

8192

if (t == NULL_TREE || t == error_mark_node)

8193

return
t;

8194

8195

switch
(TREE_CODE
(t))

8196

{

…

8693

default
:

8694

return
tsubst_copy
(t, args, complain, in_decl);

8695

}

8696

8697

#undef
RECUR

8698

}

TEMPLATE_DECL doesn’t require special treatment in tsubst_copy_and_build

(just “copy” is enough).

7449

static
tree

7450

tsubst_copy

(tree t, tree args,
tsubst_flags_t complain, tree in_decl)

in pt.c

7451

{

7452

enum
tree_code code;

7453

tree r;

7454

7455

if (t == NULL_TREE || t == error_mark_node)

7456

return
t;

7457

7458

code = TREE_CODE (t);

7459

7460

switch
(code)

7461

{

…

7542

case
TEMPLATE_DECL:

7543

if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))

7544

return
tsubst (TREE_TYPE (DECL_TEMPLATE_RESULT (t)),

7545

args, complain, in_decl);

7546

else if (is_member_template (t))

7547

return
tsubst (t, args, complain, in_decl);

7548

else if (DECL_CLASS_SCOPE_P (t)

7549

&&
uses_template_parms

(DECL_CONTEXT (t)))

7550

{

7551

/* Template
template argument like the following example need

7552

special treatment:

7553

7554

template <template
<class> class TT> struct C {};

7555

template <class T>
struct D {

7556

template <class U> struct E {};

7557

C<E> c;
//
#1

7558

};

7559

D<int> d;
// #2

7560

7561

We are processing the
template argument `E' in #1 for

7562

the template
instantiation #2. Originally, `E' is a

7563

TEMPLATE_DECL with
`D<T>' as its DECL_CONTEXT. Now we

7564

have to substitute this
with one having context `D<int>'.

*/

7565

7566

tree context = tsubst (DECL_CONTEXT
(t), args, complain, in_decl);

7567

return
lookup_field (context, DECL_NAME(t), 0, false);

7568

}

7569

else

7570

/* Ordinary
template template argument.
*/

7571

return
t;

…

7816

}

7817

}

Not defined in template parameter-list,
DECL_TEMPLATE_TEMPLATE_PARM_P returns zero for “SingleThreaded”; nor is it a
member template; and the context (enclosing scope) of “SingleThreaded” is the
namespace of “Loki” which of course is not type-dependent or value-dependent
(so uses_template_parms

returns false); so the node of TEMPLATE_DECL is just returned at line 7571.

After returning back tsubst_template_arg

, TEMPLATE_DECL which
isn’t template template parameter causes uses_template_parms

at line 5713 returns
false, and it skips IF
block at line
5727 as type

field is not NULL. Further fold

following does nothing as no constant
can be folded but just returns the TEMPLATE_DECL.

After returning
the default argument, it checks if adjustment is needed and possible. Node of
TEMPLATE_DECL in below figure is pointed by parm

, which comes from template parameter
definition.

(Click
here for open
)

In below figure, node of TEMPLATE_DECL is referred by arg

,
which comes from the definition of “SingleThreaded”.

(Click
here for open
)

3636

static
tree

3637

convert_template_argument
(tree parm,

in pt.c

3638

tree arg,

3639

tree args,

3640

tsubst_flags_t
complain,

3641

int i,

3642

tree in_decl)

3643

{

3644

tree val;

3645

tree inner_args;

3646

int is_type, requires_type, is_tmpl_type,
requires_tmpl_type;

3647

3648

inner_args = INNERMOST_TEMPLATE_ARGS (args);

3649

3650

requires_tmpl_type = TREE_CODE (parm) ==
TEMPLATE_DECL;

3651

requires_type = (TREE_CODE (parm) ==
TYPE_DECL

3652

|| requires_tmpl_type);

3653

3654

is_tmpl_type = ((TREE_CODE (arg) ==
TEMPLATE_DECL

3655

&& TREE_CODE
(DECL_TEMPLATE_RESULT (arg)) == TYPE_DECL)

3656

|| TREE_CODE (arg) ==
TEMPLATE_TEMPLATE_PARM

3657

|| TREE_CODE (arg) ==
UNBOUND_CLASS_TEMPLATE);

3658

3659

if (is_tmpl_type

3660

&& (TREE_CODE (arg) ==
TEMPLATE_TEMPLATE_PARM

3661

|| TREE_CODE (arg) ==
UNBOUND_CLASS_TEMPLATE))

3662

arg
= TYPE_STUB_DECL (arg);

3663

3664

is_type = TYPE_P (arg) || is_tmpl_type;

…

3722

if (is_type)

3723

{

3724

if (requires_tmpl_type)

3725

{

3726

if (TREE_CODE (TREE_TYPE (arg)) ==
UNBOUND_CLASS_TEMPLATE)

3727

/* The number
of argument required is not known yet.

3728

Just accept it for
now.
*/

3729

val = TREE_TYPE (arg);

3730

else

3731

{

3732

tree parmparm =
DECL_INNERMOST_TEMPLATE_PARMS (parm);

3733

tree argparm =
DECL_INNERMOST_TEMPLATE_PARMS (arg);

3734

3735

if (coerce_template_template_parms
(parmparm, argparm,

3736

complain,
in_decl,

3737

inner_args))

3738

{

3739

val = arg;

3740

3741

/*
TEMPLATE_TEMPLATE_PARM node is preferred over

3742

TEMPLATE_DECL.
*/

3743

if (val != error_mark_node

3744

&&
DECL_TEMPLATE_TEMPLATE_PARM_P (val))

3745

val = TREE_TYPE (val);

3746

}

3747

else

3748

{

…

3757

}

3758

}

3759

}

3760

else

3761

val = groktypename (arg);

3762

}

3763

else

3764

{

…

3790

}

3791

3792

return
val;

3793

}

Clearly, at line 3732, parmparm

and argparm

refer to the nodes of TREE_VEC
respectively in figure they belong to. Nothing is done in coerce_template_template_parms

,
and 1 is returned. So arg

is returned by convert_template_argument

.
Then it is set in first element of new_inner_args

in coerce_template_parms

.