Studying note of GCC-3.4.6 source (159)

5.13.4.4.

Iterate – emitting code for deferred function

Function generated by the compiler (via implicitly_declare_fn

, mark_decl_instantiated

,
or build_clone

)
or inline method is cached in deferred_fns

. Arriving here, we have parsed the
whole source file, information needed in handling these deferred functions
should be available.

First, for “artificial” method generated by the compiler itself, it
has flag DECL_ARTIFICIAL set; In FUNCTION_DECL, its DECL_INITIAL field, after
the front-end doing its job, should be trees of entities bound in this function
scope (i.e., BLOCK nodes), otherwise it would be NULL. For “artificial” methods
having empty DECL_INITIAL, the compiler just makes the declarations so far, now
it needs to synthesize the definitions.

742

void

743

synthesize_method

(tree fndecl)

in method.c

744

{

745

bool nested = (current_function_decl

!= NULL_TREE);

746

tree context = decl_function_context
(fndecl);

747

bool need_body = true;

748

tree stmt;

749

750

if (at_eof

)

751

import_export_decl (fndecl);

752

753

/* If we've been asked to synthesize a clone,
just synthesize the

754

cloned function instead. Doing so will
automatically fill in the

755

body for the clone.
*/

756

if (DECL_CLONED_FUNCTION_P (fndecl))

757

{

758

synthesize_method (DECL_CLONED_FUNCTION (fndecl));

759

return
;

760

}

761

762

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

763

it now.

*/

764

push_deferring_access_checks
(dk_no_deferred);

765

766

if (! context)

767

push_to_top_level
();

768

else if (nested)

769

push_function_context_to
(context);

770

771

/* Put the function definition at the position
where it is needed,

772

rather than within the body of the class.
That way, an error

773

during the generation of the implicit body
points at the place

774

where the attempt to generate the function
occurs, giving the

775

user a hint as to why we are attempting to
generate the

776

function.

*/

777

DECL_SOURCE_LOCATION (fndecl) = input_location

;

778

779

interface_unknown

= 1;

780

start_function
(NULL_TREE, fndecl,
NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);

781

clear_last_expr ();

782

stmt = begin_function_body
();

783

784

if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)

785

{

786

do_build_assign_ref (fndecl);

787

need_body = false;

788

}

789

else if (DECL_CONSTRUCTOR_P (fndecl))

790

{

791

tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);

792

if (arg_chain != void_list_node)

793

do_build_copy_constructor (fndecl);

794

else if (TYPE_NEEDS_CONSTRUCTING (current_class_type

))

795

finish_mem_initializers (NULL_TREE);

796

}

797

798

/* If we haven't yet generated the body of the
function, just

799

generate an empty compound statement.
*/

800

if (need_body)

801

{

802

tree compound_stmt;

803

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

804

finish_compound_stmt
(compound_stmt);

805

}

806

807

finish_function_body
(stmt);

808

expand_or_defer_fn
(finish_function
(0));

809

810

extract_interface_info
();

811

if (! context)

812

pop_from_top_level ();

813

else if (nested)

814

pop_function_context_from (context);

815

816

pop_deferring_access_checks
();

817

}

See the definition of synthesize_method

will be done in global namespace.
But never mind, as node of the function declarations already contain correct
context information. Besides, context information only is used for name-lookup,
all code should be emitted within global namespace with mangled name instead.

Note expand_or_defer_fn

at line 808, which is also
called at line 2769 in finish_file

.
However, as long as invoking this function here, in finish_file

, condition at
line 2762 is not satisfied, so no call any more. Before, one of major operation
of expand_or_defer_fn

is traversing the given function tree, and calling simplify_aggr_init_exprs_r

to processing AGGR_INIT_EXPR nodes found. Gccint [2] gives below description:

AGGR_INIT_EXPR

An AGGR_INIT_EXPR represents the initialization as the return value
of a function call, or as the result of a constructor. An AGGR_INIT_EXPR will
only appear as the second operand of a TARGET_EXPR. The first operand to the
AGGR_INIT_EXPR is the address of a function to call, just as in a CALL_EXPR.
The second operand are the arguments to pass that function, as a TREE_LIST,
again in a manner similar to that of a CALL_EXPR. The value of the expression
is that returned by the function.

If AGGR_INIT_VIA_CTOR_P holds of the AGGR_INIT_EXPR, then the
initialization is via a constructor call. The address of the third operand of
the AGGR_INIT_EXPR, which is always a VAR_DECL, is taken, and this value
replaces the first argument in the argument list. In this case, the value of
the expression is the VAR_DECL given by the third operand to the AGGR_INIT_EXPR;
constructors do not return a value.

It is the structure used
in named return value optimization, the caller passes the address of a block of
memory in which the value should be stored. This address is called the "structure
value address". simplify_aggr_init_exprs_r

combines the
CALL_EXPR with its arguments and the temperary local variable (which is added
as extra argument, as we try to return aggregate type); and inserts these nodes
within the chain of DECL_SAVED_TREE (fn)

.

2769

static
tree

2770

simplify_aggr_init_exprs_r

(tree* tp,

in semantics.c

2771

int* walk_subtrees,

2772

void* data
ATTRIBUTE_UNUSED)

2773

