Studying note of GCC-3.4.6 source (109)

5.12.3.2.1.2.1.2.


Parse
function body


For the keyword “return” seen at line 14368 which follows “)”,
refers to section Build
nodes for method
for detail.

14356

static
tree

14357

cp_parser_function_definition_after_declarator

(cp_parser* parser,

in parser.c

14358

bool inline_p)

14359

{

14360

tree fn;

14361

bool ctor_initializer_p =
false;

14362

bool
saved_in_unbraced_linkage_specification_p;

14363

unsigned
saved_num_template_parameter_lists;

14364

14365

/*
If the next token is `return', then the code may be trying to

14366

make
use of the "named return value" extension that G++ used to

14367

support.
*/

14368

if (cp_lexer_next_token_is_keyword
(parser->lexer, RID_RETURN))

14369

{

14370

/*
Consume the `return' keyword.
*/

14371

cp_lexer_consume_token
(parser->lexer);

14372

/*
Look for the identifier that indicates what value is to be

14373

returned.
*/

14374

cp_parser_identifier
(parser);

14375

/*
Issue an error message.
*/

14376

error ("named return
values are no longer supported");

14377

/*
Skip tokens until we reach the start of the function body.
*/

14378

while
(cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE)

14379

&&
cp_lexer_next_token_is_not (parser->lexer, CPP_EOF))

14380

cp_lexer_consume_token

(parser->lexer);

14381

}

14382

/*
The `extern' in `extern "C" void f () { ... }' does not apply to

14383

anything declared inside `f'.
*/

14384

saved_in_unbraced_linkage_specification_p

14385

=
parser->in_unbraced_linkage_specification_p;

14386

parser->in_unbraced_linkage_specification_p
= false;

14387

/*
Inside the function, surrounding template-parameter-lists do not

14388

apply.
*/

14389

saved_num_template_parameter_lists

14390

=
parser->num_template_parameter_lists;

14391

parser->num_template_parameter_lists
= 0;

14392

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

14393

function-try-block.
*/

14394

if (cp_lexer_next_token_is_keyword
(parser->lexer, RID_TRY))

14395

ctor_initializer_p =
cp_parser_function_try_block (parser);

14396

/*
A function-try-block includes the function-body, so we only do

14397

this
next part if we're not processing a function-try-block.
*/

14398

else

14399

ctor_initializer_p

14400

= cp_parser_ctor_initializer_opt_and_function_body
(parser);

14401

14402

/*
Finish the function.
*/

14403

fn = finish_function
((ctor_initializer_p ? 1 : 0) |

14404

(inline_p ?
2 : 0));

14405

/*
Generate code for it, if necessary.
*/

14406

expand_or_defer_fn (fn);

14407

/*
Restore the saved values.
*/

14408

parser->in_unbraced_linkage_specification_p

14409

= saved_in_unbraced_linkage_specification_p;

14410

parser->num_template_parameter_lists

14411

=
saved_num_template_parameter_lists;

14412

14413

return
fn;

14414

}

5.12.3.2.1.2.1.2.1.


Preparation


Though our example method contains an empty function body, but
handling empty function body still embodies rather complex procedure.

11469

static
bool

11470

cp_parser_ctor_initializer_opt_and_function_body

(cp_parser *parser)

in parser.c

11471

{

11472

tree body;

11473

bool ctor_initializer_p;

11474

11475

/*
Begin the function body.
*/

11476

body = begin_function_body
();

11477

/*
Parse the optional ctor-initializer.
*/

11478

ctor_initializer_p =
cp_parser_ctor_initializer_opt (parser);

11479

/*
Parse the function-body.
*/

11480

cp_parser_function_body
(parser);

11481

/*
Finish the function body.
*/

11482

finish_function_body
(body);

11483

11484

return
ctor_initializer_p;

11485

}

The function body is a compound statement itself, which has
following rule:

compound-statement:

{ statement-seq [opt] }

The statement-seq is enclosed the pair of brace which forms a scope
that separates this statement-seq from outside. So before really handling
function body it needs some preparation.

10756

tree

10757

begin_function_body

(void)

in decl.c

10758

{

10759

tree stmt;

10760

10761

if (processing_template_decl
)

10762

/*
Do nothing now.
*/;

10763

else

10764

/*
Always keep the BLOCK node associated with the outermost pair of

10765

curly braces of a function. These are needed for correct

10766

operation of dwarfout.c.
*/

10767

keep_next_level (true);

10768

10769

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

10770

COMPOUND_STMT_BODY_BLOCK
(stmt) = 1;

10771

10772

if (processing_template_decl
)

10773

/*
Do nothing now.
*/;

10774

else if (DECL_CONSTRUCTOR_P
(current_function_decl

))

10775

begin_constructor_body ();

10776

else if (DECL_DESTRUCTOR_P (current_function_decl

))

10777

begin_destructor_body ();

10778

10779

return
stmt;

10780

}

See that argument has_no_scope

is false for the invocation, which
means the compound statement defines a scope.

998

tree

999

begin_compound_stmt

(bool has_no_scope)

in semantics.c

1000

