Studying note of GCC-3.4.6 source (112)

5.12.3.2.1.2.1.4.


Prepare
for code generation


The last invocation in cp_parser_function_definition_after_declarator

is expand_or_defer_fn

.
If appropriate, it will generate RTL code for the function; or it does some
preparation for RTL generation.

2973

void

2974

expand_or_defer_fn

(tree fn)

in semantics.c

2975

{

2976

/*
When the parser calls us after finishing the body of a template

2977

function, we don't really want to expand the body.
*/

2978

if (processing_template_decl
)

2979

{

2980

/*
Normally, collection only occurs in rest_of_compilation. So,

2981

if
we don't collect here, we never collect junk generated

2982

during the processing of templates until we hit a

2983

non-template function.
*/

2984

ggc_collect ();

2985

return
;

2986

}

2987

2988

/*
Replace AGGR_INIT_EXPRs with appropriate CALL_EXPRs.
*/

2989

walk_tree_without_duplicates
(&DECL_SAVED_TREE (fn),

2990

simplify_aggr_init_exprs_r,

2991

NULL);

2992

2993

/*
If this is a constructor or destructor body, we have to clone

2994

it.
*/

2995

if (maybe_clone_body (fn))

2996

{

2997

/*
We don't want to process FN again, so pretend we've written

2998

it
out, even though we haven't.
*/

2999

TREE_ASM_WRITTEN (fn) = 1;

3000

return
;

3001

}

3002

3003

/*
There's no reason to do any of the work here if we're only doing

3004

semantic analysis; this code just generates RTL.
*/

3005

if (flag_syntax_only

)

3006

return
;

3007

3008

/*
Compute the appropriate object-file linkage for inline functions.
*/

3009

if (DECL_DECLARED_INLINE_P
(fn))

3010

import_export_decl (fn);

3011

3012

/*
If this function is marked with the constructor attribute, add it

3013

to the
list of functions to be called along with constructors

3014

from
static duration objects.
*/

3015

if (DECL_STATIC_CONSTRUCTOR
(fn))

3016

static_ctors

= tree_cons
(NULL_TREE, fn, static_ctors

);

3017

3018

/*
If this function is marked with the destructor attribute, add it

3019

to the
list of functions to be called along with destructors from

3020

static
duration objects.
*/

3021

if (DECL_STATIC_DESTRUCTOR
(fn))

3022

static_dtors

= tree_cons
(NULL_TREE, fn, static_dtors

);

3023

3024

function_depth

++;

3025

3026

/*
Expand or defer, at the whim of the compilation unit manager.
*/

3027

cgraph_finalize_function
(fn, function_depth

> 1);

3028

3029

function_depth

--;

3030

}

The iteration of the tree for the function definition at line 2989,
processes the call of function suitable for named return value optimization. We
will study it with nrv later.

Above predicate DECL_STATIC_CONSTRUCTOR or DECL_STATIC_DESTRUCTOR
holds if the function is declared with __attribute__ ((constructor))

or __attribute__
((destructor))

. The constructor attribute causes the function to be
called automatically before execution enters main (). Similarly, the destructor
attribute causes the function to be called automatically after main () has
completed or exit () has been called. Functions with these attributes are
useful for initializing data that will be used implicitly during the execution
of the program.

5.12.3.2.1.2.1.4.1.


Update call-graph


Previous section Graph of
relation between caller and callee
describes cgraph_node

and cgraph_edge

.
Also it studies routine cgraph_node

which
creates single node of cgraph_node

for every function at first
invocation and returns this unique node in later invocations. It is the first
time to invoke cgraph_finalize_function

and cgraph_node

for function
specified by decl

during the compilation.

157

void

158

cgraph_finalize_function

(tree decl,
bool nested)

in cgraphunit.c

159

