/* Write and read the cgraph to the memory mapped representation of a
|
/* Write and read the cgraph to the memory mapped representation of a
|
.o file.
|
.o file.
|
|
|
Copyright 2009 Free Software Foundation, Inc.
|
Copyright 2009 Free Software Foundation, Inc.
|
Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
|
Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
GCC is free software; you can redistribute it and/or modify it under
|
the terms of the GNU General Public License as published by the Free
|
the terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3, or (at your option) any later
|
Software Foundation; either version 3, or (at your option) any later
|
version.
|
version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "expr.h"
|
#include "expr.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "params.h"
|
#include "params.h"
|
#include "input.h"
|
#include "input.h"
|
#include "varray.h"
|
#include "varray.h"
|
#include "hashtab.h"
|
#include "hashtab.h"
|
#include "langhooks.h"
|
#include "langhooks.h"
|
#include "basic-block.h"
|
#include "basic-block.h"
|
#include "tree-flow.h"
|
#include "tree-flow.h"
|
#include "cgraph.h"
|
#include "cgraph.h"
|
#include "function.h"
|
#include "function.h"
|
#include "ggc.h"
|
#include "ggc.h"
|
#include "diagnostic.h"
|
#include "diagnostic.h"
|
#include "except.h"
|
#include "except.h"
|
#include "vec.h"
|
#include "vec.h"
|
#include "timevar.h"
|
#include "timevar.h"
|
#include "output.h"
|
#include "output.h"
|
#include "pointer-set.h"
|
#include "pointer-set.h"
|
#include "lto-streamer.h"
|
#include "lto-streamer.h"
|
#include "gcov-io.h"
|
#include "gcov-io.h"
|
|
|
/* Create a new cgraph encoder. */
|
/* Create a new cgraph encoder. */
|
|
|
lto_cgraph_encoder_t
|
lto_cgraph_encoder_t
|
lto_cgraph_encoder_new (void)
|
lto_cgraph_encoder_new (void)
|
{
|
{
|
lto_cgraph_encoder_t encoder = XCNEW (struct lto_cgraph_encoder_d);
|
lto_cgraph_encoder_t encoder = XCNEW (struct lto_cgraph_encoder_d);
|
encoder->map = pointer_map_create ();
|
encoder->map = pointer_map_create ();
|
encoder->nodes = NULL;
|
encoder->nodes = NULL;
|
return encoder;
|
return encoder;
|
}
|
}
|
|
|
|
|
/* Delete ENCODER and its components. */
|
/* Delete ENCODER and its components. */
|
|
|
void
|
void
|
lto_cgraph_encoder_delete (lto_cgraph_encoder_t encoder)
|
lto_cgraph_encoder_delete (lto_cgraph_encoder_t encoder)
|
{
|
{
|
VEC_free (cgraph_node_ptr, heap, encoder->nodes);
|
VEC_free (cgraph_node_ptr, heap, encoder->nodes);
|
pointer_map_destroy (encoder->map);
|
pointer_map_destroy (encoder->map);
|
free (encoder);
|
free (encoder);
|
}
|
}
|
|
|
|
|
/* Return the existing reference number of NODE in the cgraph encoder in
|
/* Return the existing reference number of NODE in the cgraph encoder in
|
output block OB. Assign a new reference if this is the first time
|
output block OB. Assign a new reference if this is the first time
|
NODE is encoded. */
|
NODE is encoded. */
|
|
|
int
|
int
|
lto_cgraph_encoder_encode (lto_cgraph_encoder_t encoder,
|
lto_cgraph_encoder_encode (lto_cgraph_encoder_t encoder,
|
struct cgraph_node *node)
|
struct cgraph_node *node)
|
{
|
{
|
int ref;
|
int ref;
|
void **slot;
|
void **slot;
|
|
|
slot = pointer_map_contains (encoder->map, node);
|
slot = pointer_map_contains (encoder->map, node);
|
if (!slot)
|
if (!slot)
|
{
|
{
|
ref = VEC_length (cgraph_node_ptr, encoder->nodes);
|
ref = VEC_length (cgraph_node_ptr, encoder->nodes);
|
slot = pointer_map_insert (encoder->map, node);
|
slot = pointer_map_insert (encoder->map, node);
|
*slot = (void *) (intptr_t) ref;
|
*slot = (void *) (intptr_t) ref;
|
VEC_safe_push (cgraph_node_ptr, heap, encoder->nodes, node);
|
VEC_safe_push (cgraph_node_ptr, heap, encoder->nodes, node);
|
}
|
}
|
else
|
else
|
ref = (int) (intptr_t) *slot;
|
ref = (int) (intptr_t) *slot;
|
|
|
return ref;
|
return ref;
|
}
|
}
|
|
|
|
|
/* Look up NODE in encoder. Return NODE's reference if it has been encoded
|
/* Look up NODE in encoder. Return NODE's reference if it has been encoded
|
or LCC_NOT_FOUND if it is not there. */
|
or LCC_NOT_FOUND if it is not there. */
|
|
|
int
|
int
|
lto_cgraph_encoder_lookup (lto_cgraph_encoder_t encoder,
|
lto_cgraph_encoder_lookup (lto_cgraph_encoder_t encoder,
|
struct cgraph_node *node)
|
struct cgraph_node *node)
|
{
|
{
|
void **slot = pointer_map_contains (encoder->map, node);
|
void **slot = pointer_map_contains (encoder->map, node);
|
return (slot ? (int) (intptr_t) *slot : LCC_NOT_FOUND);
|
return (slot ? (int) (intptr_t) *slot : LCC_NOT_FOUND);
|
}
|
}
|
|
|
|
|
/* Return the cgraph node corresponding to REF using ENCODER. */
|
/* Return the cgraph node corresponding to REF using ENCODER. */
|
|
|
struct cgraph_node *
|
struct cgraph_node *
|
lto_cgraph_encoder_deref (lto_cgraph_encoder_t encoder, int ref)
|
lto_cgraph_encoder_deref (lto_cgraph_encoder_t encoder, int ref)
|
{
|
{
|
if (ref == LCC_NOT_FOUND)
|
if (ref == LCC_NOT_FOUND)
|
return NULL;
|
return NULL;
|
|
|
return VEC_index (cgraph_node_ptr, encoder->nodes, ref);
|
return VEC_index (cgraph_node_ptr, encoder->nodes, ref);
|
}
|
}
|
|
|
|
|
/* Return number of encoded nodes in ENCODER. */
|
/* Return number of encoded nodes in ENCODER. */
|
|
|
static int
|
static int
|
lto_cgraph_encoder_size (lto_cgraph_encoder_t encoder)
|
lto_cgraph_encoder_size (lto_cgraph_encoder_t encoder)
|
{
|
{
|
return VEC_length (cgraph_node_ptr, encoder->nodes);
|
return VEC_length (cgraph_node_ptr, encoder->nodes);
|
}
|
}
|
|
|
|
|
/* Output the cgraph EDGE to OB using ENCODER. */
|
/* Output the cgraph EDGE to OB using ENCODER. */
|
|
|
static void
|
static void
|
lto_output_edge (struct lto_simple_output_block *ob, struct cgraph_edge *edge,
|
lto_output_edge (struct lto_simple_output_block *ob, struct cgraph_edge *edge,
|
lto_cgraph_encoder_t encoder)
|
lto_cgraph_encoder_t encoder)
|
{
|
{
|
unsigned int uid;
|
unsigned int uid;
|
intptr_t ref;
|
intptr_t ref;
|
struct bitpack_d *bp;
|
struct bitpack_d *bp;
|
|
|
lto_output_uleb128_stream (ob->main_stream, LTO_cgraph_edge);
|
lto_output_uleb128_stream (ob->main_stream, LTO_cgraph_edge);
|
|
|
ref = lto_cgraph_encoder_lookup (encoder, edge->caller);
|
ref = lto_cgraph_encoder_lookup (encoder, edge->caller);
|
gcc_assert (ref != LCC_NOT_FOUND);
|
gcc_assert (ref != LCC_NOT_FOUND);
|
lto_output_sleb128_stream (ob->main_stream, ref);
|
lto_output_sleb128_stream (ob->main_stream, ref);
|
|
|
ref = lto_cgraph_encoder_lookup (encoder, edge->callee);
|
ref = lto_cgraph_encoder_lookup (encoder, edge->callee);
|
gcc_assert (ref != LCC_NOT_FOUND);
|
gcc_assert (ref != LCC_NOT_FOUND);
|
lto_output_sleb128_stream (ob->main_stream, ref);
|
lto_output_sleb128_stream (ob->main_stream, ref);
|
|
|
lto_output_sleb128_stream (ob->main_stream, edge->count);
|
lto_output_sleb128_stream (ob->main_stream, edge->count);
|
|
|
bp = bitpack_create ();
|
bp = bitpack_create ();
|
uid = flag_wpa ? edge->lto_stmt_uid : gimple_uid (edge->call_stmt);
|
uid = flag_wpa ? edge->lto_stmt_uid : gimple_uid (edge->call_stmt);
|
bp_pack_value (bp, uid, HOST_BITS_PER_INT);
|
bp_pack_value (bp, uid, HOST_BITS_PER_INT);
|
bp_pack_value (bp, edge->inline_failed, HOST_BITS_PER_INT);
|
bp_pack_value (bp, edge->inline_failed, HOST_BITS_PER_INT);
|
bp_pack_value (bp, edge->frequency, HOST_BITS_PER_INT);
|
bp_pack_value (bp, edge->frequency, HOST_BITS_PER_INT);
|
bp_pack_value (bp, edge->loop_nest, 30);
|
bp_pack_value (bp, edge->loop_nest, 30);
|
bp_pack_value (bp, edge->indirect_call, 1);
|
bp_pack_value (bp, edge->indirect_call, 1);
|
bp_pack_value (bp, edge->call_stmt_cannot_inline_p, 1);
|
bp_pack_value (bp, edge->call_stmt_cannot_inline_p, 1);
|
bp_pack_value (bp, edge->can_throw_external, 1);
|
bp_pack_value (bp, edge->can_throw_external, 1);
|
lto_output_bitpack (ob->main_stream, bp);
|
lto_output_bitpack (ob->main_stream, bp);
|
bitpack_delete (bp);
|
bitpack_delete (bp);
|
}
|
}
|
|
|
|
|
/* Output the cgraph NODE to OB. ENCODER is used to find the
|
/* Output the cgraph NODE to OB. ENCODER is used to find the
|
reference number of NODE->inlined_to. SET is the set of nodes we
|
reference number of NODE->inlined_to. SET is the set of nodes we
|
are writing to the current file. If NODE is not in SET, then NODE
|
are writing to the current file. If NODE is not in SET, then NODE
|
is a boundary of a cgraph_node_set and we pretend NODE just has a
|
is a boundary of a cgraph_node_set and we pretend NODE just has a
|
decl and no callees. WRITTEN_DECLS is the set of FUNCTION_DECLs
|
decl and no callees. WRITTEN_DECLS is the set of FUNCTION_DECLs
|
that have had their callgraph node written so far. This is used to
|
that have had their callgraph node written so far. This is used to
|
determine if NODE is a clone of a previously written node. */
|
determine if NODE is a clone of a previously written node. */
|
|
|
static void
|
static void
|
lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
|
lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
|
lto_cgraph_encoder_t encoder, cgraph_node_set set,
|
lto_cgraph_encoder_t encoder, cgraph_node_set set,
|
bitmap written_decls)
|
bitmap written_decls)
|
{
|
{
|
unsigned int tag;
|
unsigned int tag;
|
struct bitpack_d *bp;
|
struct bitpack_d *bp;
|
unsigned local, externally_visible, inlinable, analyzed;
|
unsigned local, externally_visible, inlinable, analyzed;
|
bool boundary_p, wrote_decl_p;
|
bool boundary_p, wrote_decl_p;
|
intptr_t ref;
|
intptr_t ref;
|
|
|
boundary_p = !cgraph_node_in_set_p (node, set);
|
boundary_p = !cgraph_node_in_set_p (node, set);
|
wrote_decl_p = bitmap_bit_p (written_decls, DECL_UID (node->decl));
|
wrote_decl_p = bitmap_bit_p (written_decls, DECL_UID (node->decl));
|
|
|
switch (cgraph_function_body_availability (node))
|
switch (cgraph_function_body_availability (node))
|
{
|
{
|
case AVAIL_NOT_AVAILABLE:
|
case AVAIL_NOT_AVAILABLE:
|
tag = LTO_cgraph_unavail_node;
|
tag = LTO_cgraph_unavail_node;
|
break;
|
break;
|
|
|
case AVAIL_AVAILABLE:
|
case AVAIL_AVAILABLE:
|
case AVAIL_LOCAL:
|
case AVAIL_LOCAL:
|
tag = LTO_cgraph_avail_node;
|
tag = LTO_cgraph_avail_node;
|
break;
|
break;
|
|
|
case AVAIL_OVERWRITABLE:
|
case AVAIL_OVERWRITABLE:
|
tag = LTO_cgraph_overwritable_node;
|
tag = LTO_cgraph_overwritable_node;
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
if (boundary_p)
|
if (boundary_p)
|
tag = LTO_cgraph_unavail_node;
|
tag = LTO_cgraph_unavail_node;
|
|
|
lto_output_uleb128_stream (ob->main_stream, tag);
|
lto_output_uleb128_stream (ob->main_stream, tag);
|
|
|
local = node->local.local;
|
local = node->local.local;
|
externally_visible = node->local.externally_visible;
|
externally_visible = node->local.externally_visible;
|
inlinable = node->local.inlinable;
|
inlinable = node->local.inlinable;
|
analyzed = node->analyzed;
|
analyzed = node->analyzed;
|
|
|
/* In WPA mode, we only output part of the call-graph. Also, we
|
/* In WPA mode, we only output part of the call-graph. Also, we
|
fake cgraph node attributes. There are two cases that we care.
|
fake cgraph node attributes. There are two cases that we care.
|
|
|
Boundary nodes: There are nodes that are not part of SET but are
|
Boundary nodes: There are nodes that are not part of SET but are
|
called from within SET. We artificially make them look like
|
called from within SET. We artificially make them look like
|
externally visible nodes with no function body.
|
externally visible nodes with no function body.
|
|
|
Cherry-picked nodes: These are nodes we pulled from other
|
Cherry-picked nodes: These are nodes we pulled from other
|
translation units into SET during IPA-inlining. We make them as
|
translation units into SET during IPA-inlining. We make them as
|
local static nodes to prevent clashes with other local statics. */
|
local static nodes to prevent clashes with other local statics. */
|
if (boundary_p)
|
if (boundary_p)
|
{
|
{
|
/* Inline clones can not be part of boundary. */
|
/* Inline clones can not be part of boundary. */
|
gcc_assert (!node->global.inlined_to);
|
gcc_assert (!node->global.inlined_to);
|
local = 0;
|
local = 0;
|
externally_visible = 1;
|
externally_visible = 1;
|
inlinable = 0;
|
inlinable = 0;
|
analyzed = 0;
|
analyzed = 0;
|
}
|
}
|
else if (lto_forced_extern_inline_p (node->decl))
|
else if (lto_forced_extern_inline_p (node->decl))
|
{
|
{
|
local = 1;
|
local = 1;
|
externally_visible = 0;
|
externally_visible = 0;
|
inlinable = 1;
|
inlinable = 1;
|
}
|
}
|
|
|
lto_output_uleb128_stream (ob->main_stream, wrote_decl_p);
|
lto_output_uleb128_stream (ob->main_stream, wrote_decl_p);
|
|
|
if (!wrote_decl_p)
|
if (!wrote_decl_p)
|
bitmap_set_bit (written_decls, DECL_UID (node->decl));
|
bitmap_set_bit (written_decls, DECL_UID (node->decl));
|
|
|
lto_output_fn_decl_index (ob->decl_state, ob->main_stream, node->decl);
|
lto_output_fn_decl_index (ob->decl_state, ob->main_stream, node->decl);
|
lto_output_sleb128_stream (ob->main_stream, node->count);
|
lto_output_sleb128_stream (ob->main_stream, node->count);
|
|
|
bp = bitpack_create ();
|
bp = bitpack_create ();
|
bp_pack_value (bp, local, 1);
|
bp_pack_value (bp, local, 1);
|
bp_pack_value (bp, externally_visible, 1);
|
bp_pack_value (bp, externally_visible, 1);
|
bp_pack_value (bp, node->local.finalized, 1);
|
bp_pack_value (bp, node->local.finalized, 1);
|
bp_pack_value (bp, inlinable, 1);
|
bp_pack_value (bp, inlinable, 1);
|
bp_pack_value (bp, node->local.disregard_inline_limits, 1);
|
bp_pack_value (bp, node->local.disregard_inline_limits, 1);
|
bp_pack_value (bp, node->local.redefined_extern_inline, 1);
|
bp_pack_value (bp, node->local.redefined_extern_inline, 1);
|
bp_pack_value (bp, node->local.for_functions_valid, 1);
|
bp_pack_value (bp, node->local.for_functions_valid, 1);
|
bp_pack_value (bp, node->local.vtable_method, 1);
|
bp_pack_value (bp, node->local.vtable_method, 1);
|
bp_pack_value (bp, node->needed, 1);
|
bp_pack_value (bp, node->needed, 1);
|
bp_pack_value (bp, node->address_taken, 1);
|
bp_pack_value (bp, node->address_taken, 1);
|
bp_pack_value (bp, node->abstract_and_needed, 1);
|
bp_pack_value (bp, node->abstract_and_needed, 1);
|
bp_pack_value (bp, node->reachable, 1);
|
bp_pack_value (bp, node->reachable, 1);
|
bp_pack_value (bp, node->lowered, 1);
|
bp_pack_value (bp, node->lowered, 1);
|
bp_pack_value (bp, analyzed, 1);
|
bp_pack_value (bp, analyzed, 1);
|
bp_pack_value (bp, node->process, 1);
|
bp_pack_value (bp, node->process, 1);
|
bp_pack_value (bp, node->alias, 1);
|
bp_pack_value (bp, node->alias, 1);
|
bp_pack_value (bp, node->finalized_by_frontend, 1);
|
bp_pack_value (bp, node->finalized_by_frontend, 1);
|
lto_output_bitpack (ob->main_stream, bp);
|
lto_output_bitpack (ob->main_stream, bp);
|
bitpack_delete (bp);
|
bitpack_delete (bp);
|
|
|
if (tag != LTO_cgraph_unavail_node)
|
if (tag != LTO_cgraph_unavail_node)
|
{
|
{
|
lto_output_sleb128_stream (ob->main_stream,
|
lto_output_sleb128_stream (ob->main_stream,
|
node->local.inline_summary.estimated_self_stack_size);
|
node->local.inline_summary.estimated_self_stack_size);
|
lto_output_sleb128_stream (ob->main_stream,
|
lto_output_sleb128_stream (ob->main_stream,
|
node->local.inline_summary.self_size);
|
node->local.inline_summary.self_size);
|
lto_output_sleb128_stream (ob->main_stream,
|
lto_output_sleb128_stream (ob->main_stream,
|
node->local.inline_summary.size_inlining_benefit);
|
node->local.inline_summary.size_inlining_benefit);
|
lto_output_sleb128_stream (ob->main_stream,
|
lto_output_sleb128_stream (ob->main_stream,
|
node->local.inline_summary.self_time);
|
node->local.inline_summary.self_time);
|
lto_output_sleb128_stream (ob->main_stream,
|
lto_output_sleb128_stream (ob->main_stream,
|
node->local.inline_summary.time_inlining_benefit);
|
node->local.inline_summary.time_inlining_benefit);
|
}
|
}
|
|
|
/* FIXME lto: Outputting global info is not neccesary until after
|
/* FIXME lto: Outputting global info is not neccesary until after
|
inliner was run. Global structure holds results of propagation
|
inliner was run. Global structure holds results of propagation
|
done by inliner. */
|
done by inliner. */
|
lto_output_sleb128_stream (ob->main_stream,
|
lto_output_sleb128_stream (ob->main_stream,
|
node->global.estimated_stack_size);
|
node->global.estimated_stack_size);
|
lto_output_sleb128_stream (ob->main_stream,
|
lto_output_sleb128_stream (ob->main_stream,
|
node->global.stack_frame_offset);
|
node->global.stack_frame_offset);
|
if (node->global.inlined_to && !boundary_p)
|
if (node->global.inlined_to && !boundary_p)
|
{
|
{
|
ref = lto_cgraph_encoder_lookup (encoder, node->global.inlined_to);
|
ref = lto_cgraph_encoder_lookup (encoder, node->global.inlined_to);
|
gcc_assert (ref != LCC_NOT_FOUND);
|
gcc_assert (ref != LCC_NOT_FOUND);
|
}
|
}
|
else
|
else
|
ref = LCC_NOT_FOUND;
|
ref = LCC_NOT_FOUND;
|
lto_output_sleb128_stream (ob->main_stream, ref);
|
lto_output_sleb128_stream (ob->main_stream, ref);
|
|
|
lto_output_sleb128_stream (ob->main_stream, node->global.time);
|
lto_output_sleb128_stream (ob->main_stream, node->global.time);
|
lto_output_sleb128_stream (ob->main_stream, node->global.size);
|
lto_output_sleb128_stream (ob->main_stream, node->global.size);
|
lto_output_sleb128_stream (ob->main_stream,
|
lto_output_sleb128_stream (ob->main_stream,
|
node->global.estimated_growth);
|
node->global.estimated_growth);
|
lto_output_uleb128_stream (ob->main_stream, node->global.inlined);
|
lto_output_uleb128_stream (ob->main_stream, node->global.inlined);
|
if (node->same_comdat_group)
|
if (node->same_comdat_group)
|
{
|
{
|
ref = lto_cgraph_encoder_lookup (encoder, node->same_comdat_group);
|
ref = lto_cgraph_encoder_lookup (encoder, node->same_comdat_group);
|
gcc_assert (ref != LCC_NOT_FOUND);
|
gcc_assert (ref != LCC_NOT_FOUND);
|
}
|
}
|
else
|
else
|
ref = LCC_NOT_FOUND;
|
ref = LCC_NOT_FOUND;
|
lto_output_sleb128_stream (ob->main_stream, ref);
|
lto_output_sleb128_stream (ob->main_stream, ref);
|
|
|
if (node->same_body)
|
if (node->same_body)
|
{
|
{
|
struct cgraph_node *alias;
|
struct cgraph_node *alias;
|
unsigned long alias_count = 1;
|
unsigned long alias_count = 1;
|
for (alias = node->same_body; alias->next; alias = alias->next)
|
for (alias = node->same_body; alias->next; alias = alias->next)
|
alias_count++;
|
alias_count++;
|
lto_output_uleb128_stream (ob->main_stream, alias_count);
|
lto_output_uleb128_stream (ob->main_stream, alias_count);
|
do
|
do
|
{
|
{
|
lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
|
lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
|
alias->decl);
|
alias->decl);
|
if (alias->thunk.thunk_p)
|
if (alias->thunk.thunk_p)
|
{
|
{
|
lto_output_uleb128_stream
|
lto_output_uleb128_stream
|
(ob->main_stream,
|
(ob->main_stream,
|
1 + (alias->thunk.this_adjusting != 0) * 2
|
1 + (alias->thunk.this_adjusting != 0) * 2
|
+ (alias->thunk.virtual_offset_p != 0) * 4);
|
+ (alias->thunk.virtual_offset_p != 0) * 4);
|
lto_output_uleb128_stream (ob->main_stream,
|
lto_output_uleb128_stream (ob->main_stream,
|
alias->thunk.fixed_offset);
|
alias->thunk.fixed_offset);
|
lto_output_uleb128_stream (ob->main_stream,
|
lto_output_uleb128_stream (ob->main_stream,
|
alias->thunk.virtual_value);
|
alias->thunk.virtual_value);
|
lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
|
lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
|
alias->thunk.alias);
|
alias->thunk.alias);
|
}
|
}
|
else
|
else
|
{
|
{
|
lto_output_uleb128_stream (ob->main_stream, 0);
|
lto_output_uleb128_stream (ob->main_stream, 0);
|
lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
|
lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
|
alias->thunk.alias);
|
alias->thunk.alias);
|
}
|
}
|
alias = alias->previous;
|
alias = alias->previous;
|
}
|
}
|
while (alias);
|
while (alias);
|
}
|
}
|
else
|
else
|
lto_output_uleb128_stream (ob->main_stream, 0);
|
lto_output_uleb128_stream (ob->main_stream, 0);
|
}
|
}
|
|
|
/* Stream out profile_summary to OB. */
|
/* Stream out profile_summary to OB. */
|
|
|
static void
|
static void
|
output_profile_summary (struct lto_simple_output_block *ob)
|
output_profile_summary (struct lto_simple_output_block *ob)
|
{
|
{
|
if (profile_info)
|
if (profile_info)
|
{
|
{
|
/* We do not output num, it is not terribly useful. */
|
/* We do not output num, it is not terribly useful. */
|
gcc_assert (profile_info->runs);
|
gcc_assert (profile_info->runs);
|
lto_output_uleb128_stream (ob->main_stream, profile_info->runs);
|
lto_output_uleb128_stream (ob->main_stream, profile_info->runs);
|
lto_output_sleb128_stream (ob->main_stream, profile_info->sum_all);
|
lto_output_sleb128_stream (ob->main_stream, profile_info->sum_all);
|
lto_output_sleb128_stream (ob->main_stream, profile_info->run_max);
|
lto_output_sleb128_stream (ob->main_stream, profile_info->run_max);
|
lto_output_sleb128_stream (ob->main_stream, profile_info->sum_max);
|
lto_output_sleb128_stream (ob->main_stream, profile_info->sum_max);
|
}
|
}
|
else
|
else
|
lto_output_uleb128_stream (ob->main_stream, 0);
|
lto_output_uleb128_stream (ob->main_stream, 0);
|
}
|
}
|
|
|
|
|
/* Output the part of the cgraph in SET. */
|
/* Output the part of the cgraph in SET. */
|
|
|
void
|
void
|
output_cgraph (cgraph_node_set set)
|
output_cgraph (cgraph_node_set set)
|
{
|
{
|
struct cgraph_node *node;
|
struct cgraph_node *node;
|
struct lto_simple_output_block *ob;
|
struct lto_simple_output_block *ob;
|
cgraph_node_set_iterator csi;
|
cgraph_node_set_iterator csi;
|
struct cgraph_edge *edge;
|
struct cgraph_edge *edge;
|
int i, n_nodes;
|
int i, n_nodes;
|
bitmap written_decls;
|
bitmap written_decls;
|
lto_cgraph_encoder_t encoder;
|
lto_cgraph_encoder_t encoder;
|
struct cgraph_asm_node *can;
|
struct cgraph_asm_node *can;
|
|
|
ob = lto_create_simple_output_block (LTO_section_cgraph);
|
ob = lto_create_simple_output_block (LTO_section_cgraph);
|
|
|
output_profile_summary (ob);
|
output_profile_summary (ob);
|
|
|
/* An encoder for cgraph nodes should have been created by
|
/* An encoder for cgraph nodes should have been created by
|
ipa_write_summaries_1. */
|
ipa_write_summaries_1. */
|
gcc_assert (ob->decl_state->cgraph_node_encoder);
|
gcc_assert (ob->decl_state->cgraph_node_encoder);
|
encoder = ob->decl_state->cgraph_node_encoder;
|
encoder = ob->decl_state->cgraph_node_encoder;
|
|
|
/* The FUNCTION_DECLs for which we have written a node. The first
|
/* The FUNCTION_DECLs for which we have written a node. The first
|
node found is written as the "original" node, the remaining nodes
|
node found is written as the "original" node, the remaining nodes
|
are considered its clones. */
|
are considered its clones. */
|
written_decls = lto_bitmap_alloc ();
|
written_decls = lto_bitmap_alloc ();
|
|
|
/* Go over all the nodes in SET and assign references. */
|
/* Go over all the nodes in SET and assign references. */
|
for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
|
for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
|
{
|
{
|
node = csi_node (csi);
|
node = csi_node (csi);
|
lto_cgraph_encoder_encode (encoder, node);
|
lto_cgraph_encoder_encode (encoder, node);
|
}
|
}
|
|
|
/* Go over all the nodes again to include callees that are not in
|
/* Go over all the nodes again to include callees that are not in
|
SET. */
|
SET. */
|
for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
|
for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
|
{
|
{
|
node = csi_node (csi);
|
node = csi_node (csi);
|
for (edge = node->callees; edge; edge = edge->next_callee)
|
for (edge = node->callees; edge; edge = edge->next_callee)
|
{
|
{
|
struct cgraph_node *callee = edge->callee;
|
struct cgraph_node *callee = edge->callee;
|
if (!cgraph_node_in_set_p (callee, set))
|
if (!cgraph_node_in_set_p (callee, set))
|
{
|
{
|
/* We should have moved all the inlines. */
|
/* We should have moved all the inlines. */
|
gcc_assert (!callee->global.inlined_to);
|
gcc_assert (!callee->global.inlined_to);
|
lto_cgraph_encoder_encode (encoder, callee);
|
lto_cgraph_encoder_encode (encoder, callee);
|
/* Also with each included function include all other functions
|
/* Also with each included function include all other functions
|
in the same comdat group. */
|
in the same comdat group. */
|
if (callee->same_comdat_group)
|
if (callee->same_comdat_group)
|
{
|
{
|
struct cgraph_node *next;
|
struct cgraph_node *next;
|
for (next = callee->same_comdat_group;
|
for (next = callee->same_comdat_group;
|
next != callee;
|
next != callee;
|
next = next->same_comdat_group)
|
next = next->same_comdat_group)
|
if (!cgraph_node_in_set_p (next, set))
|
if (!cgraph_node_in_set_p (next, set))
|
lto_cgraph_encoder_encode (encoder, next);
|
lto_cgraph_encoder_encode (encoder, next);
|
}
|
}
|
}
|
}
|
}
|
}
|
/* Also with each included function include all other functions
|
/* Also with each included function include all other functions
|
in the same comdat group. */
|
in the same comdat group. */
|
if (node->same_comdat_group)
|
if (node->same_comdat_group)
|
{
|
{
|
struct cgraph_node *next;
|
struct cgraph_node *next;
|
for (next = node->same_comdat_group;
|
for (next = node->same_comdat_group;
|
next != node;
|
next != node;
|
next = next->same_comdat_group)
|
next = next->same_comdat_group)
|
if (!cgraph_node_in_set_p (next, set))
|
if (!cgraph_node_in_set_p (next, set))
|
lto_cgraph_encoder_encode (encoder, next);
|
lto_cgraph_encoder_encode (encoder, next);
|
}
|
}
|
}
|
}
|
|
|
/* Write out the nodes. */
|
/* Write out the nodes. */
|
n_nodes = lto_cgraph_encoder_size (encoder);
|
n_nodes = lto_cgraph_encoder_size (encoder);
|
for (i = 0; i < n_nodes; i++)
|
for (i = 0; i < n_nodes; i++)
|
{
|
{
|
node = lto_cgraph_encoder_deref (encoder, i);
|
node = lto_cgraph_encoder_deref (encoder, i);
|
lto_output_node (ob, node, encoder, set, written_decls);
|
lto_output_node (ob, node, encoder, set, written_decls);
|
}
|
}
|
|
|
lto_bitmap_free (written_decls);
|
lto_bitmap_free (written_decls);
|
|
|
/* Go over the nodes in SET again to write edges. */
|
/* Go over the nodes in SET again to write edges. */
|
for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
|
for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
|
{
|
{
|
node = csi_node (csi);
|
node = csi_node (csi);
|
if (node->callees)
|
if (node->callees)
|
{
|
{
|
/* Output edges in backward direction, so the reconstructed callgraph
|
/* Output edges in backward direction, so the reconstructed callgraph
|
match and it is easy to associate call sites in the IPA pass summaries. */
|
match and it is easy to associate call sites in the IPA pass summaries. */
|
edge = node->callees;
|
edge = node->callees;
|
while (edge->next_callee)
|
while (edge->next_callee)
|
edge = edge->next_callee;
|
edge = edge->next_callee;
|
for (; edge; edge = edge->prev_callee)
|
for (; edge; edge = edge->prev_callee)
|
lto_output_edge (ob, edge, encoder);
|
lto_output_edge (ob, edge, encoder);
|
}
|
}
|
}
|
}
|
|
|
lto_output_uleb128_stream (ob->main_stream, 0);
|
lto_output_uleb128_stream (ob->main_stream, 0);
|
|
|
/* Emit toplevel asms. */
|
/* Emit toplevel asms. */
|
for (can = cgraph_asm_nodes; can; can = can->next)
|
for (can = cgraph_asm_nodes; can; can = can->next)
|
{
|
{
|
int len = TREE_STRING_LENGTH (can->asm_str);
|
int len = TREE_STRING_LENGTH (can->asm_str);
|
lto_output_uleb128_stream (ob->main_stream, len);
|
lto_output_uleb128_stream (ob->main_stream, len);
|
for (i = 0; i < len; ++i)
|
for (i = 0; i < len; ++i)
|
lto_output_1_stream (ob->main_stream,
|
lto_output_1_stream (ob->main_stream,
|
TREE_STRING_POINTER (can->asm_str)[i]);
|
TREE_STRING_POINTER (can->asm_str)[i]);
|
}
|
}
|
|
|
lto_output_uleb128_stream (ob->main_stream, 0);
|
lto_output_uleb128_stream (ob->main_stream, 0);
|
|
|
lto_destroy_simple_output_block (ob);
|
lto_destroy_simple_output_block (ob);
|
}
|
}
|
|
|
|
|
/* Overwrite the information in NODE based on FILE_DATA, TAG, FLAGS,
|
/* Overwrite the information in NODE based on FILE_DATA, TAG, FLAGS,
|
STACK_SIZE, SELF_TIME and SELF_SIZE. This is called either to initialize
|
STACK_SIZE, SELF_TIME and SELF_SIZE. This is called either to initialize
|
NODE or to replace the values in it, for instance because the first
|
NODE or to replace the values in it, for instance because the first
|
time we saw it, the function body was not available but now it
|
time we saw it, the function body was not available but now it
|
is. BP is a bitpack with all the bitflags for NODE read from the
|
is. BP is a bitpack with all the bitflags for NODE read from the
|
stream. */
|
stream. */
|
|
|
static void
|
static void
|
input_overwrite_node (struct lto_file_decl_data *file_data,
|
input_overwrite_node (struct lto_file_decl_data *file_data,
|
struct cgraph_node *node,
|
struct cgraph_node *node,
|
enum LTO_cgraph_tags tag,
|
enum LTO_cgraph_tags tag,
|
struct bitpack_d *bp,
|
struct bitpack_d *bp,
|
unsigned int stack_size,
|
unsigned int stack_size,
|
unsigned int self_time,
|
unsigned int self_time,
|
unsigned int time_inlining_benefit,
|
unsigned int time_inlining_benefit,
|
unsigned int self_size,
|
unsigned int self_size,
|
unsigned int size_inlining_benefit)
|
unsigned int size_inlining_benefit)
|
{
|
{
|
node->aux = (void *) tag;
|
node->aux = (void *) tag;
|
node->local.inline_summary.estimated_self_stack_size = stack_size;
|
node->local.inline_summary.estimated_self_stack_size = stack_size;
|
node->local.inline_summary.self_time = self_time;
|
node->local.inline_summary.self_time = self_time;
|
node->local.inline_summary.time_inlining_benefit = time_inlining_benefit;
|
node->local.inline_summary.time_inlining_benefit = time_inlining_benefit;
|
node->local.inline_summary.self_size = self_size;
|
node->local.inline_summary.self_size = self_size;
|
node->local.inline_summary.size_inlining_benefit = size_inlining_benefit;
|
node->local.inline_summary.size_inlining_benefit = size_inlining_benefit;
|
node->global.time = self_time;
|
node->global.time = self_time;
|
node->global.size = self_size;
|
node->global.size = self_size;
|
node->local.lto_file_data = file_data;
|
node->local.lto_file_data = file_data;
|
|
|
node->local.local = bp_unpack_value (bp, 1);
|
node->local.local = bp_unpack_value (bp, 1);
|
node->local.externally_visible = bp_unpack_value (bp, 1);
|
node->local.externally_visible = bp_unpack_value (bp, 1);
|
node->local.finalized = bp_unpack_value (bp, 1);
|
node->local.finalized = bp_unpack_value (bp, 1);
|
node->local.inlinable = bp_unpack_value (bp, 1);
|
node->local.inlinable = bp_unpack_value (bp, 1);
|
node->local.disregard_inline_limits = bp_unpack_value (bp, 1);
|
node->local.disregard_inline_limits = bp_unpack_value (bp, 1);
|
node->local.redefined_extern_inline = bp_unpack_value (bp, 1);
|
node->local.redefined_extern_inline = bp_unpack_value (bp, 1);
|
node->local.for_functions_valid = bp_unpack_value (bp, 1);
|
node->local.for_functions_valid = bp_unpack_value (bp, 1);
|
node->local.vtable_method = bp_unpack_value (bp, 1);
|
node->local.vtable_method = bp_unpack_value (bp, 1);
|
node->needed = bp_unpack_value (bp, 1);
|
node->needed = bp_unpack_value (bp, 1);
|
node->address_taken = bp_unpack_value (bp, 1);
|
node->address_taken = bp_unpack_value (bp, 1);
|
node->abstract_and_needed = bp_unpack_value (bp, 1);
|
node->abstract_and_needed = bp_unpack_value (bp, 1);
|
node->reachable = bp_unpack_value (bp, 1);
|
node->reachable = bp_unpack_value (bp, 1);
|
node->lowered = bp_unpack_value (bp, 1);
|
node->lowered = bp_unpack_value (bp, 1);
|
node->analyzed = bp_unpack_value (bp, 1);
|
node->analyzed = bp_unpack_value (bp, 1);
|
node->process = bp_unpack_value (bp, 1);
|
node->process = bp_unpack_value (bp, 1);
|
node->alias = bp_unpack_value (bp, 1);
|
node->alias = bp_unpack_value (bp, 1);
|
node->finalized_by_frontend = bp_unpack_value (bp, 1);
|
node->finalized_by_frontend = bp_unpack_value (bp, 1);
|
}
|
}
|
|
|
|
|
/* Read a node from input_block IB. TAG is the node's tag just read.
|
/* Read a node from input_block IB. TAG is the node's tag just read.
|
Return the node read or overwriten. */
|
Return the node read or overwriten. */
|
|
|
static struct cgraph_node *
|
static struct cgraph_node *
|
input_node (struct lto_file_decl_data *file_data,
|
input_node (struct lto_file_decl_data *file_data,
|
struct lto_input_block *ib,
|
struct lto_input_block *ib,
|
enum LTO_cgraph_tags tag)
|
enum LTO_cgraph_tags tag)
|
{
|
{
|
tree fn_decl;
|
tree fn_decl;
|
struct cgraph_node *node;
|
struct cgraph_node *node;
|
struct bitpack_d *bp;
|
struct bitpack_d *bp;
|
int stack_size = 0;
|
int stack_size = 0;
|
unsigned decl_index;
|
unsigned decl_index;
|
bool clone_p;
|
bool clone_p;
|
int estimated_stack_size = 0;
|
int estimated_stack_size = 0;
|
int stack_frame_offset = 0;
|
int stack_frame_offset = 0;
|
int ref = LCC_NOT_FOUND, ref2 = LCC_NOT_FOUND;
|
int ref = LCC_NOT_FOUND, ref2 = LCC_NOT_FOUND;
|
int estimated_growth = 0;
|
int estimated_growth = 0;
|
int time = 0;
|
int time = 0;
|
int size = 0;
|
int size = 0;
|
int self_time = 0;
|
int self_time = 0;
|
int self_size = 0;
|
int self_size = 0;
|
int time_inlining_benefit = 0;
|
int time_inlining_benefit = 0;
|
int size_inlining_benefit = 0;
|
int size_inlining_benefit = 0;
|
unsigned long same_body_count = 0;
|
unsigned long same_body_count = 0;
|
bool inlined = false;
|
bool inlined = false;
|
|
|
clone_p = (lto_input_uleb128 (ib) != 0);
|
clone_p = (lto_input_uleb128 (ib) != 0);
|
|
|
decl_index = lto_input_uleb128 (ib);
|
decl_index = lto_input_uleb128 (ib);
|
fn_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
|
fn_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
|
|
|
if (clone_p)
|
if (clone_p)
|
node = cgraph_clone_node (cgraph_node (fn_decl), 0,
|
node = cgraph_clone_node (cgraph_node (fn_decl), 0,
|
CGRAPH_FREQ_BASE, 0, false, NULL);
|
CGRAPH_FREQ_BASE, 0, false, NULL);
|
|
|
else
|
else
|
node = cgraph_node (fn_decl);
|
node = cgraph_node (fn_decl);
|
|
|
node->count = lto_input_sleb128 (ib);
|
node->count = lto_input_sleb128 (ib);
|
bp = lto_input_bitpack (ib);
|
bp = lto_input_bitpack (ib);
|
|
|
if (tag != LTO_cgraph_unavail_node)
|
if (tag != LTO_cgraph_unavail_node)
|
{
|
{
|
stack_size = lto_input_sleb128 (ib);
|
stack_size = lto_input_sleb128 (ib);
|
self_size = lto_input_sleb128 (ib);
|
self_size = lto_input_sleb128 (ib);
|
size_inlining_benefit = lto_input_sleb128 (ib);
|
size_inlining_benefit = lto_input_sleb128 (ib);
|
self_time = lto_input_sleb128 (ib);
|
self_time = lto_input_sleb128 (ib);
|
time_inlining_benefit = lto_input_sleb128 (ib);
|
time_inlining_benefit = lto_input_sleb128 (ib);
|
}
|
}
|
|
|
estimated_stack_size = lto_input_sleb128 (ib);
|
estimated_stack_size = lto_input_sleb128 (ib);
|
stack_frame_offset = lto_input_sleb128 (ib);
|
stack_frame_offset = lto_input_sleb128 (ib);
|
ref = lto_input_sleb128 (ib);
|
ref = lto_input_sleb128 (ib);
|
time = lto_input_sleb128 (ib);
|
time = lto_input_sleb128 (ib);
|
size = lto_input_sleb128 (ib);
|
size = lto_input_sleb128 (ib);
|
estimated_growth = lto_input_sleb128 (ib);
|
estimated_growth = lto_input_sleb128 (ib);
|
inlined = lto_input_uleb128 (ib);
|
inlined = lto_input_uleb128 (ib);
|
ref2 = lto_input_sleb128 (ib);
|
ref2 = lto_input_sleb128 (ib);
|
same_body_count = lto_input_uleb128 (ib);
|
same_body_count = lto_input_uleb128 (ib);
|
|
|
/* Make sure that we have not read this node before. Nodes that
|
/* Make sure that we have not read this node before. Nodes that
|
have already been read will have their tag stored in the 'aux'
|
have already been read will have their tag stored in the 'aux'
|
field. Since built-in functions can be referenced in multiple
|
field. Since built-in functions can be referenced in multiple
|
functions, they are expected to be read more than once. */
|
functions, they are expected to be read more than once. */
|
if (node->aux && !DECL_IS_BUILTIN (node->decl))
|
if (node->aux && !DECL_IS_BUILTIN (node->decl))
|
internal_error ("bytecode stream: found multiple instances of cgraph "
|
internal_error ("bytecode stream: found multiple instances of cgraph "
|
"node %d", node->uid);
|
"node %d", node->uid);
|
|
|
input_overwrite_node (file_data, node, tag, bp, stack_size, self_time,
|
input_overwrite_node (file_data, node, tag, bp, stack_size, self_time,
|
time_inlining_benefit, self_size,
|
time_inlining_benefit, self_size,
|
size_inlining_benefit);
|
size_inlining_benefit);
|
bitpack_delete (bp);
|
bitpack_delete (bp);
|
|
|
node->global.estimated_stack_size = estimated_stack_size;
|
node->global.estimated_stack_size = estimated_stack_size;
|
node->global.stack_frame_offset = stack_frame_offset;
|
node->global.stack_frame_offset = stack_frame_offset;
|
node->global.time = time;
|
node->global.time = time;
|
node->global.size = size;
|
node->global.size = size;
|
|
|
/* Store a reference for now, and fix up later to be a pointer. */
|
/* Store a reference for now, and fix up later to be a pointer. */
|
node->global.inlined_to = (cgraph_node_ptr) (intptr_t) ref;
|
node->global.inlined_to = (cgraph_node_ptr) (intptr_t) ref;
|
|
|
node->global.estimated_growth = estimated_growth;
|
node->global.estimated_growth = estimated_growth;
|
node->global.inlined = inlined;
|
node->global.inlined = inlined;
|
|
|
/* Store a reference for now, and fix up later to be a pointer. */
|
/* Store a reference for now, and fix up later to be a pointer. */
|
node->same_comdat_group = (cgraph_node_ptr) (intptr_t) ref2;
|
node->same_comdat_group = (cgraph_node_ptr) (intptr_t) ref2;
|
|
|
while (same_body_count-- > 0)
|
while (same_body_count-- > 0)
|
{
|
{
|
tree alias_decl;
|
tree alias_decl;
|
int type;
|
int type;
|
decl_index = lto_input_uleb128 (ib);
|
decl_index = lto_input_uleb128 (ib);
|
alias_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
|
alias_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
|
type = lto_input_uleb128 (ib);
|
type = lto_input_uleb128 (ib);
|
if (!type)
|
if (!type)
|
{
|
{
|
tree real_alias;
|
tree real_alias;
|
decl_index = lto_input_uleb128 (ib);
|
decl_index = lto_input_uleb128 (ib);
|
real_alias = lto_file_decl_data_get_fn_decl (file_data, decl_index);
|
real_alias = lto_file_decl_data_get_fn_decl (file_data, decl_index);
|
cgraph_same_body_alias (alias_decl, real_alias);
|
cgraph_same_body_alias (alias_decl, real_alias);
|
}
|
}
|
else
|
else
|
{
|
{
|
HOST_WIDE_INT fixed_offset = lto_input_uleb128 (ib);
|
HOST_WIDE_INT fixed_offset = lto_input_uleb128 (ib);
|
HOST_WIDE_INT virtual_value = lto_input_uleb128 (ib);
|
HOST_WIDE_INT virtual_value = lto_input_uleb128 (ib);
|
tree real_alias;
|
tree real_alias;
|
decl_index = lto_input_uleb128 (ib);
|
decl_index = lto_input_uleb128 (ib);
|
real_alias = lto_file_decl_data_get_fn_decl (file_data, decl_index);
|
real_alias = lto_file_decl_data_get_fn_decl (file_data, decl_index);
|
cgraph_add_thunk (alias_decl, fn_decl, type & 2, fixed_offset,
|
cgraph_add_thunk (alias_decl, fn_decl, type & 2, fixed_offset,
|
virtual_value,
|
virtual_value,
|
(type & 4) ? size_int (virtual_value) : NULL_TREE,
|
(type & 4) ? size_int (virtual_value) : NULL_TREE,
|
real_alias);
|
real_alias);
|
}
|
}
|
}
|
}
|
return node;
|
return node;
|
}
|
}
|
|
|
|
|
/* Read an edge from IB. NODES points to a vector of previously read
|
/* Read an edge from IB. NODES points to a vector of previously read
|
nodes for decoding caller and callee of the edge to be read. */
|
nodes for decoding caller and callee of the edge to be read. */
|
|
|
static void
|
static void
|
input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes)
|
input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes)
|
{
|
{
|
struct cgraph_node *caller, *callee;
|
struct cgraph_node *caller, *callee;
|
struct cgraph_edge *edge;
|
struct cgraph_edge *edge;
|
unsigned int stmt_id;
|
unsigned int stmt_id;
|
gcov_type count;
|
gcov_type count;
|
int freq;
|
int freq;
|
unsigned int nest;
|
unsigned int nest;
|
cgraph_inline_failed_t inline_failed;
|
cgraph_inline_failed_t inline_failed;
|
struct bitpack_d *bp;
|
struct bitpack_d *bp;
|
enum ld_plugin_symbol_resolution caller_resolution;
|
enum ld_plugin_symbol_resolution caller_resolution;
|
|
|
caller = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
|
caller = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
|
if (caller == NULL || caller->decl == NULL_TREE)
|
if (caller == NULL || caller->decl == NULL_TREE)
|
internal_error ("bytecode stream: no caller found while reading edge");
|
internal_error ("bytecode stream: no caller found while reading edge");
|
|
|
callee = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
|
callee = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
|
if (callee == NULL || callee->decl == NULL_TREE)
|
if (callee == NULL || callee->decl == NULL_TREE)
|
internal_error ("bytecode stream: no callee found while reading edge");
|
internal_error ("bytecode stream: no callee found while reading edge");
|
|
|
count = (gcov_type) lto_input_sleb128 (ib);
|
count = (gcov_type) lto_input_sleb128 (ib);
|
|
|
bp = lto_input_bitpack (ib);
|
bp = lto_input_bitpack (ib);
|
stmt_id = (unsigned int) bp_unpack_value (bp, HOST_BITS_PER_INT);
|
stmt_id = (unsigned int) bp_unpack_value (bp, HOST_BITS_PER_INT);
|
inline_failed = (cgraph_inline_failed_t) bp_unpack_value (bp,
|
inline_failed = (cgraph_inline_failed_t) bp_unpack_value (bp,
|
HOST_BITS_PER_INT);
|
HOST_BITS_PER_INT);
|
freq = (int) bp_unpack_value (bp, HOST_BITS_PER_INT);
|
freq = (int) bp_unpack_value (bp, HOST_BITS_PER_INT);
|
nest = (unsigned) bp_unpack_value (bp, 30);
|
nest = (unsigned) bp_unpack_value (bp, 30);
|
|
|
/* If the caller was preempted, don't create the edge.
|
/* If the caller was preempted, don't create the edge.
|
??? Should we ever have edges from a preempted caller? */
|
??? Should we ever have edges from a preempted caller? */
|
caller_resolution = lto_symtab_get_resolution (caller->decl);
|
caller_resolution = lto_symtab_get_resolution (caller->decl);
|
if (caller_resolution == LDPR_PREEMPTED_REG
|
if (caller_resolution == LDPR_PREEMPTED_REG
|
|| caller_resolution == LDPR_PREEMPTED_IR)
|
|| caller_resolution == LDPR_PREEMPTED_IR)
|
return;
|
return;
|
|
|
edge = cgraph_create_edge (caller, callee, NULL, count, freq, nest);
|
edge = cgraph_create_edge (caller, callee, NULL, count, freq, nest);
|
edge->lto_stmt_uid = stmt_id;
|
edge->lto_stmt_uid = stmt_id;
|
edge->inline_failed = inline_failed;
|
edge->inline_failed = inline_failed;
|
edge->indirect_call = bp_unpack_value (bp, 1);
|
edge->indirect_call = bp_unpack_value (bp, 1);
|
edge->call_stmt_cannot_inline_p = bp_unpack_value (bp, 1);
|
edge->call_stmt_cannot_inline_p = bp_unpack_value (bp, 1);
|
edge->can_throw_external = bp_unpack_value (bp, 1);
|
edge->can_throw_external = bp_unpack_value (bp, 1);
|
bitpack_delete (bp);
|
bitpack_delete (bp);
|
}
|
}
|
|
|
|
|
/* Read a cgraph from IB using the info in FILE_DATA. */
|
/* Read a cgraph from IB using the info in FILE_DATA. */
|
|
|
static void
|
static void
|
input_cgraph_1 (struct lto_file_decl_data *file_data,
|
input_cgraph_1 (struct lto_file_decl_data *file_data,
|
struct lto_input_block *ib)
|
struct lto_input_block *ib)
|
{
|
{
|
enum LTO_cgraph_tags tag;
|
enum LTO_cgraph_tags tag;
|
VEC(cgraph_node_ptr, heap) *nodes = NULL;
|
VEC(cgraph_node_ptr, heap) *nodes = NULL;
|
struct cgraph_node *node;
|
struct cgraph_node *node;
|
unsigned i;
|
unsigned i;
|
unsigned HOST_WIDE_INT len;
|
unsigned HOST_WIDE_INT len;
|
|
|
tag = (enum LTO_cgraph_tags) lto_input_uleb128 (ib);
|
tag = (enum LTO_cgraph_tags) lto_input_uleb128 (ib);
|
while (tag)
|
while (tag)
|
{
|
{
|
if (tag == LTO_cgraph_edge)
|
if (tag == LTO_cgraph_edge)
|
input_edge (ib, nodes);
|
input_edge (ib, nodes);
|
else
|
else
|
{
|
{
|
node = input_node (file_data, ib, tag);
|
node = input_node (file_data, ib, tag);
|
if (node == NULL || node->decl == NULL_TREE)
|
if (node == NULL || node->decl == NULL_TREE)
|
internal_error ("bytecode stream: found empty cgraph node");
|
internal_error ("bytecode stream: found empty cgraph node");
|
VEC_safe_push (cgraph_node_ptr, heap, nodes, node);
|
VEC_safe_push (cgraph_node_ptr, heap, nodes, node);
|
lto_cgraph_encoder_encode (file_data->cgraph_node_encoder, node);
|
lto_cgraph_encoder_encode (file_data->cgraph_node_encoder, node);
|
}
|
}
|
|
|
tag = (enum LTO_cgraph_tags) lto_input_uleb128 (ib);
|
tag = (enum LTO_cgraph_tags) lto_input_uleb128 (ib);
|
}
|
}
|
|
|
/* Input toplevel asms. */
|
/* Input toplevel asms. */
|
len = lto_input_uleb128 (ib);
|
len = lto_input_uleb128 (ib);
|
while (len)
|
while (len)
|
{
|
{
|
char *str = (char *)xmalloc (len + 1);
|
char *str = (char *)xmalloc (len + 1);
|
for (i = 0; i < len; ++i)
|
for (i = 0; i < len; ++i)
|
str[i] = lto_input_1_unsigned (ib);
|
str[i] = lto_input_1_unsigned (ib);
|
cgraph_add_asm_node (build_string (len, str));
|
cgraph_add_asm_node (build_string (len, str));
|
free (str);
|
free (str);
|
|
|
len = lto_input_uleb128 (ib);
|
len = lto_input_uleb128 (ib);
|
}
|
}
|
|
|
for (i = 0; VEC_iterate (cgraph_node_ptr, nodes, i, node); i++)
|
for (i = 0; VEC_iterate (cgraph_node_ptr, nodes, i, node); i++)
|
{
|
{
|
int ref = (int) (intptr_t) node->global.inlined_to;
|
int ref = (int) (intptr_t) node->global.inlined_to;
|
|
|
/* Fixup inlined_to from reference to pointer. */
|
/* Fixup inlined_to from reference to pointer. */
|
if (ref != LCC_NOT_FOUND)
|
if (ref != LCC_NOT_FOUND)
|
node->global.inlined_to = VEC_index (cgraph_node_ptr, nodes, ref);
|
node->global.inlined_to = VEC_index (cgraph_node_ptr, nodes, ref);
|
else
|
else
|
node->global.inlined_to = NULL;
|
node->global.inlined_to = NULL;
|
|
|
ref = (int) (intptr_t) node->same_comdat_group;
|
ref = (int) (intptr_t) node->same_comdat_group;
|
|
|
/* Fixup same_comdat_group from reference to pointer. */
|
/* Fixup same_comdat_group from reference to pointer. */
|
if (ref != LCC_NOT_FOUND)
|
if (ref != LCC_NOT_FOUND)
|
node->same_comdat_group = VEC_index (cgraph_node_ptr, nodes, ref);
|
node->same_comdat_group = VEC_index (cgraph_node_ptr, nodes, ref);
|
else
|
else
|
node->same_comdat_group = NULL;
|
node->same_comdat_group = NULL;
|
}
|
}
|
|
|
VEC_free (cgraph_node_ptr, heap, nodes);
|
VEC_free (cgraph_node_ptr, heap, nodes);
|
}
|
}
|
|
|
static struct gcov_ctr_summary lto_gcov_summary;
|
static struct gcov_ctr_summary lto_gcov_summary;
|
|
|
/* Input profile_info from IB. */
|
/* Input profile_info from IB. */
|
static void
|
static void
|
input_profile_summary (struct lto_input_block *ib)
|
input_profile_summary (struct lto_input_block *ib)
|
{
|
{
|
unsigned int runs = lto_input_uleb128 (ib);
|
unsigned int runs = lto_input_uleb128 (ib);
|
if (runs)
|
if (runs)
|
{
|
{
|
if (!profile_info)
|
if (!profile_info)
|
{
|
{
|
profile_info = <o_gcov_summary;
|
profile_info = <o_gcov_summary;
|
lto_gcov_summary.runs = runs;
|
lto_gcov_summary.runs = runs;
|
lto_gcov_summary.sum_all = lto_input_sleb128 (ib);
|
lto_gcov_summary.sum_all = lto_input_sleb128 (ib);
|
lto_gcov_summary.run_max = lto_input_sleb128 (ib);
|
lto_gcov_summary.run_max = lto_input_sleb128 (ib);
|
lto_gcov_summary.sum_max = lto_input_sleb128 (ib);
|
lto_gcov_summary.sum_max = lto_input_sleb128 (ib);
|
}
|
}
|
/* We can support this by scaling all counts to nearest common multiple
|
/* We can support this by scaling all counts to nearest common multiple
|
of all different runs, but it is perhaps not worth the effort. */
|
of all different runs, but it is perhaps not worth the effort. */
|
else if (profile_info->runs != runs
|
else if (profile_info->runs != runs
|
|| profile_info->sum_all != lto_input_sleb128 (ib)
|
|| profile_info->sum_all != lto_input_sleb128 (ib)
|
|| profile_info->run_max != lto_input_sleb128 (ib)
|
|| profile_info->run_max != lto_input_sleb128 (ib)
|
|| profile_info->sum_max != lto_input_sleb128 (ib))
|
|| profile_info->sum_max != lto_input_sleb128 (ib))
|
sorry ("Combining units with different profiles is not supported.");
|
sorry ("Combining units with different profiles is not supported.");
|
/* We allow some units to have profile and other to not have one. This will
|
/* We allow some units to have profile and other to not have one. This will
|
just make unprofiled units to be size optimized that is sane. */
|
just make unprofiled units to be size optimized that is sane. */
|
}
|
}
|
|
|
}
|
}
|
|
|
/* Input and merge the cgraph from each of the .o files passed to
|
/* Input and merge the cgraph from each of the .o files passed to
|
lto1. */
|
lto1. */
|
|
|
void
|
void
|
input_cgraph (void)
|
input_cgraph (void)
|
{
|
{
|
struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
|
struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
|
struct lto_file_decl_data *file_data;
|
struct lto_file_decl_data *file_data;
|
unsigned int j = 0;
|
unsigned int j = 0;
|
struct cgraph_node *node;
|
struct cgraph_node *node;
|
|
|
while ((file_data = file_data_vec[j++]))
|
while ((file_data = file_data_vec[j++]))
|
{
|
{
|
const char *data;
|
const char *data;
|
size_t len;
|
size_t len;
|
struct lto_input_block *ib;
|
struct lto_input_block *ib;
|
|
|
ib = lto_create_simple_input_block (file_data, LTO_section_cgraph,
|
ib = lto_create_simple_input_block (file_data, LTO_section_cgraph,
|
&data, &len);
|
&data, &len);
|
input_profile_summary (ib);
|
input_profile_summary (ib);
|
file_data->cgraph_node_encoder = lto_cgraph_encoder_new ();
|
file_data->cgraph_node_encoder = lto_cgraph_encoder_new ();
|
input_cgraph_1 (file_data, ib);
|
input_cgraph_1 (file_data, ib);
|
lto_destroy_simple_input_block (file_data, LTO_section_cgraph,
|
lto_destroy_simple_input_block (file_data, LTO_section_cgraph,
|
ib, data, len);
|
ib, data, len);
|
|
|
/* Assume that every file read needs to be processed by LTRANS. */
|
/* Assume that every file read needs to be processed by LTRANS. */
|
if (flag_wpa)
|
if (flag_wpa)
|
lto_mark_file_for_ltrans (file_data);
|
lto_mark_file_for_ltrans (file_data);
|
}
|
}
|
|
|
/* Clear out the aux field that was used to store enough state to
|
/* Clear out the aux field that was used to store enough state to
|
tell which nodes should be overwritten. */
|
tell which nodes should be overwritten. */
|
for (node = cgraph_nodes; node; node = node->next)
|
for (node = cgraph_nodes; node; node = node->next)
|
{
|
{
|
/* Some nodes may have been created by cgraph_node. This
|
/* Some nodes may have been created by cgraph_node. This
|
happens when the callgraph contains nested functions. If the
|
happens when the callgraph contains nested functions. If the
|
node for the parent function was never emitted to the gimple
|
node for the parent function was never emitted to the gimple
|
file, cgraph_node will create a node for it when setting the
|
file, cgraph_node will create a node for it when setting the
|
context of the nested function. */
|
context of the nested function. */
|
if (node->local.lto_file_data)
|
if (node->local.lto_file_data)
|
node->aux = NULL;
|
node->aux = NULL;
|
}
|
}
|
}
|
}
|
|
|