{

2774

/* We don't need to
walk into types; there's nothing in a type that

2775

needs simplification. (And, furthermore,
there are places we

2776

actively don't want to go. For example, we
don't want to wander

2777

into the default arguments for a
FUNCTION_DECL that appears in a

2778

CALL_EXPR.)

*/

2779

if (TYPE_P (*tp))

2780

{

2781

*walk_subtrees = 0;

2782

return
NULL_TREE;

2783

}

2784

/* Only
AGGR_INIT_EXPRs are interesting.
*/

2785

else if (TREE_CODE (*tp) != AGGR_INIT_EXPR)

2786

return
NULL_TREE;

2787

2788

simplify_aggr_init_expr
(tp);

2789

2790

/* Keep
iterating.
*/

2791

return
NULL_TREE;

2792

}

It see that simplify_aggr_init_exprs_r

always returns NULL, which forces walk_tree

to visit the whole tree. As in a
function definition it may contain more than 1 node of AGGR_INIT_EXPR. For
example:

class
A {…};

class
B {

public
:

B (const
A&);

…

};

A func1 () {…}

B func2 () {

B b = func1 ();
// 1st AGGR_INIT_EXPR

return
b;
// 2nd AGGR_INIT_EXPR

}

AGGR_INIT_EXPR is handled
by below function. Note that fn gotten at line 2804 is the address of the
function (i.e., node of ADDR_EXPR).

2798

void

2799

simplify_aggr_init_expr

(tree *tp)

in semantics.c

2800

{

2801

tree aggr_init_expr = *tp;

2802

2803

/* Form an
appropriate CALL_EXPR.
*/

2804

tree fn = TREE_OPERAND (aggr_init_expr, 0);

2805

tree args = TREE_OPERAND (aggr_init_expr, 1);

2806

tree slot = TREE_OPERAND (aggr_init_expr, 2);

2807

tree type = TREE_TYPE (aggr_init_expr);

2808

2809

tree call_expr;

2810

enum
style_t
{ ctor, arg, pcc } style;

2811

2812

if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr))

2813

style = ctor;

2814

#ifdef

PCC_STATIC_STRUCT_RETURN

2815

else if (1)

2816

style = pcc;

2817

#endif

2818

else if (TREE_ADDRESSABLE (type))

2819

style = arg;

2820

else

2821

/* We shouldn't
build an AGGR_INIT_EXPR if we don't need any special

2822

handling. See build_cplus_new.
*/

2823

abort ();

2824

2825

if (style == ctor || style == arg)

2826

{

2827

/* Pass the
address of the slot. If this is a constructor, we

2828

replace the first argument;
otherwise, we tack on a new one.
*/

2829

tree
addr;

2830

2831

if (style == ctor)

2832

args
= TREE_CHAIN (args);

2833

2834

cxx_mark_addressable (slot);

2835

addr = build1
(ADDR_EXPR, build_pointer_type
(TREE_TYPE
(slot)), slot);

2836

if (style == arg)

2837

{

2838

/* The return
type might have different cv-quals from the slot.
*/

2839

tree fntype = TREE_TYPE (TREE_TYPE (fn));

2840

#ifdef
ENABLE_CHECKING

2841

if (TREE_CODE (fntype) != FUNCTION_TYPE

2842

&& TREE_CODE (fntype) !=
METHOD_TYPE)

2843

abort ();

2844

#endif

2845

addr = convert (build_pointer_type
(TREE_TYPE (fntype)), addr);

2846

}

2847

2848

args = tree_cons (NULL_TREE, addr, args);

2849

}

2850

2851

call_expr = build (CALL_EXPR,

2852

TREE_TYPE (TREE_TYPE
(TREE_TYPE (fn))),

2853

fn, args, NULL_TREE);

2854

2855

if (style == arg)

2856

/* Tell the
backend that we've added our return slot to the argument

2857

list.

*/

2858

CALL_EXPR_HAS_RETURN_SLOT_ADDR (call_expr)
= 1;

2859

else if (style == pcc)

2860

{

2861

/* If we're using
the non-reentrant PCC calling convention, then we

2862

need to copy the returned value out of the
static buffer into the

2863

SLOT.
*/

2864

push_deferring_access_checks
(dk_no_check);

2865

call_expr = build_aggr_init (slot,
call_expr,

2866

DIRECT_BIND |
LOOKUP_ONLYCONVERTING);

2867

pop_deferring_access_checks
();

2868

}

2869

2870

/* We want to use
the value of the initialized location as the

2871

result.

*/

2872

call_expr = build (COMPOUND_EXPR, type,

2873

call_expr, slot);

2874

2875

/* Replace the
AGGR_INIT_EXPR with the CALL_EXPR.
*/

2876

TREE_CHAIN (call_expr) = TREE_CHAIN
(aggr_init_expr);

2877

*tp = call_expr;

2878

}

As named return value optimization will strip the return statement
from the function, at line 2872, the original call expression needs be replaced
by a compound statement to make the return value can be acquired correctly.
Next see line 2834, the variable holding the return value is marked as
addressable, it will affect the RTL generation deeply. And PCC_STATIC_STRUCT_RETURN
at line 2814 is defined if the usual system convention on the target
machine for returning structures and unions
is for the called function to return the address of a static variable
containing the value. It is not defined for x86 machine.