/* Interprocedural analyses.
- Copyright (C) 2005, 2007, 2008, 2009, 2010
+ Copyright (C) 2005, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
This file is part of GCC.
#include "tree-pretty-print.h"
#include "gimple-pretty-print.h"
#include "lto-streamer.h"
+#include "data-streamer.h"
+#include "tree-streamer.h"
/* Intermediate information about a parameter that is only useful during the
/* Vector where the parameter infos are actually stored. */
VEC (ipa_edge_args_t, gc) *ipa_edge_args_vector;
-/* Bitmap with all UIDs of call graph edges that have been already processed
- by indirect inlining. */
-static bitmap iinlining_processed_edges;
-
/* Holders of ipa cgraph hooks: */
static struct cgraph_edge_hook_list *edge_removal_hook_holder;
static struct cgraph_node_hook_list *node_removal_hook_holder;
static struct cgraph_2node_hook_list *node_duplication_hook_holder;
static struct cgraph_node_hook_list *function_insertion_hook_holder;
-/* Add cgraph NODE described by INFO to the worklist WL regardless of whether
- it is in one or not. It should almost never be used directly, as opposed to
- ipa_push_func_to_list. */
-
-void
-ipa_push_func_to_list_1 (struct ipa_func_list **wl,
- struct cgraph_node *node,
- struct ipa_node_params *info)
-{
- struct ipa_func_list *temp;
-
- info->node_enqueued = 1;
- temp = XCNEW (struct ipa_func_list);
- temp->node = node;
- temp->next = *wl;
- *wl = temp;
-}
-
-/* Initialize worklist to contain all functions. */
-
-struct ipa_func_list *
-ipa_init_func_list (void)
-{
- struct cgraph_node *node;
- struct ipa_func_list * wl;
-
- wl = NULL;
- for (node = cgraph_nodes; node; node = node->next)
- if (node->analyzed)
- {
- struct ipa_node_params *info = IPA_NODE_REF (node);
- /* Unreachable nodes should have been eliminated before ipcp and
- inlining. */
- gcc_assert (node->needed || node->reachable);
- ipa_push_func_to_list_1 (&wl, node, info);
- }
-
- return wl;
-}
-
-/* Remove a function from the worklist WL and return it. */
-
-struct cgraph_node *
-ipa_pop_func_from_list (struct ipa_func_list **wl)
-{
- struct ipa_node_params *info;
- struct ipa_func_list *first;
- struct cgraph_node *node;
-
- first = *wl;
- *wl = (*wl)->next;
- node = first->node;
- free (first);
-
- info = IPA_NODE_REF (node);
- info->node_enqueued = 0;
- return node;
-}
-
/* Return index of the formal whose tree is PTREE in function which corresponds
to INFO. */
count = ipa_get_param_count (info);
for (i = 0; i < count; i++)
- if (ipa_get_param(info, i) == ptree)
+ if (ipa_get_param (info, i) == ptree)
return i;
return -1;
param_num = 0;
for (parm = fnargs; parm; parm = DECL_CHAIN (parm))
{
- info->params[param_num].decl = parm;
+ VEC_index (ipa_param_descriptor_t,
+ info->descriptors, param_num)->decl = parm;
param_num++;
}
}
/* Return how many formal parameters FNDECL has. */
static inline int
-count_formal_params_1 (tree fndecl)
+count_formal_params (tree fndecl)
{
tree parm;
int count = 0;
return count;
}
-/* Count number of formal parameters in NOTE. Store the result to the
- appropriate field of INFO. */
-
-static void
-ipa_count_formal_params (struct cgraph_node *node,
- struct ipa_node_params *info)
-{
- int param_num;
-
- param_num = count_formal_params_1 (node->decl);
- ipa_set_param_count (info, param_num);
-}
-
/* Initialize the ipa_node_params structure associated with NODE by counting
the function parameters, creating the descriptors and populating their
param_decls. */
{
struct ipa_node_params *info = IPA_NODE_REF (node);
- if (!info->params)
+ if (!info->descriptors)
{
- ipa_count_formal_params (node, info);
- info->params = XCNEWVEC (struct ipa_param_descriptor,
- ipa_get_param_count (info));
- ipa_populate_param_decls (node, info);
- }
-}
-
-/* Count number of arguments callsite CS has and store it in
- ipa_edge_args structure corresponding to this callsite. */
+ int param_count;
-static void
-ipa_count_arguments (struct cgraph_edge *cs)
-{
- gimple stmt;
- int arg_num;
-
- stmt = cs->call_stmt;
- gcc_assert (is_gimple_call (stmt));
- arg_num = gimple_call_num_args (stmt);
- if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
- <= (unsigned) cgraph_edge_max_uid)
- VEC_safe_grow_cleared (ipa_edge_args_t, gc,
- ipa_edge_args_vector, cgraph_edge_max_uid + 1);
- ipa_set_cs_argument_count (IPA_EDGE_REF (cs), arg_num);
+ param_count = count_formal_params (node->decl);
+ if (param_count)
+ {
+ VEC_safe_grow_cleared (ipa_param_descriptor_t, heap,
+ info->descriptors, param_count);
+ ipa_populate_param_decls (node, info);
+ }
+ }
}
/* Print the jump functions associated with call graph edge CS to file F. */
fprintf (f, "UNKNOWN\n");
else if (type == IPA_JF_KNOWN_TYPE)
{
- tree binfo_type = TREE_TYPE (jump_func->value.base_binfo);
- fprintf (f, "KNOWN TYPE, type in binfo is: ");
- print_generic_expr (f, binfo_type, 0);
- fprintf (f, " (%u)\n", TYPE_UID (binfo_type));
+ fprintf (f, "KNOWN TYPE: base ");
+ print_generic_expr (f, jump_func->value.known_type.base_type, 0);
+ fprintf (f, ", offset "HOST_WIDE_INT_PRINT_DEC", component ",
+ jump_func->value.known_type.offset);
+ print_generic_expr (f, jump_func->value.known_type.component_type, 0);
+ fprintf (f, "\n");
}
else if (type == IPA_JF_CONST)
{
tree_code_name[(int)
jump_func->value.pass_through.operation]);
if (jump_func->value.pass_through.operation != NOP_EXPR)
- print_generic_expr (dump_file,
+ print_generic_expr (f,
jump_func->value.pass_through.operand, 0);
- fprintf (dump_file, "\n");
+ fprintf (f, "\n");
}
else if (type == IPA_JF_ANCESTOR)
{
jump_func->value.ancestor.formal_id,
jump_func->value.ancestor.offset);
print_generic_expr (f, jump_func->value.ancestor.type, 0);
- fprintf (dump_file, "\n");
+ fprintf (f, "\n");
}
}
}
gimple call)
{
HOST_WIDE_INT offset, size, max_size;
- tree base, binfo;
+ tree base;
if (!flag_devirtualize
|| TREE_CODE (op) != ADDR_EXPR
|| is_global_var (base))
return;
- if (detect_type_change (op, base, call, jfunc, offset))
+ if (detect_type_change (op, base, call, jfunc, offset)
+ || !TYPE_BINFO (TREE_TYPE (base)))
return;
- binfo = TYPE_BINFO (TREE_TYPE (base));
- if (!binfo)
- return;
- binfo = get_binfo_at_offset (binfo, offset, TREE_TYPE (op));
- if (binfo)
- {
- jfunc->type = IPA_JF_KNOWN_TYPE;
- jfunc->value.base_binfo = binfo;
- }
+ jfunc->type = IPA_JF_KNOWN_TYPE;
+ jfunc->value.known_type.base_type = TREE_TYPE (base);
+ jfunc->value.known_type.offset = offset;
+ jfunc->value.known_type.component_type = TREE_TYPE (op);
}
static void
compute_scalar_jump_functions (struct ipa_node_params *info,
- struct ipa_jump_func *functions,
+ struct ipa_edge_args *args,
gimple call)
{
tree arg;
for (num = 0; num < gimple_call_num_args (call); num++)
{
+ struct ipa_jump_func *jfunc = ipa_get_ith_jump_func (args, num);
arg = gimple_call_arg (call, num);
if (is_gimple_ip_invariant (arg))
{
- functions[num].type = IPA_JF_CONST;
- functions[num].value.constant = arg;
+ jfunc->type = IPA_JF_CONST;
+ jfunc->value.constant = arg;
}
else if (TREE_CODE (arg) == SSA_NAME)
{
int index = ipa_get_param_decl_index (info, SSA_NAME_VAR (arg));
if (index >= 0
- && !detect_type_change_ssa (arg, call, &functions[num]))
+ && !detect_type_change_ssa (arg, call, jfunc))
{
- functions[num].type = IPA_JF_PASS_THROUGH;
- functions[num].value.pass_through.formal_id = index;
- functions[num].value.pass_through.operation = NOP_EXPR;
+ jfunc->type = IPA_JF_PASS_THROUGH;
+ jfunc->value.pass_through.formal_id = index;
+ jfunc->value.pass_through.operation = NOP_EXPR;
}
}
else
{
gimple stmt = SSA_NAME_DEF_STMT (arg);
if (is_gimple_assign (stmt))
- compute_complex_assign_jump_func (info, &functions[num],
- call, stmt, arg);
+ compute_complex_assign_jump_func (info, jfunc, call, stmt, arg);
else if (gimple_code (stmt) == GIMPLE_PHI)
- compute_complex_ancestor_jump_func (info, &functions[num],
- call, stmt);
+ compute_complex_ancestor_jump_func (info, jfunc, call, stmt);
}
}
else
- compute_known_type_jump_func (arg, &functions[num], call);
+ compute_known_type_jump_func (arg, jfunc, call);
}
}
static bool
compute_pass_through_member_ptrs (struct ipa_node_params *info,
struct param_analysis_info *parms_info,
- struct ipa_jump_func *functions,
+ struct ipa_edge_args *args,
gimple call)
{
bool undecided_members = false;
gcc_assert (index >=0);
if (!is_parm_modified_before_call (&parms_info[index], call, arg))
{
- functions[num].type = IPA_JF_PASS_THROUGH;
- functions[num].value.pass_through.formal_id = index;
- functions[num].value.pass_through.operation = NOP_EXPR;
+ struct ipa_jump_func *jfunc = ipa_get_ith_jump_func (args,
+ num);
+ jfunc->type = IPA_JF_PASS_THROUGH;
+ jfunc->value.pass_through.formal_id = index;
+ jfunc->value.pass_through.operation = NOP_EXPR;
}
else
undecided_members = true;
associated with the call. */
static void
-compute_cst_member_ptr_arguments (struct ipa_jump_func *functions,
+compute_cst_member_ptr_arguments (struct ipa_edge_args *args,
gimple call)
{
unsigned num;
for (num = 0; num < gimple_call_num_args (call); num++)
{
+ struct ipa_jump_func *jfunc = ipa_get_ith_jump_func (args, num);
arg = gimple_call_arg (call, num);
- if (functions[num].type == IPA_JF_UNKNOWN
+ if (jfunc->type == IPA_JF_UNKNOWN
&& type_like_member_ptr_p (TREE_TYPE (arg), &method_field,
&delta_field))
- determine_cst_member_ptr (call, arg, method_field, delta_field,
- &functions[num]);
+ determine_cst_member_ptr (call, arg, method_field, delta_field, jfunc);
}
}
struct cgraph_edge *cs)
{
struct ipa_node_params *info = IPA_NODE_REF (cs->caller);
- struct ipa_edge_args *arguments = IPA_EDGE_REF (cs);
- gimple call;
+ struct ipa_edge_args *args = IPA_EDGE_REF (cs);
+ gimple call = cs->call_stmt;
+ int arg_num = gimple_call_num_args (call);
- if (ipa_get_cs_argument_count (arguments) == 0 || arguments->jump_functions)
+ if (arg_num == 0 || args->jump_functions)
return;
- arguments->jump_functions = ggc_alloc_cleared_vec_ipa_jump_func
- (ipa_get_cs_argument_count (arguments));
-
- call = cs->call_stmt;
- gcc_assert (is_gimple_call (call));
+ VEC_safe_grow_cleared (ipa_jump_func_t, gc, args->jump_functions, arg_num);
/* We will deal with constants and SSA scalars first: */
- compute_scalar_jump_functions (info, arguments->jump_functions, call);
+ compute_scalar_jump_functions (info, args, call);
/* Let's check whether there are any potential member pointers and if so,
whether we can determine their functions as pass_through. */
- if (!compute_pass_through_member_ptrs (info, parms_info,
- arguments->jump_functions, call))
+ if (!compute_pass_through_member_ptrs (info, parms_info, args, call))
return;
/* Finally, let's check whether we actually pass a new constant member
pointer here... */
- compute_cst_member_ptr_arguments (arguments->jump_functions, call);
+ compute_cst_member_ptr_arguments (args, call);
}
/* Compute jump functions for all edges - both direct and indirect - outgoing
for (cs = node->callees; cs; cs = cs->next_callee)
{
+ struct cgraph_node *callee = cgraph_function_or_thunk_node (cs->callee,
+ NULL);
/* We do not need to bother analyzing calls to unknown
functions unless they may become known during lto/whopr. */
- if (!cs->callee->analyzed && !flag_lto)
+ if (!callee->analyzed && !flag_lto)
continue;
- ipa_count_arguments (cs);
- /* If the descriptor of the callee is not initialized yet, we have to do
- it now. */
- if (cs->callee->analyzed)
- ipa_initialize_node_params (cs->callee);
- if (ipa_get_cs_argument_count (IPA_EDGE_REF (cs))
- != ipa_get_param_count (IPA_NODE_REF (cs->callee)))
- ipa_set_called_with_variable_arg (IPA_NODE_REF (cs->callee));
ipa_compute_jump_functions_for_edge (parms_info, cs);
}
for (cs = node->indirect_calls; cs; cs = cs->next_callee)
- {
- ipa_count_arguments (cs);
- ipa_compute_jump_functions_for_edge (parms_info, cs);
- }
+ ipa_compute_jump_functions_for_edge (parms_info, cs);
}
/* If RHS looks like a rhs of a statement loading pfn from a member
if (!branch || gimple_code (branch) != GIMPLE_COND)
return;
- if (gimple_cond_code (branch) != NE_EXPR
+ if ((gimple_cond_code (branch) != NE_EXPR
+ && gimple_cond_code (branch) != EQ_EXPR)
|| !integer_zerop (gimple_cond_rhs (branch)))
return;
{
int index = ipa_get_param_decl_index (info, op);
gcc_assert (index >= 0);
- info->params[index].used = true;
+ ipa_set_param_used (info, index, true);
}
return false;
the flag during modification analysis. */
if (is_gimple_reg (parm)
&& gimple_default_def (DECL_STRUCT_FUNCTION (node->decl), parm))
- info->params[i].used = true;
+ ipa_set_param_used (info, i, true);
}
func = DECL_STRUCT_FUNCTION (decl);
combine_known_type_and_ancestor_jfs (struct ipa_jump_func *src,
struct ipa_jump_func *dst)
{
- tree new_binfo;
+ HOST_WIDE_INT combined_offset;
+ tree combined_type;
- new_binfo = get_binfo_at_offset (src->value.base_binfo,
- dst->value.ancestor.offset,
- dst->value.ancestor.type);
- if (new_binfo)
- {
- dst->type = IPA_JF_KNOWN_TYPE;
- dst->value.base_binfo = new_binfo;
- }
- else
- dst->type = IPA_JF_UNKNOWN;
+ combined_offset = src->value.known_type.offset + dst->value.ancestor.offset;
+ combined_type = dst->value.ancestor.type;
+
+ dst->type = IPA_JF_KNOWN_TYPE;
+ dst->value.known_type.base_type = src->value.known_type.base_type;
+ dst->value.known_type.offset = combined_offset;
+ dst->value.known_type.component_type = combined_type;
}
/* Update the jump functions associated with call graph edge E when the call
}
/* If TARGET is an addr_expr of a function declaration, make it the destination
- of an indirect edge IE and return the edge. Otherwise, return NULL. Delta,
- if non-NULL, is an integer constant that must be added to this pointer
- (first parameter). */
+ of an indirect edge IE and return the edge. Otherwise, return NULL. */
struct cgraph_edge *
-ipa_make_edge_direct_to_target (struct cgraph_edge *ie, tree target, tree delta)
+ipa_make_edge_direct_to_target (struct cgraph_edge *ie, tree target)
{
struct cgraph_node *callee;
return NULL;
ipa_check_create_node_params ();
- /* We can not make edges to inline clones. It is bug that someone removed the cgraph
- node too early. */
+ /* We can not make edges to inline clones. It is bug that someone removed
+ the cgraph node too early. */
gcc_assert (!callee->global.inlined_to);
- cgraph_make_edge_direct (ie, callee, delta ? tree_low_cst (delta, 0) : 0);
+ cgraph_make_edge_direct (ie, callee);
if (dump_file)
{
fprintf (dump_file, "ipa-prop: Discovered %s call to a known target "
print_gimple_stmt (dump_file, ie->call_stmt, 2, TDF_SLIM);
else
fprintf (dump_file, "with uid %i\n", ie->lto_stmt_uid);
-
- if (delta)
- {
- fprintf (dump_file, " Thunk delta is ");
- print_generic_expr (dump_file, delta, 0);
- fprintf (dump_file, "\n");
- }
}
-
- if (ipa_get_cs_argument_count (IPA_EDGE_REF (ie))
- != ipa_get_param_count (IPA_NODE_REF (callee)))
- ipa_set_called_with_variable_arg (IPA_NODE_REF (callee));
+ callee = cgraph_function_or_thunk_node (callee, NULL);
return ie;
}
else
return NULL;
- return ipa_make_edge_direct_to_target (ie, target, NULL_TREE);
+ return ipa_make_edge_direct_to_target (ie, target);
}
/* Try to find a destination for indirect edge IE that corresponds to a
try_make_edge_direct_virtual_call (struct cgraph_edge *ie,
struct ipa_jump_func *jfunc)
{
- tree binfo, type, target, delta;
- HOST_WIDE_INT token;
-
- if (jfunc->type == IPA_JF_KNOWN_TYPE)
- binfo = jfunc->value.base_binfo;
- else
- return NULL;
+ tree binfo, target;
- if (!binfo)
+ if (jfunc->type != IPA_JF_KNOWN_TYPE)
return NULL;
- token = ie->indirect_info->otr_token;
- type = ie->indirect_info->otr_type;
- binfo = get_binfo_at_offset (binfo, ie->indirect_info->anc_offset, type);
+ binfo = TYPE_BINFO (jfunc->value.known_type.base_type);
+ gcc_checking_assert (binfo);
+ binfo = get_binfo_at_offset (binfo, jfunc->value.known_type.offset
+ + ie->indirect_info->anc_offset,
+ ie->indirect_info->otr_type);
if (binfo)
- target = gimple_get_virt_method_for_binfo (token, binfo, &delta);
+ target = gimple_get_virt_method_for_binfo (ie->indirect_info->otr_token,
+ binfo);
else
return NULL;
if (target)
- return ipa_make_edge_direct_to_target (ie, target, delta);
+ return ipa_make_edge_direct_to_target (ie, target);
else
return NULL;
}
struct ipa_jump_func *jfunc;
next_ie = ie->next_callee;
- if (bitmap_bit_p (iinlining_processed_edges, ie->uid))
- continue;
- /* If we ever use indirect edges for anything other than indirect
- inlining, we will need to skip those with negative param_indices. */
if (ici->param_index == -1)
continue;
/* We must check range due to calls with variable number of arguments: */
if (ici->param_index >= ipa_get_cs_argument_count (top))
{
- bitmap_set_bit (iinlining_processed_edges, ie->uid);
+ ici->param_index = -1;
continue;
}
}
else
/* Either we can find a destination for this edge now or never. */
- bitmap_set_bit (iinlining_processed_edges, ie->uid);
+ ici->param_index = -1;
+
+ if (!flag_indirect_inlining)
+ continue;
if (ici->polymorphic)
new_direct_edge = try_make_edge_direct_virtual_call (ie, jfunc);
res |= propagate_info_to_inlined_callees (cs, e->callee, new_edges);
else
update_jump_functions_after_inlining (cs, e);
+ for (e = node->indirect_calls; e; e = e->next_callee)
+ update_jump_functions_after_inlining (cs, e);
return res;
}
ipa_propagate_indirect_call_infos (struct cgraph_edge *cs,
VEC (cgraph_edge_p, heap) **new_edges)
{
+ bool changed;
/* Do nothing if the preparation phase has not been carried out yet
(i.e. during early inlining). */
if (!ipa_node_params_vector)
return false;
gcc_assert (ipa_edge_args_vector);
- return propagate_info_to_inlined_callees (cs, cs->callee, new_edges);
+ changed = propagate_info_to_inlined_callees (cs, cs->callee, new_edges);
+
+ /* We do not keep jump functions of inlined edges up to date. Better to free
+ them so we do not access them accidentally. */
+ ipa_free_edge_args_substructures (IPA_EDGE_REF (cs));
+ return changed;
}
/* Frees all dynamically allocated structures that the argument info points
void
ipa_free_node_params_substructures (struct ipa_node_params *info)
{
- free (info->params);
-
+ VEC_free (ipa_param_descriptor_t, heap, info->descriptors);
+ free (info->lattices);
+ /* Lattice values and their sources are deallocated with their alocation
+ pool. */
+ VEC_free (tree, heap, info->known_vals);
memset (info, 0, sizeof (*info));
}
ipa_free_node_params_substructures (IPA_NODE_REF (node));
}
-/* Helper function to duplicate an array of size N that is at SRC and store a
- pointer to it to DST. Nothing is done if SRC is NULL. */
-
-static void *
-duplicate_array (void *src, size_t n)
-{
- void *p;
-
- if (!src)
- return NULL;
-
- p = xmalloc (n);
- memcpy (p, src, n);
- return p;
-}
-
-static struct ipa_jump_func *
-duplicate_ipa_jump_func_array (const struct ipa_jump_func * src, size_t n)
-{
- struct ipa_jump_func *p;
-
- if (!src)
- return NULL;
-
- p = ggc_alloc_vec_ipa_jump_func (n);
- memcpy (p, src, n * sizeof (struct ipa_jump_func));
- return p;
-}
-
/* Hook that is called by cgraph.c when a node is duplicated. */
static void
__attribute__((unused)) void *data)
{
struct ipa_edge_args *old_args, *new_args;
- int arg_count;
ipa_check_create_edge_args ();
old_args = IPA_EDGE_REF (src);
new_args = IPA_EDGE_REF (dst);
- arg_count = ipa_get_cs_argument_count (old_args);
- ipa_set_cs_argument_count (new_args, arg_count);
- new_args->jump_functions =
- duplicate_ipa_jump_func_array (old_args->jump_functions, arg_count);
-
- if (iinlining_processed_edges
- && bitmap_bit_p (iinlining_processed_edges, src->uid))
- bitmap_set_bit (iinlining_processed_edges, dst->uid);
+ new_args->jump_functions = VEC_copy (ipa_jump_func_t, gc,
+ old_args->jump_functions);
}
/* Hook that is called by cgraph.c when a node is duplicated. */
ATTRIBUTE_UNUSED void *data)
{
struct ipa_node_params *old_info, *new_info;
- int param_count, i;
ipa_check_create_node_params ();
old_info = IPA_NODE_REF (src);
new_info = IPA_NODE_REF (dst);
- param_count = ipa_get_param_count (old_info);
- ipa_set_param_count (new_info, param_count);
- new_info->params = (struct ipa_param_descriptor *)
- duplicate_array (old_info->params,
- sizeof (struct ipa_param_descriptor) * param_count);
- for (i = 0; i < param_count; i++)
- new_info->params[i].types = VEC_copy (tree, heap,
- old_info->params[i].types);
+ new_info->descriptors = VEC_copy (ipa_param_descriptor_t, heap,
+ old_info->descriptors);
+ new_info->lattices = NULL;
new_info->ipcp_orig_node = old_info->ipcp_orig_node;
- new_info->count_scale = old_info->count_scale;
- new_info->called_with_var_arguments = old_info->called_with_var_arguments;
new_info->uses_analysis_done = old_info->uses_analysis_done;
new_info->node_enqueued = old_info->node_enqueued;
}
function_insertion_hook_holder = NULL;
}
-/* Allocate all necessary data structures necessary for indirect inlining. */
-
-void
-ipa_create_all_structures_for_iinln (void)
-{
- iinlining_processed_edges = BITMAP_ALLOC (NULL);
-}
-
/* Free all ipa_node_params and all ipa_edge_args structures if they are no
longer needed after ipa-cp. */
void
ipa_free_all_structures_after_ipa_cp (void)
{
- if (!flag_indirect_inlining)
+ if (!optimize)
{
ipa_free_all_edge_args ();
ipa_free_all_node_params ();
+ free_alloc_pool (ipcp_sources_pool);
+ free_alloc_pool (ipcp_values_pool);
ipa_unregister_cgraph_hooks ();
}
}
void
ipa_free_all_structures_after_iinln (void)
{
- BITMAP_FREE (iinlining_processed_edges);
-
ipa_free_all_edge_args ();
ipa_free_all_node_params ();
ipa_unregister_cgraph_hooks ();
+ if (ipcp_sources_pool)
+ free_alloc_pool (ipcp_sources_pool);
+ if (ipcp_values_pool)
+ free_alloc_pool (ipcp_values_pool);
}
/* Print ipa_tree_map data structures of all functions in the
int count;
tree parm;
- count = count_formal_params_1 (fndecl);
+ count = count_formal_params (fndecl);
args = VEC_alloc (tree, heap, count);
for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm))
VEC_quick_push (tree, args, parm);
ipa_parm_adjustment_vec adjustments)
{
VEC(tree, heap) *vargs;
+ VEC(tree, gc) **debug_args = NULL;
gimple new_stmt;
gimple_stmt_iterator gsi;
tree callee_decl;
len = VEC_length (ipa_parm_adjustment_t, adjustments);
vargs = VEC_alloc (tree, heap, len);
+ callee_decl = !cs ? gimple_call_fndecl (stmt) : cs->callee->decl;
gsi = gsi_for_stmt (stmt);
for (i = 0; i < len; i++)
NULL, true, GSI_SAME_STMT);
VEC_quick_push (tree, vargs, expr);
}
+ if (!adj->copy_param && MAY_HAVE_DEBUG_STMTS)
+ {
+ unsigned int ix;
+ tree ddecl = NULL_TREE, origin = DECL_ORIGIN (adj->base), arg;
+ gimple def_temp;
+
+ arg = gimple_call_arg (stmt, adj->base_index);
+ if (!useless_type_conversion_p (TREE_TYPE (origin), TREE_TYPE (arg)))
+ {
+ if (!fold_convertible_p (TREE_TYPE (origin), arg))
+ continue;
+ arg = fold_convert_loc (gimple_location (stmt),
+ TREE_TYPE (origin), arg);
+ }
+ if (debug_args == NULL)
+ debug_args = decl_debug_args_insert (callee_decl);
+ for (ix = 0; VEC_iterate (tree, *debug_args, ix, ddecl); ix += 2)
+ if (ddecl == origin)
+ {
+ ddecl = VEC_index (tree, *debug_args, ix + 1);
+ break;
+ }
+ if (ddecl == NULL)
+ {
+ ddecl = make_node (DEBUG_EXPR_DECL);
+ DECL_ARTIFICIAL (ddecl) = 1;
+ TREE_TYPE (ddecl) = TREE_TYPE (origin);
+ DECL_MODE (ddecl) = DECL_MODE (origin);
+
+ VEC_safe_push (tree, gc, *debug_args, origin);
+ VEC_safe_push (tree, gc, *debug_args, ddecl);
+ }
+ def_temp = gimple_build_debug_bind (ddecl, unshare_expr (arg),
+ stmt);
+ gsi_insert_before (&gsi, def_temp, GSI_SAME_STMT);
+ }
}
if (dump_file && (dump_flags & TDF_DETAILS))
print_gimple_stmt (dump_file, gsi_stmt (gsi), 0, 0);
}
- callee_decl = !cs ? gimple_call_fndecl (stmt) : cs->callee->decl;
new_stmt = gimple_build_call_vec (callee_decl, vargs);
VEC_free (tree, heap, vargs);
if (gimple_call_lhs (stmt))
ipa_write_jump_function (struct output_block *ob,
struct ipa_jump_func *jump_func)
{
- lto_output_uleb128_stream (ob->main_stream,
- jump_func->type);
+ streamer_write_uhwi (ob, jump_func->type);
switch (jump_func->type)
{
case IPA_JF_UNKNOWN:
break;
case IPA_JF_KNOWN_TYPE:
- lto_output_tree (ob, jump_func->value.base_binfo, true);
+ streamer_write_uhwi (ob, jump_func->value.known_type.offset);
+ stream_write_tree (ob, jump_func->value.known_type.base_type, true);
+ stream_write_tree (ob, jump_func->value.known_type.component_type, true);
break;
case IPA_JF_CONST:
- lto_output_tree (ob, jump_func->value.constant, true);
+ stream_write_tree (ob, jump_func->value.constant, true);
break;
case IPA_JF_PASS_THROUGH:
- lto_output_tree (ob, jump_func->value.pass_through.operand, true);
- lto_output_uleb128_stream (ob->main_stream,
- jump_func->value.pass_through.formal_id);
- lto_output_uleb128_stream (ob->main_stream,
- jump_func->value.pass_through.operation);
+ stream_write_tree (ob, jump_func->value.pass_through.operand, true);
+ streamer_write_uhwi (ob, jump_func->value.pass_through.formal_id);
+ streamer_write_uhwi (ob, jump_func->value.pass_through.operation);
break;
case IPA_JF_ANCESTOR:
- lto_output_uleb128_stream (ob->main_stream,
- jump_func->value.ancestor.offset);
- lto_output_tree (ob, jump_func->value.ancestor.type, true);
- lto_output_uleb128_stream (ob->main_stream,
- jump_func->value.ancestor.formal_id);
+ streamer_write_uhwi (ob, jump_func->value.ancestor.offset);
+ stream_write_tree (ob, jump_func->value.ancestor.type, true);
+ streamer_write_uhwi (ob, jump_func->value.ancestor.formal_id);
break;
case IPA_JF_CONST_MEMBER_PTR:
- lto_output_tree (ob, jump_func->value.member_cst.pfn, true);
- lto_output_tree (ob, jump_func->value.member_cst.delta, false);
+ stream_write_tree (ob, jump_func->value.member_cst.pfn, true);
+ stream_write_tree (ob, jump_func->value.member_cst.delta, false);
break;
}
}
struct ipa_jump_func *jump_func,
struct data_in *data_in)
{
- jump_func->type = (enum jump_func_type) lto_input_uleb128 (ib);
+ jump_func->type = (enum jump_func_type) streamer_read_uhwi (ib);
switch (jump_func->type)
{
case IPA_JF_UNKNOWN:
break;
case IPA_JF_KNOWN_TYPE:
- jump_func->value.base_binfo = lto_input_tree (ib, data_in);
+ jump_func->value.known_type.offset = streamer_read_uhwi (ib);
+ jump_func->value.known_type.base_type = stream_read_tree (ib, data_in);
+ jump_func->value.known_type.component_type = stream_read_tree (ib,
+ data_in);
break;
case IPA_JF_CONST:
- jump_func->value.constant = lto_input_tree (ib, data_in);
+ jump_func->value.constant = stream_read_tree (ib, data_in);
break;
case IPA_JF_PASS_THROUGH:
- jump_func->value.pass_through.operand = lto_input_tree (ib, data_in);
- jump_func->value.pass_through.formal_id = lto_input_uleb128 (ib);
- jump_func->value.pass_through.operation = (enum tree_code) lto_input_uleb128 (ib);
+ jump_func->value.pass_through.operand = stream_read_tree (ib, data_in);
+ jump_func->value.pass_through.formal_id = streamer_read_uhwi (ib);
+ jump_func->value.pass_through.operation
+ = (enum tree_code) streamer_read_uhwi (ib);
break;
case IPA_JF_ANCESTOR:
- jump_func->value.ancestor.offset = lto_input_uleb128 (ib);
- jump_func->value.ancestor.type = lto_input_tree (ib, data_in);
- jump_func->value.ancestor.formal_id = lto_input_uleb128 (ib);
+ jump_func->value.ancestor.offset = streamer_read_uhwi (ib);
+ jump_func->value.ancestor.type = stream_read_tree (ib, data_in);
+ jump_func->value.ancestor.formal_id = streamer_read_uhwi (ib);
break;
case IPA_JF_CONST_MEMBER_PTR:
- jump_func->value.member_cst.pfn = lto_input_tree (ib, data_in);
- jump_func->value.member_cst.delta = lto_input_tree (ib, data_in);
+ jump_func->value.member_cst.pfn = stream_read_tree (ib, data_in);
+ jump_func->value.member_cst.delta = stream_read_tree (ib, data_in);
break;
}
}
struct cgraph_indirect_call_info *ii = cs->indirect_info;
struct bitpack_d bp;
- lto_output_sleb128_stream (ob->main_stream, ii->param_index);
- lto_output_sleb128_stream (ob->main_stream, ii->anc_offset);
+ streamer_write_hwi (ob, ii->param_index);
+ streamer_write_hwi (ob, ii->anc_offset);
bp = bitpack_create (ob->main_stream);
bp_pack_value (&bp, ii->polymorphic, 1);
- lto_output_bitpack (&bp);
+ streamer_write_bitpack (&bp);
if (ii->polymorphic)
{
- lto_output_sleb128_stream (ob->main_stream, ii->otr_token);
- lto_output_tree (ob, ii->otr_type, true);
+ streamer_write_hwi (ob, ii->otr_token);
+ stream_write_tree (ob, ii->otr_type, true);
}
}
struct cgraph_indirect_call_info *ii = cs->indirect_info;
struct bitpack_d bp;
- ii->param_index = (int) lto_input_sleb128 (ib);
- ii->anc_offset = (HOST_WIDE_INT) lto_input_sleb128 (ib);
- bp = lto_input_bitpack (ib);
+ ii->param_index = (int) streamer_read_hwi (ib);
+ ii->anc_offset = (HOST_WIDE_INT) streamer_read_hwi (ib);
+ bp = streamer_read_bitpack (ib);
ii->polymorphic = bp_unpack_value (&bp, 1);
if (ii->polymorphic)
{
- ii->otr_token = (HOST_WIDE_INT) lto_input_sleb128 (ib);
- ii->otr_type = lto_input_tree (ib, data_in);
+ ii->otr_token = (HOST_WIDE_INT) streamer_read_hwi (ib);
+ ii->otr_type = stream_read_tree (ib, data_in);
}
}
encoder = ob->decl_state->cgraph_node_encoder;
node_ref = lto_cgraph_encoder_encode (encoder, node);
- lto_output_uleb128_stream (ob->main_stream, node_ref);
+ streamer_write_uhwi (ob, node_ref);
bp = bitpack_create (ob->main_stream);
- bp_pack_value (&bp, info->called_with_var_arguments, 1);
gcc_assert (info->uses_analysis_done
|| ipa_get_param_count (info) == 0);
gcc_assert (!info->node_enqueued);
gcc_assert (!info->ipcp_orig_node);
for (j = 0; j < ipa_get_param_count (info); j++)
- bp_pack_value (&bp, info->params[j].used, 1);
- lto_output_bitpack (&bp);
+ bp_pack_value (&bp, ipa_is_param_used (info, j), 1);
+ streamer_write_bitpack (&bp);
for (e = node->callees; e; e = e->next_callee)
{
struct ipa_edge_args *args = IPA_EDGE_REF (e);
- lto_output_uleb128_stream (ob->main_stream,
- ipa_get_cs_argument_count (args));
+ streamer_write_uhwi (ob, ipa_get_cs_argument_count (args));
for (j = 0; j < ipa_get_cs_argument_count (args); j++)
ipa_write_jump_function (ob, ipa_get_ith_jump_func (args, j));
}
for (e = node->indirect_calls; e; e = e->next_callee)
- ipa_write_indirect_edge_info (ob, e);
+ {
+ struct ipa_edge_args *args = IPA_EDGE_REF (e);
+
+ streamer_write_uhwi (ob, ipa_get_cs_argument_count (args));
+ for (j = 0; j < ipa_get_cs_argument_count (args); j++)
+ ipa_write_jump_function (ob, ipa_get_ith_jump_func (args, j));
+ ipa_write_indirect_edge_info (ob, e);
+ }
}
/* Stream in NODE info from IB. */
ipa_initialize_node_params (node);
- bp = lto_input_bitpack (ib);
- info->called_with_var_arguments = bp_unpack_value (&bp, 1);
+ bp = streamer_read_bitpack (ib);
if (ipa_get_param_count (info) != 0)
info->uses_analysis_done = true;
info->node_enqueued = false;
for (k = 0; k < ipa_get_param_count (info); k++)
- info->params[k].used = bp_unpack_value (&bp, 1);
+ ipa_set_param_used (info, k, bp_unpack_value (&bp, 1));
for (e = node->callees; e; e = e->next_callee)
{
struct ipa_edge_args *args = IPA_EDGE_REF (e);
- int count = lto_input_uleb128 (ib);
+ int count = streamer_read_uhwi (ib);
- ipa_set_cs_argument_count (args, count);
if (!count)
continue;
+ VEC_safe_grow_cleared (ipa_jump_func_t, gc, args->jump_functions, count);
- args->jump_functions = ggc_alloc_cleared_vec_ipa_jump_func
- (ipa_get_cs_argument_count (args));
for (k = 0; k < ipa_get_cs_argument_count (args); k++)
ipa_read_jump_function (ib, ipa_get_ith_jump_func (args, k), data_in);
}
for (e = node->indirect_calls; e; e = e->next_callee)
- ipa_read_indirect_edge_info (ib, data_in, e);
+ {
+ struct ipa_edge_args *args = IPA_EDGE_REF (e);
+ int count = streamer_read_uhwi (ib);
+
+ if (count)
+ {
+ VEC_safe_grow_cleared (ipa_jump_func_t, gc, args->jump_functions,
+ count);
+ for (k = 0; k < ipa_get_cs_argument_count (args); k++)
+ ipa_read_jump_function (ib, ipa_get_ith_jump_func (args, k),
+ data_in);
+ }
+ ipa_read_indirect_edge_info (ib, data_in, e);
+ }
}
/* Write jump functions for nodes in SET. */
ipa_prop_write_jump_functions (cgraph_node_set set)
{
struct cgraph_node *node;
- struct output_block *ob = create_output_block (LTO_section_jump_functions);
+ struct output_block *ob;
unsigned int count = 0;
cgraph_node_set_iterator csi;
- ob->cgraph_node = NULL;
+ if (!ipa_node_params_vector)
+ return;
+ ob = create_output_block (LTO_section_jump_functions);
+ ob->cgraph_node = NULL;
for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
{
node = csi_node (csi);
count++;
}
- lto_output_uleb128_stream (ob->main_stream, count);
+ streamer_write_uhwi (ob, count);
/* Process all of the functions. */
for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
&& IPA_NODE_REF (node) != NULL)
ipa_write_node_info (ob, node);
}
- lto_output_1_stream (ob->main_stream, 0);
+ streamer_write_char_stream (ob->main_stream, 0);
produce_asm (ob, NULL);
destroy_output_block (ob);
}
data_in =
lto_data_in_create (file_data, (const char *) data + string_offset,
header->string_size, NULL);
- count = lto_input_uleb128 (&ib_main);
+ count = streamer_read_uhwi (&ib_main);
for (i = 0; i < count; i++)
{
struct cgraph_node *node;
lto_cgraph_encoder_t encoder;
- index = lto_input_uleb128 (&ib_main);
+ index = streamer_read_uhwi (&ib_main);
encoder = file_data->cgraph_node_encoder;
node = lto_cgraph_encoder_deref (encoder, index);
gcc_assert (node->analyzed);
ipa_update_after_lto_read (void)
{
struct cgraph_node *node;
- struct cgraph_edge *cs;
ipa_check_create_node_params ();
ipa_check_create_edge_args ();
for (node = cgraph_nodes; node; node = node->next)
if (node->analyzed)
ipa_initialize_node_params (node);
-
- for (node = cgraph_nodes; node; node = node->next)
- if (node->analyzed)
- for (cs = node->callees; cs; cs = cs->next_callee)
- {
- if (ipa_get_cs_argument_count (IPA_EDGE_REF (cs))
- != ipa_get_param_count (IPA_NODE_REF (cs->callee)))
- ipa_set_called_with_variable_arg (IPA_NODE_REF (cs->callee));
- }
-}
-
-/* Given the jump function JFUNC, compute the lattice LAT that describes the
- value coming down the callsite. INFO describes the caller node so that
- pass-through jump functions can be evaluated. */
-
-void
-ipa_lattice_from_jfunc (struct ipa_node_params *info, struct ipcp_lattice *lat,
- struct ipa_jump_func *jfunc)
-{
- if (jfunc->type == IPA_JF_CONST)
- {
- lat->type = IPA_CONST_VALUE;
- lat->constant = jfunc->value.constant;
- }
- else if (jfunc->type == IPA_JF_PASS_THROUGH)
- {
- struct ipcp_lattice *caller_lat;
- tree cst;
-
- caller_lat = ipa_get_lattice (info, jfunc->value.pass_through.formal_id);
- lat->type = caller_lat->type;
- if (caller_lat->type != IPA_CONST_VALUE)
- return;
- cst = caller_lat->constant;
-
- if (jfunc->value.pass_through.operation != NOP_EXPR)
- {
- tree restype;
- if (TREE_CODE_CLASS (jfunc->value.pass_through.operation)
- == tcc_comparison)
- restype = boolean_type_node;
- else
- restype = TREE_TYPE (cst);
- cst = fold_binary (jfunc->value.pass_through.operation,
- restype, cst, jfunc->value.pass_through.operand);
- }
- if (!cst || !is_gimple_ip_invariant (cst))
- lat->type = IPA_BOTTOM;
- lat->constant = cst;
- }
- else if (jfunc->type == IPA_JF_ANCESTOR)
- {
- struct ipcp_lattice *caller_lat;
- tree t;
-
- caller_lat = ipa_get_lattice (info, jfunc->value.ancestor.formal_id);
- lat->type = caller_lat->type;
- if (caller_lat->type != IPA_CONST_VALUE)
- return;
- if (TREE_CODE (caller_lat->constant) != ADDR_EXPR)
- {
- /* This can happen when the constant is a NULL pointer. */
- lat->type = IPA_BOTTOM;
- return;
- }
- t = TREE_OPERAND (caller_lat->constant, 0);
- t = build_ref_for_offset (EXPR_LOCATION (t), t,
- jfunc->value.ancestor.offset,
- jfunc->value.ancestor.type, NULL, false);
- lat->constant = build_fold_addr_expr (t);
- }
- else
- lat->type = IPA_BOTTOM;
-}
-
-/* Determine whether JFUNC evaluates to a constant and if so, return it.
- Otherwise return NULL. INFO describes the caller node so that pass-through
- jump functions can be evaluated. */
-
-tree
-ipa_cst_from_jfunc (struct ipa_node_params *info, struct ipa_jump_func *jfunc)
-{
- struct ipcp_lattice lat;
-
- ipa_lattice_from_jfunc (info, &lat, jfunc);
- if (lat.type == IPA_CONST_VALUE)
- return lat.constant;
- else
- return NULL_TREE;
}
OSDN Git Service