{

160

struct
cgraph_node *node = cgraph_node
(decl);

161

162

if (node->local.finalized)

163

{

164

/* As an GCC
extension we allow redefinition of the function. The

165

semantics when
both copies of bodies differ is not well defined.

166

We replace the
old body with new body so in unit at a time mode

167

we always use
new body, while in normal mode we may end up with

168

old body
inlined into some functions and new body expanded and

169

inlined in
others.

170

171

??? It may make
more sense to use one body for inlining and other

172

body for
expanding the function but this is difficult to do.
*/

173

174

/* If
node->output is set, then this is a unit-at-a-time compilation

175

and we have
already begun whole-unit analysis. This is *not*

176

testing for
whether we've already emitted the function. That

177

case can be
sort-of legitimately seen with real function

178

redefinition
errors. I would argue that the front end should

179

never present
us with such a case, but don't enforce that for now.
*/

180

if (node->output)

181

abort ();

182

183

/* Reset our datastructures so we can analyze
the function again.
*/

184

memset (&node->local, 0, sizeof
(node->local));

185

memset (&node->global, 0, sizeof
(node->global));

186

memset (&node->rtl, 0, sizeof
(node->rtl));

187

node->analyzed = false;

188

node->local.redefined_extern_inline =
true;

189

while
(node->callees)

190

cgraph_remove_edge (node,
node->callees->callee);

191

192

/* We may need to
re-queue the node for assembling in case

193

we already
proceeded it and ignored as not needed.

*/

194

if (node->reachable && !flag_unit_at_a_time

)

195

{

196

struct
cgraph_node *n;

197

198

for
(n = cgraph_nodes_queue

;
n; n = n->next_needed)

199

if (n == node)

200

break
;

201

if (!n)

202

node->reachable = 0;

203

}

204

}

205

206

notice_global_symbol
(decl);

207

node->decl = decl;

208

node->local.finalized = true;

209

210

/* If not unit at a
time, then we need to create the call graph

211

now, so that
called functions can be queued and emitted now.

*/

212

if (!flag_unit_at_a_time

)

213

{

214

cgraph_analyze_function (node);

215

cgraph_decide_inlining_incrementally
(node);

216

}

In the first time invocation, node->local.finalized

must be false, but it is
updated to true at line 208 immediately. At line 206, notice_global_symbol

collects first visible global symbol. As global symbol must be unique across
the translation unit, it is useful to generate unique name for the nameless
object by the compiler, for example, symbol collected here will be used to
generate internal name of annoymous namespace.

1034

void

1035

notice_global_symbol

(tree decl)

in varasm.c

1036

{

1037

const
char
**type = &first_global_object_name

;

1038

1039

if (first_global_object_name

1040

|| !TREE_PUBLIC (decl) || DECL_EXTERNAL
(decl)

1041

|| !DECL_NAME (decl)

1042

|| (TREE_CODE (decl) != FUNCTION_DECL

1043

&& (TREE_CODE (decl) !=
VAR_DECL

1044

|| (DECL_COMMON (decl)

1045

&& (DECL_INITIAL (decl)
== 0

1046

|| DECL_INITIAL (decl) ==
error_mark_node))))

1047

|| GET_CODE (DECL_RTL (decl)) != MEM)

1048

return
;

1049

1050

/* We win when
global object is found, but it is usefull to know about weak

1051

symbol as well so we can
produce nicer unique names.
*/

1052

if (DECL_WEAK (decl) || DECL_ONE_ONLY (decl))

1053

type = &weak_global_object_name

;

1054

1055

if (!*type)

1056

{

1057

const
char
*p;

1058

char *name;

1059

rtx decl_rtl = DECL_RTL (decl);

1060

1061

p = (* targetm

.strip_name_encoding) (XSTR (XEXP
(decl_rtl, 0), 0));

1062

name = xstrdup (p);

1063

1064

*type = name;

1065

}

1066

}

At line 212 in cgraph_finalize_function

,
flag_unit_at_a_time

is set as 1 if we specify optimization switch higher than –O2 in the compiling command. Usually, we would
like to use –O3 option to squeeze out all optimization ability from the
compiler. Here assuming flag_unit_at_a_time

is 1.

cgraph_finalize_function (continue)

218

if (decide_is_function_needed
(node, decl))

219

cgraph_mark_needed_node
(node);

220

221

/* If not unit at a
time, go ahead and emit everything we've found

222

to be reachable
at this time.
*/

223

if (!nested)

224

{

225

if (!cgraph_assemble_pending_functions ())

226

ggc_collect ();

227

}

228

229

/* If we've not yet
emitted decl, tell the debug info about it.

*/

230

if (!TREE_ASM_WRITTEN (decl))

231

(*debug_hooks

->deferred_inline_function) (decl);

232

233

/* We will never
really output the function body, clear the SAVED_INSNS array

234

early then.
*/

235

if (DECL_EXTERNAL (decl))

236

DECL_SAVED_INSNS (decl) = NULL;

237

}