{

1001

tree r;

1002

int is_try = 0;

1003

1004

r = build_stmt
(COMPOUND_STMT, NULL_TREE);

1005

1006

if (last_tree &&
TREE_CODE (last_tree) == TRY_BLOCK)

1007

is_try = 1;

1008

1009

add_stmt
(r);

1010

if (has_no_scope)

1011

COMPOUND_STMT_NO_SCOPE (r)
= 1;

1012

1013

last_expr_type = NULL_TREE;

1014

1015

if (!has_no_scope)

1016

do_pushlevel
(is_try ? sk_try : sk_block);

1017

else

1018

/* Normally, we try hard to keep the BLOCK for
a

1019

statement-expression. But, if it's a statement-expression with

1020

a
scopeless block, there's nothing to keep, and we don't want

1021

to
accidentally keep a block *inside* the scopeless block.
*/

1022

keep_next_level (false);

1023

1024

return
r;

1025

}

In intermediate tree, brace and parethensis can’t be present. To mark
all statements within the compound statement, a node of COMPOUND_STMT is
created being the head of statement list. At line 84, last_expr_filename

is updated as input_filename

in begin_stmt_tree

.
And if current input file is not the same as that current function belonged,
node of FILE_STMT is created to tell the difference.

81

tree

82

add_stmt

(tree t)

in c-semantics.c

83

{

84

if (input_filename !=
last_expr_filename)

85

{

86

/*
If the filename has changed, also add in a FILE_STMT. Do a string

87

compare first, though, as it might be an
equivalent string.
*/

88

int add = (strcmp
(input_filename, last_expr_filename) != 0);

89

last_expr_filename =
input_filename;

90

if (add)

91

{

92

tree pos = build_nt
(FILE_STMT,
get_identifier

(input_filename));

93

add_stmt (pos);

94

}

95

}

96

97

/*
Add T to the statement-tree.
*/

98

TREE_CHAIN (last_tree) = t;

99

last_tree = t;

100

101

/*
When we expand a statement-tree, we must know whether or not the

102

statements are full-expressions. We record that fact here.
*/

103

STMT_IS_FULL_EXPR_P
(last_tree) = stmts_are_full_exprs_p
();

104

105

return
t;

106

}

Notice that the statement is added at tail of the statement-list,
however, field saved_tree

of the FUNCTION_DECL still refers to the head of the list. Routine stmts_are_full_exprs_p

returns true if the current statement is a full expression (i.e. temporaries
created during that statement should be destroyed at the end of the statement).
Field stmts_are_full_exprs_p

is set as 1 at line 11299 in cxx_push_function_context

.

306

int

307

stmts_are_full_exprs_p

(void)

in semantics.c

308

{

309

return
current_stmt_tree
()->stmts_are_full_exprs_p;

310

}

Then if the compound statement defines a scope, a new scope should
be pushed as sk_block or try_block.

364

void

365

do_pushlevel

(scope_kind sk)

in semantics.c

366

{

367

if (stmts_are_full_exprs_p
())

368

{

369

if (!processing_template_decl
)

370

add_scope_stmt
(/*begin_p=*/
1, /*partial_p=*/
0);

371

begin_scope

(sk, NULL);

372

}

373

}

If it is not a template declaration, a node of SCOPE_STMT is
inserted into the statement-list. Argument begin_p

indicates whether this statement opens or
closes a scope; partial_p

is true for a partial scope, i.e, the scope that begins after a label when an
object that needs a cleanup is created. In C++, scopes can be contained wholy
by other scopes, but can’t be overlapped partial each other. So stack is
appropriate for recording scopes, with new node represents new scope.

131

tree

132

add_scope_stmt

(int begin_p, int partial_p)

in c-semantics.c

133

{

134

tree *stack_ptr = current_scope_stmt_stack
();

135

tree ss;

136

tree top = *stack_ptr;

137

138

/*
Build the statement.
*/

139

ss = build_stmt (SCOPE_STMT,
NULL_TREE);

140

SCOPE_BEGIN_P (ss) =
begin_p;

141

SCOPE_PARTIAL_P (ss) =
partial_p;

142

143

/*
Keep the scope stack up to date.
*/

144

if (begin_p)

145

{

146

top = tree_cons (ss,
NULL_TREE, top);

147

*stack_ptr = top;

148

}

149

else

150

{

151

if (partial_p !=
SCOPE_PARTIAL_P (TREE_PURPOSE (top)))

152

abort ();

153

TREE_VALUE (top) = ss;

154

*stack_ptr = TREE_CHAIN
(top);

155

}

156

157

/*
Add the new statement to the statement-tree.

*/

158

add_stmt
(ss);

159

160

return
top;

161

}

The SCOPE_STMT stack mentioned above is returned by current_scope_stmt_stack

.

1199

tree *

1200

current_scope_stmt_stack

(void)

in c-semantics.c

1201

{

1202

return
&cfun

->language->base.x_scope_stmt_stack;

1203

}

At line 151
SCOPE_PARTIAL_P indicates partial scope, which for example:

S s;

l:

S s2;

goto
l;

There is (implicitly) a
new scope after `l', even though there are no curly braces. In particular, when
we hit the goto, we must destroy s2 and then re-construct it.

Then following
nodes will be created before real function-body parsing. We omit the node of last_tree

here, as it always refers to the node at tail of the list.

(Click
here for open
)

Figure 94

:
Before real function-body parsing