Studying note of GCC-3.4.6 source (175)

5.13.5.3.2.

Optimization based on cgraph

Back finish_file

from cgraph_finalize_compilation_unit

,
at that time global variables and reachable static variables have assembler
code output, and functions needed are also built into cgraph map, in which
relationship of caller and callee is clear. Following, in cgraph_optimize

, it will do
optimization according to this cgraph map and output assembler code for the
function.

1579

void

1580

cgraph_optimize

(void)

in cgraphunit.c

1581

{

1582

if (!flag_unit_at_a_time

)

1583

return
;

1584

timevar_push (TV_CGRAPHOPT);

1585

if (!quiet_flag

)

1586

fprintf (stderr

, "Performing
intraprocedural optimizations/n");

1587

1588

cgraph_mark_local_functions
();

1589

if (cgraph_dump_file

)

1590

{

1591

fprintf (cgraph_dump_file

, "Marked
");

1592

dump_cgraph (cgraph_dump_file

);

1593

}

1594

1595

cgraph_decide_inlining
();

1596

cgraph_global_info_ready

= true;

1597

if (cgraph_dump_file

)

1598

{

1599

fprintf (cgraph_dump_file

, "Optimized
");

1600

dump_cgraph (cgraph_dump_file

);

1601

}

1602

timevar_pop (TV_CGRAPHOPT);

1603

1604

/* Output
everything.
*/

1605

if (!quiet_flag

)

1606

fprintf (stderr

, "Assembling
functions:/n");

1607

cgraph_expand_all_functions
();

1608

if (cgraph_dump_file

)

1609

{

1610

fprintf (cgraph_dump_file

, "/nFinal
");

1611

dump_cgraph (cgraph_dump_file

);

1612

}

1613

}

See that it is a heavy optimization, which is done only the switch
is on.

5.13.5.3.2.1.

Mark local function

First mark local function. A local function is one whose calls can
occur only in the current compilation unit and all it's calls are explicit, so
we can change its calling convention.

1556

static
void

1557

cgraph_mark_local_functions

(void)

in cgraphunit.c

1558

{

1559

struct
cgraph_node *node;

1560

1561

if (cgraph_dump_file

)

1562

fprintf (cgraph_dump_file

, "/nMarking
local functions:");

1563

1564

/* Figure out
functions we want to assemble.
*
/

1565

for
(node = cgraph_nodes

;
node; node = node->next)

1566

{

1567

node->local.local = (!node->needed

1568

&& DECL_SAVED_TREE
(node->decl)

1569

&& !TREE_PUBLIC
(node->decl));

1570

if (cgraph_dump_file &&
node->local.local)

1571

fprintf (cgraph_dump_file

, " %s",
cgraph_node_name (node));

1572

}

1573

if (cgraph_dump_file

)

1574

fprintf (cgraph_dump_file

,
"/n/n");

1575

}

The function makes the right hand side of the assignment expression
at line 1567 is static function (TREE_PUBLIC is 0) that having address referred
(thus node->needed is 0).

5.13.5.3.2.2.

Determine inlinability

Before we have analyzed functions declared as inline, now we need
further decide if function inlinable in theory can be inlined really.

1233

static
void

1234

cgraph_decide_inlining

(void)

in cgraphunit.c

1235

{

1236

struct
cgraph_node
*node;

1237

int nnodes;

1238

struct
cgraph_node **order =

1239

xcalloc (cgraph_n_nodes

, sizeof
(struct
cgraph_node *));

1240

struct
cgraph_node **inlined =

1241

xcalloc (cgraph_n_nodes

, sizeof
(struct
cgraph_node *));

1242

struct
cgraph_node **inlined_callees =

1243

xcalloc (cgraph_n_nodes

, sizeof
(struct
cgraph_node *));

1244

int ninlined;

1245

int ninlined_callees;

1246

int old_insns = 0;

1247

int i, y;

1248

1249

for
(node = cgraph_nodes

;
node; node = node->next)

1250

initial_insns

+= node->local.self_insns;

1251

overall_insns

= initial_insns

;

1252

1253

nnodes = cgraph_postorder
(order);

1254

1255

if (cgraph_dump_file

)

1256

fprintf (cgraph_dump_file

,

1257

"/nDeciding on inlining.
Starting with %i insns./n",

1258

initial_insns);

1259

1260

for
(node = cgraph_nodes

;
node; node = node->next)

1261

node->aux = 0;

1262

1263

if (cgraph_dump_file

)

1264

fprintf (cgraph_dump_file

, "/nInlining
always_inline functions:/n");

1265

#ifdef
ENABLE_CHECKING

1266

for
(node = cgraph_nodes

;
node; node = node->next)

1267

if (node->aux || node->output)

1268

abort ();

1269

#endif

In previous, in cgraph_node, local.self_insns saves the estimated
instruction number of the function (not confined to inlined function), so at
line 1251, overall_insns

and initial_insns

get the total instruction number of this translation-unit.