Routine decide_is_function_needed

determines if decl
is visible to something either outside this translation unit, something magic
in the system configuration, or (if not doing unit-at-a-time) to something we
haven't seen yet. At line 93, attribute “used” means that the variable must be
emitted even if it appears that the variable is not referenced (compiler will
eliminate dead code).

73

static
bool

74

decide_is_function_needed

(struct
cgraph_node *node, tree decl)

in cgraphunit.c

75

{

76

/* If we decided it
was needed before, but at the time we didn't have

77

the body of the
function available, then it's still needed. We have

78

to go back and
re-check its dependencies now.
*/

79

if (node->needed)

80

return
true;

81

82

/* Externally visible
functions must be output. The exception is

83

COMDAT functions
that must be output only when they are needed.

*/

84

if (TREE_PUBLIC (decl)
&& !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))

85

return
true;

86

87

/* Constructors and
destructors are reachable from the runtime by

88

some mechanism.
*/

89

if (DECL_STATIC_CONSTRUCTOR (decl) ||
DECL_STATIC_DESTRUCTOR (decl))

90

return
true;

91

92

/* If the user told
us it is used, then it must be so.
*/

93

if (lookup_attribute
("used", DECL_ATTRIBUTES (decl)))

94

return
true;

95

96

/* ??? If the
assembler name is set by hand, it is possible to assemble

97

the name later
after finalizing the function and the fact is noticed

98

i
n assemble_name then. This is arguably a
bug.
*/

99

if (DECL_ASSEMBLER_NAME_SET_P (decl)

100

&& TREE_SYMBOL_REFERENCED
(DECL_ASSEMBLER_NAME (decl)))

101

return
true;

102

103

if (flag_unit_at_a_time

)

104

return
false;

105

106

/* If not doing unit
at a time, then we'll only defer this function

107

if its marked for
inlining. Otherwise we want to emit it now.

*/

108

109

/* "extern
inline" functions are never output locally.
*/

110

if (DECL_EXTERNAL (decl))

111

return
false;

112

/* We want to emit
COMDAT functions only when absolutely necessary.
*/

113

if (DECL_COMDAT (decl))

114

return
false;

115

if (!DECL_INLINE (decl)

116

||
(!node->local.disregard_inline_limits

117

/* When
declared inline, defer even the uninlinable functions.

118

This allows them to be eliminated when
unused.
*/

119

&& !DECL_DECLARED_INLINE_P
(decl)

120

&& (!node->local.inlinable ||
!cgraph_default_inline_p (node))))

121

return
true;

122

123

return
false;

124

}

If the declaration is visible, cgraph_mark_needed_node

needs set the
relevant cgraph_node as needed and mark its subnodes as reachable.

286

void

287

cgraph_mark_needed_node

(struct
cgraph_node *node)

in cgraph.c

288

{

289

node->needed = 1;

290

cgraph_mark_reachable_node
(node);

291

}

Slot local.finalized

is set as true in cgraph_finalize_function

already. In routine cgraph_node

,
line 123 through 128, field origin

refers to node of containing function;
field nested

refers to the node of contained function (i.e, function invoked within); and
field next_nested

refers to the node of sibling functions contained within the containing
function.

260

void

261

cgraph_mark_reachable_node

(struct
cgraph_node *node)

in cgraph.c

262

{

263

if (!node->reachable &&
node->local.finalized)

264

{

265

notice_global_symbol
(node->decl);

266

node->reachable = 1;

267

268

node->next_needed = cgraph_nodes_queue

;

269

cgraph_nodes_queue

= node;

270

271

/* At the moment
frontend automatically emits all nested functions.
*/

272

if (node->nested)

273

{

274

struct
cgraph_node *node2;

275

276

for
(node2 = node->nested; node2; node2 = node2->next_nested)

277

if (!node2->reachable)

278

cgraph_mark_reachable_node (node2);

279

}

280

}

281

}

All nodes of external visible functions should be chained tegother,
which is pointed by cgraph_nodes_queue

.

Back cgraph_finalize_function

, if it is not a
nested function (inline function defined within another function or class context),
cgraph_assemble_pending_functions

just returns false, if flag_unit_at_a_time

is
true, to trigger garbage collection.