#include "gimple-pretty-print.h"
#include "lto-streamer.h"
+
+/* Intermediate information about a parameter that is only useful during the
+ run of ipa_analyze_node and is not kept afterwards. */
+
+struct param_analysis_info
+{
+ bool modified;
+ bitmap visited_statements;
+};
+
/* Vector where the parameter infos are actually stored. */
VEC (ipa_node_params_t, heap) *ipa_node_params_vector;
/* Vector where the parameter infos are actually stored. */
fndecl = node->decl;
fnargs = DECL_ARGUMENTS (fndecl);
param_num = 0;
- for (parm = fnargs; parm; parm = TREE_CHAIN (parm))
+ for (parm = fnargs; parm; parm = DECL_CHAIN (parm))
{
info->params[param_num].decl = parm;
param_num++;
tree parm;
int count = 0;
- for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
+ for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm))
count++;
return count;
}
}
-/* Callback of walk_stmt_load_store_addr_ops for the visit_store and visit_addr
- parameters. If OP is a parameter declaration, mark it as modified in the
- info structure passed in DATA. */
-
-static bool
-visit_store_addr_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED,
- tree op, void *data)
-{
- struct ipa_node_params *info = (struct ipa_node_params *) data;
-
- op = get_base_address (op);
- if (op
- && TREE_CODE (op) == PARM_DECL)
- {
- int index = ipa_get_param_decl_index (info, op);
- gcc_assert (index >= 0);
- info->params[index].modified = true;
- info->params[index].used = true;
- }
-
- return false;
-}
-
-/* Callback of walk_stmt_load_store_addr_ops for the visit_load.
- If OP is a parameter declaration, mark it as used in the info structure
- passed in DATA. */
-
-static bool
-visit_load_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED,
- tree op, void *data)
-{
- struct ipa_node_params *info = (struct ipa_node_params *) data;
-
- op = get_base_address (op);
- if (op
- && TREE_CODE (op) == PARM_DECL)
- {
- int index = ipa_get_param_decl_index (info, op);
- gcc_assert (index >= 0);
- info->params[index].used = true;
- }
-
- return false;
-}
-
-/* Compute which formal parameters of function associated with NODE are locally
- modified or their address is taken. Note that this does not apply on
- parameters with SSA names but those can and should be analyzed
- differently. */
-
-void
-ipa_detect_param_modifications (struct cgraph_node *node)
-{
- tree decl = node->decl;
- basic_block bb;
- struct function *func;
- gimple_stmt_iterator gsi;
- struct ipa_node_params *info = IPA_NODE_REF (node);
- int i;
-
- if (ipa_get_param_count (info) == 0 || info->modification_analysis_done)
- return;
-
- for (i = 0; i < ipa_get_param_count (info); i++)
- {
- tree parm = ipa_get_param (info, i);
- /* For SSA regs see if parameter is used. For non-SSA we compute
- the flag during modification analysis. */
- if (is_gimple_reg (parm)
- && gimple_default_def (DECL_STRUCT_FUNCTION (node->decl), parm))
- info->params[i].used = true;
- }
-
- func = DECL_STRUCT_FUNCTION (decl);
- FOR_EACH_BB_FN (bb, func)
- {
- for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
- walk_stmt_load_store_addr_ops (gsi_stmt (gsi), info,
- visit_load_for_mod_analysis,
- visit_store_addr_for_mod_analysis,
- visit_store_addr_for_mod_analysis);
- for (gsi = gsi_start (phi_nodes (bb)); !gsi_end_p (gsi); gsi_next (&gsi))
- walk_stmt_load_store_addr_ops (gsi_stmt (gsi), info,
- visit_load_for_mod_analysis,
- visit_store_addr_for_mod_analysis,
- visit_store_addr_for_mod_analysis);
- }
-
- info->modification_analysis_done = 1;
-}
-
/* Count number of arguments callsite CS has and store it in
ipa_edge_args structure corresponding to this callsite. */
-void
+static void
ipa_count_arguments (struct cgraph_edge *cs)
{
gimple stmt;
if (TREE_CODE (type) != RECORD_TYPE)
return;
op1 = get_ref_base_and_extent (op1, &offset, &size, &max_size);
- if (TREE_CODE (op1) != INDIRECT_REF
+ if (TREE_CODE (op1) != MEM_REF
/* If this is a varying address, punt. */
|| max_size == -1
|| max_size != size)
return;
+ offset += mem_ref_offset (op1).low * BITS_PER_UNIT;
op1 = TREE_OPERAND (op1, 0);
if (TREE_CODE (op1) != SSA_NAME
- || !SSA_NAME_IS_DEFAULT_DEF (op1))
+ || !SSA_NAME_IS_DEFAULT_DEF (op1)
+ || offset < 0)
return;
index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
expr = TREE_OPERAND (expr, 0);
expr = get_ref_base_and_extent (expr, &offset, &size, &max_size);
- if (TREE_CODE (expr) != INDIRECT_REF
+ if (TREE_CODE (expr) != MEM_REF
/* If this is a varying address, punt. */
|| max_size == -1
|| max_size != size)
return;
+ offset += mem_ref_offset (expr).low * BITS_PER_UNIT;
parm = TREE_OPERAND (expr, 0);
if (TREE_CODE (parm) != SSA_NAME
- || !SSA_NAME_IS_DEFAULT_DEF (parm))
+ || !SSA_NAME_IS_DEFAULT_DEF (parm)
+ || offset < 0)
return;
index = ipa_get_param_decl_index (info, SSA_NAME_VAR (parm));
if (method_ptr)
*method_ptr = fld;
- fld = TREE_CHAIN (fld);
+ fld = DECL_CHAIN (fld);
if (!fld || INTEGRAL_TYPE_P (fld))
return false;
if (delta)
*delta = fld;
- if (TREE_CHAIN (fld))
+ if (DECL_CHAIN (fld))
return false;
return true;
}
+/* Callback of walk_aliased_vdefs. Flags that it has been invoked to the
+ boolean variable pointed to by DATA. */
+
+static bool
+mark_modified (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef ATTRIBUTE_UNUSED,
+ void *data)
+{
+ bool *b = (bool *) data;
+ *b = true;
+ return true;
+}
+
+/* Return true if the formal parameter PARM might have been modified in this
+ function before reaching the statement CALL. PARM_INFO is a pointer to a
+ structure containing intermediate information about PARM. */
+
+static bool
+is_parm_modified_before_call (struct param_analysis_info *parm_info,
+ gimple call, tree parm)
+{
+ bool modified = false;
+ ao_ref refd;
+
+ if (parm_info->modified)
+ return true;
+
+ ao_ref_init (&refd, parm);
+ walk_aliased_vdefs (&refd, gimple_vuse (call), mark_modified,
+ &modified, &parm_info->visited_statements);
+ if (modified)
+ {
+ parm_info->modified = true;
+ return true;
+ }
+ return false;
+}
+
/* Go through arguments of the CALL and for every one that looks like a member
pointer, check whether it can be safely declared pass-through and if so,
mark that to the corresponding item of jump FUNCTIONS. Return true iff
there are non-pass-through member pointers within the arguments. INFO
- describes formal parameters of the caller. */
+ describes formal parameters of the caller. PARMS_INFO is a pointer to a
+ vector containing intermediate information about each formal parameter. */
static bool
compute_pass_through_member_ptrs (struct ipa_node_params *info,
+ struct param_analysis_info *parms_info,
struct ipa_jump_func *functions,
gimple call)
{
int index = ipa_get_param_decl_index (info, arg);
gcc_assert (index >=0);
- if (!ipa_is_param_modified (info, index))
+ 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;
to this callsite. */
static void
-ipa_compute_jump_functions_for_edge (struct cgraph_edge *cs)
+ipa_compute_jump_functions_for_edge (struct param_analysis_info *parms_info,
+ struct cgraph_edge *cs)
{
struct ipa_node_params *info = IPA_NODE_REF (cs->caller);
struct ipa_edge_args *arguments = IPA_EDGE_REF (cs);
/* 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, arguments->jump_functions, call))
+ if (!compute_pass_through_member_ptrs (info, parms_info,
+ arguments->jump_functions, call))
return;
/* Finally, let's check whether we actually pass a new constant member
/* Compute jump functions for all edges - both direct and indirect - outgoing
from NODE. Also count the actual arguments in the process. */
-void
-ipa_compute_jump_functions (struct cgraph_node *node)
+static void
+ipa_compute_jump_functions (struct cgraph_node *node,
+ struct param_analysis_info *parms_info)
{
struct cgraph_edge *cs;
{
/* 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 && !flag_whopr)
+ if (!cs->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 (cs);
+ 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 (cs);
+ ipa_compute_jump_functions_for_edge (parms_info, cs);
}
}
static tree
ipa_get_member_ptr_load_param (tree rhs, bool use_delta)
{
- tree rec, fld;
- tree ptr_field;
- tree delta_field;
+ tree rec, ref_field, ref_offset, fld, fld_offset, ptr_field, delta_field;
- if (TREE_CODE (rhs) != COMPONENT_REF)
+ if (TREE_CODE (rhs) == COMPONENT_REF)
+ {
+ ref_field = TREE_OPERAND (rhs, 1);
+ rhs = TREE_OPERAND (rhs, 0);
+ }
+ else
+ ref_field = NULL_TREE;
+ if (TREE_CODE (rhs) != MEM_REF)
return NULL_TREE;
-
rec = TREE_OPERAND (rhs, 0);
+ if (TREE_CODE (rec) != ADDR_EXPR)
+ return NULL_TREE;
+ rec = TREE_OPERAND (rec, 0);
if (TREE_CODE (rec) != PARM_DECL
|| !type_like_member_ptr_p (TREE_TYPE (rec), &ptr_field, &delta_field))
return NULL_TREE;
- fld = TREE_OPERAND (rhs, 1);
- if (use_delta ? (fld == delta_field) : (fld == ptr_field))
- return rec;
+ ref_offset = TREE_OPERAND (rhs, 1);
+
+ if (ref_field)
+ {
+ if (integer_nonzerop (ref_offset))
+ return NULL_TREE;
+
+ if (use_delta)
+ fld = delta_field;
+ else
+ fld = ptr_field;
+
+ return ref_field == fld ? rec : NULL_TREE;
+ }
+
+ if (use_delta)
+ fld_offset = byte_position (delta_field);
else
- return NULL_TREE;
+ fld_offset = byte_position (ptr_field);
+
+ return tree_int_cst_equal (ref_offset, fld_offset) ? rec : NULL_TREE;
}
/* If STMT looks like a statement loading a value from a member pointer formal
}
/* Analyze the CALL and examine uses of formal parameters of the caller NODE
- (described by INFO). Currently it checks whether the call calls a pointer
- that is a formal parameter and if so, the parameter is marked with the
- called flag and an indirect call graph edge describing the call is created.
- This is very simple for ordinary pointers represented in SSA but not-so-nice
- when it comes to member pointers. The ugly part of this function does
- nothing more than trying to match the pattern of such a call. An example of
- such a pattern is the gimple dump below, the call is on the last line:
+ (described by INFO). PARMS_INFO is a pointer to a vector containing
+ intermediate information about each formal parameter. Currently it checks
+ whether the call calls a pointer that is a formal parameter and if so, the
+ parameter is marked with the called flag and an indirect call graph edge
+ describing the call is created. This is very simple for ordinary pointers
+ represented in SSA but not-so-nice when it comes to member pointers. The
+ ugly part of this function does nothing more than trying to match the
+ pattern of such a call. An example of such a pattern is the gimple dump
+ below, the call is on the last line:
<bb 2>:
f$__delta_5 = f.__delta;
f$__pfn_24 = f.__pfn;
- ...
+ or
+ <bb 2>:
+ f$__delta_5 = MEM[(struct *)&f];
+ f$__pfn_24 = MEM[(struct *)&f + 4B];
+
+ and a few lines below:
<bb 5>
D.2496_3 = (int) f$__pfn_24;
static void
ipa_analyze_indirect_call_uses (struct cgraph_node *node,
struct ipa_node_params *info,
+ struct param_analysis_info *parms_info,
gimple call, tree target)
{
gimple def;
return;
index = ipa_get_param_decl_index (info, rec);
- if (index >= 0 && !ipa_is_param_modified (info, index))
+ if (index >= 0 && !is_parm_modified_before_call (&parms_info[index],
+ call, rec))
ipa_note_param_call (node, index, call, false);
return;
obj = TREE_OPERAND (obj, 0);
}
while (TREE_CODE (obj) == COMPONENT_REF);
- if (TREE_CODE (obj) != INDIRECT_REF)
+ if (TREE_CODE (obj) != MEM_REF)
return;
obj = TREE_OPERAND (obj, 0);
}
}
/* Analyze a call statement CALL whether and how it utilizes formal parameters
- of the caller (described by INFO). */
+ of the caller (described by INFO). PARMS_INFO is a pointer to a vector
+ containing intermediate information about each formal parameter. */
static void
ipa_analyze_call_uses (struct cgraph_node *node,
- struct ipa_node_params *info, gimple call)
+ struct ipa_node_params *info,
+ struct param_analysis_info *parms_info, gimple call)
{
tree target = gimple_call_fn (call);
if (TREE_CODE (target) == SSA_NAME)
- ipa_analyze_indirect_call_uses (node, info, call, target);
+ ipa_analyze_indirect_call_uses (node, info, parms_info, call, target);
else if (TREE_CODE (target) == OBJ_TYPE_REF)
ipa_analyze_virtual_call_uses (node, info, call, target);
}
/* Analyze the call statement STMT with respect to formal parameters (described
in INFO) of caller given by NODE. Currently it only checks whether formal
- parameters are called. */
+ parameters are called. PARMS_INFO is a pointer to a vector containing
+ intermediate information about each formal parameter. */
static void
ipa_analyze_stmt_uses (struct cgraph_node *node, struct ipa_node_params *info,
- gimple stmt)
+ struct param_analysis_info *parms_info, gimple stmt)
{
if (is_gimple_call (stmt))
- ipa_analyze_call_uses (node, info, stmt);
+ ipa_analyze_call_uses (node, info, parms_info, stmt);
+}
+
+/* Callback of walk_stmt_load_store_addr_ops for the visit_load.
+ If OP is a parameter declaration, mark it as used in the info structure
+ passed in DATA. */
+
+static bool
+visit_ref_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED,
+ tree op, void *data)
+{
+ struct ipa_node_params *info = (struct ipa_node_params *) data;
+
+ op = get_base_address (op);
+ if (op
+ && TREE_CODE (op) == PARM_DECL)
+ {
+ int index = ipa_get_param_decl_index (info, op);
+ gcc_assert (index >= 0);
+ info->params[index].used = true;
+ }
+
+ return false;
}
/* Scan the function body of NODE and inspect the uses of formal parameters.
Store the findings in various structures of the associated ipa_node_params
- structure, such as parameter flags, notes etc. */
+ structure, such as parameter flags, notes etc. PARMS_INFO is a pointer to a
+ vector containing intermediate information about each formal parameter. */
-void
-ipa_analyze_params_uses (struct cgraph_node *node)
+static void
+ipa_analyze_params_uses (struct cgraph_node *node,
+ struct param_analysis_info *parms_info)
{
tree decl = node->decl;
basic_block bb;
struct function *func;
gimple_stmt_iterator gsi;
struct ipa_node_params *info = IPA_NODE_REF (node);
+ int i;
if (ipa_get_param_count (info) == 0 || info->uses_analysis_done)
return;
+ for (i = 0; i < ipa_get_param_count (info); i++)
+ {
+ tree parm = ipa_get_param (info, i);
+ /* For SSA regs see if parameter is used. For non-SSA we compute
+ the flag during modification analysis. */
+ if (is_gimple_reg (parm)
+ && gimple_default_def (DECL_STRUCT_FUNCTION (node->decl), parm))
+ info->params[i].used = true;
+ }
+
func = DECL_STRUCT_FUNCTION (decl);
FOR_EACH_BB_FN (bb, func)
{
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
gimple stmt = gsi_stmt (gsi);
- ipa_analyze_stmt_uses (node, info, stmt);
+
+ if (is_gimple_debug (stmt))
+ continue;
+
+ ipa_analyze_stmt_uses (node, info, parms_info, stmt);
+ walk_stmt_load_store_addr_ops (stmt, info,
+ visit_ref_for_mod_analysis,
+ visit_ref_for_mod_analysis,
+ visit_ref_for_mod_analysis);
}
+ for (gsi = gsi_start (phi_nodes (bb)); !gsi_end_p (gsi); gsi_next (&gsi))
+ walk_stmt_load_store_addr_ops (gsi_stmt (gsi), info,
+ visit_ref_for_mod_analysis,
+ visit_ref_for_mod_analysis,
+ visit_ref_for_mod_analysis);
}
info->uses_analysis_done = 1;
}
+/* Initialize the array describing properties of of formal parameters of NODE,
+ analyze their uses and and compute jump functions associated witu actual
+ arguments of calls from within NODE. */
+
+void
+ipa_analyze_node (struct cgraph_node *node)
+{
+ struct ipa_node_params *info = IPA_NODE_REF (node);
+ struct param_analysis_info *parms_info;
+ int i, param_count;
+
+ ipa_initialize_node_params (node);
+
+ param_count = ipa_get_param_count (info);
+ parms_info = XALLOCAVEC (struct param_analysis_info, param_count);
+ memset (parms_info, 0, sizeof (struct param_analysis_info) * param_count);
+
+ ipa_analyze_params_uses (node, parms_info);
+ ipa_compute_jump_functions (node, parms_info);
+
+ for (i = 0; i < param_count; i++)
+ if (parms_info[i].visited_statements)
+ BITMAP_FREE (parms_info[i].visited_statements);
+}
+
+
/* Update the jump function DST when the call graph edge correspondng to SRC is
is being inlined, knowing that DST is of type ancestor and src of known
type. */
/* 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. */
-static struct cgraph_edge *
-make_edge_direct_to_target (struct cgraph_edge *ie, tree target)
+struct cgraph_edge *
+ipa_make_edge_direct_to_target (struct cgraph_edge *ie, tree target)
{
struct cgraph_node *callee;
callee = cgraph_node (target);
if (!callee)
return NULL;
-
+ ipa_check_create_node_params ();
cgraph_make_edge_direct (ie, callee);
if (dump_file)
{
else
return NULL;
- return make_edge_direct_to_target (ie, target);
+ return ipa_make_edge_direct_to_target (ie, target);
}
/* Try to find a destination for indirect edge IE that corresponds to a
return NULL;
if (target)
- return make_edge_direct_to_target (ie, target);
+ return ipa_make_edge_direct_to_target (ie, target);
else
return NULL;
}
struct cgraph_node *node,
VEC (cgraph_edge_p, heap) **new_edges)
{
- struct ipa_edge_args *top = IPA_EDGE_REF (cs);
+ struct ipa_edge_args *top;
struct cgraph_edge *ie, *next_ie, *new_direct_edge;
bool res = false;
ipa_check_create_edge_args ();
+ top = IPA_EDGE_REF (cs);
for (ie = node->indirect_calls; ie; ie = next_ie)
{
int i;
struct ipa_edge_args *args;
- for (i = 0;
- VEC_iterate (ipa_edge_args_t, ipa_edge_args_vector, i, args);
- i++)
+ FOR_EACH_VEC_ELT (ipa_edge_args_t, ipa_edge_args_vector, i, args)
ipa_free_edge_args_substructures (args);
VEC_free (ipa_edge_args_t, gc, ipa_edge_args_vector);
int i;
struct ipa_node_params *info;
- for (i = 0;
- VEC_iterate (ipa_node_params_t, ipa_node_params_vector, i, info);
- i++)
+ FOR_EACH_VEC_ELT (ipa_node_params_t, ipa_node_params_vector, i, info)
ipa_free_node_params_substructures (info);
VEC_free (ipa_node_params_t, heap, ipa_node_params_vector);
__attribute__((unused)) void *data)
{
struct ipa_node_params *old_info, *new_info;
- int param_count;
+ int param_count, i;
ipa_check_create_node_params ();
old_info = IPA_NODE_REF (src);
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->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;
}
/* Register our cgraph hooks if they are not already there. */
(DECL_NAME (temp)
? (*lang_hooks.decl_printable_name) (temp, 2)
: "(unnamed)"));
- if (ipa_is_param_modified (info, i))
- fprintf (f, " modified");
if (ipa_is_param_used (info, i))
fprintf (f, " used");
fprintf (f, "\n");
count = count_formal_params_1 (fndecl);
args = VEC_alloc (tree, heap, count);
- for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
+ for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm))
VEC_quick_push (tree, args, parm);
return args;
adj->base_index),
new_arg_types);
*link = parm;
- link = &TREE_CHAIN (parm);
+ link = &DECL_CHAIN (parm);
}
else if (!adj->remove_param)
{
*link = new_parm;
- link = &TREE_CHAIN (new_parm);
+ link = &DECL_CHAIN (new_parm);
}
}
|| (VEC_index (ipa_parm_adjustment_t, adjustments, 0)->copy_param
&& VEC_index (ipa_parm_adjustment_t, adjustments, 0)->base_index == 0))
{
- new_type = copy_node (orig_type);
+ new_type = build_distinct_type_copy (orig_type);
TYPE_ARG_TYPES (new_type) = new_reversed;
}
else
DECL_VINDEX (fndecl) = NULL_TREE;
}
+ /* When signature changes, we need to clear builtin info. */
+ if (DECL_BUILT_IN (fndecl))
+ {
+ DECL_BUILT_IN_CLASS (fndecl) = NOT_BUILT_IN;
+ DECL_FUNCTION_CODE (fndecl) = (enum built_in_function) 0;
+ }
+
/* This is a new type, not a copy of an old type. Need to reassociate
variants. We can handle everything except the main variant lazily. */
t = TYPE_MAIN_VARIANT (orig_type);
}
TREE_TYPE (fndecl) = new_type;
+ DECL_VIRTUAL_P (fndecl) = 0;
if (otypes)
VEC_free (tree, heap, otypes);
VEC_free (tree, heap, oparms);
}
else if (!adj->remove_param)
{
- tree expr, orig_expr;
- bool allow_ptr, repl_found;
-
- orig_expr = expr = gimple_call_arg (stmt, adj->base_index);
- if (TREE_CODE (expr) == ADDR_EXPR)
- {
- allow_ptr = false;
- expr = TREE_OPERAND (expr, 0);
- }
- else
- allow_ptr = true;
-
- repl_found = build_ref_for_offset (&expr, TREE_TYPE (expr),
- adj->offset, adj->type,
- allow_ptr);
- if (repl_found)
- {
- if (adj->by_ref)
- expr = build_fold_addr_expr (expr);
- }
+ tree expr, base, off;
+ location_t loc;
+
+ /* We create a new parameter out of the value of the old one, we can
+ do the following kind of transformations:
+
+ - A scalar passed by reference is converted to a scalar passed by
+ value. (adj->by_ref is false and the type of the original
+ actual argument is a pointer to a scalar).
+
+ - A part of an aggregate is passed instead of the whole aggregate.
+ The part can be passed either by value or by reference, this is
+ determined by value of adj->by_ref. Moreover, the code below
+ handles both situations when the original aggregate is passed by
+ value (its type is not a pointer) and when it is passed by
+ reference (it is a pointer to an aggregate).
+
+ When the new argument is passed by reference (adj->by_ref is true)
+ it must be a part of an aggregate and therefore we form it by
+ simply taking the address of a reference inside the original
+ aggregate. */
+
+ gcc_checking_assert (adj->offset % BITS_PER_UNIT == 0);
+ base = gimple_call_arg (stmt, adj->base_index);
+ loc = EXPR_LOCATION (base);
+
+ if (TREE_CODE (base) == ADDR_EXPR
+ && DECL_P (TREE_OPERAND (base, 0)))
+ off = build_int_cst (TREE_TYPE (base),
+ adj->offset / BITS_PER_UNIT);
+ else if (TREE_CODE (base) != ADDR_EXPR
+ && POINTER_TYPE_P (TREE_TYPE (base)))
+ off = build_int_cst (TREE_TYPE (base), adj->offset / BITS_PER_UNIT);
else
{
- tree ptrtype = build_pointer_type (adj->type);
- expr = orig_expr;
- if (!POINTER_TYPE_P (TREE_TYPE (expr)))
- expr = build_fold_addr_expr (expr);
- if (!useless_type_conversion_p (ptrtype, TREE_TYPE (expr)))
- expr = fold_convert (ptrtype, expr);
- expr = fold_build2 (POINTER_PLUS_EXPR, ptrtype, expr,
- build_int_cst (sizetype,
- adj->offset / BITS_PER_UNIT));
- if (!adj->by_ref)
- expr = fold_build1 (INDIRECT_REF, adj->type, expr);
+ HOST_WIDE_INT base_offset;
+ tree prev_base;
+
+ if (TREE_CODE (base) == ADDR_EXPR)
+ base = TREE_OPERAND (base, 0);
+ prev_base = base;
+ base = get_addr_base_and_unit_offset (base, &base_offset);
+ /* Aggregate arguments can have non-invariant addresses. */
+ if (!base)
+ {
+ base = build_fold_addr_expr (prev_base);
+ off = build_int_cst (reference_alias_ptr_type (prev_base),
+ adj->offset / BITS_PER_UNIT);
+ }
+ else if (TREE_CODE (base) == MEM_REF)
+ {
+ off = build_int_cst (TREE_TYPE (TREE_OPERAND (base, 1)),
+ base_offset
+ + adj->offset / BITS_PER_UNIT);
+ off = int_const_binop (PLUS_EXPR, TREE_OPERAND (base, 1),
+ off, 0);
+ base = TREE_OPERAND (base, 0);
+ }
+ else
+ {
+ off = build_int_cst (reference_alias_ptr_type (prev_base),
+ base_offset
+ + adj->offset / BITS_PER_UNIT);
+ base = build_fold_addr_expr (base);
+ }
}
+
+ expr = fold_build2_loc (loc, MEM_REF, adj->type, base, off);
+ if (adj->by_ref)
+ expr = build_fold_addr_expr (expr);
+
expr = force_gimple_operand_gsi (&gsi, expr,
adj->by_ref
|| is_gimple_reg_type (adj->type),
bp = bitpack_create (ob->main_stream);
bp_pack_value (&bp, info->called_with_var_arguments, 1);
- bp_pack_value (&bp, info->uses_analysis_done, 1);
- gcc_assert (info->modification_analysis_done
+ 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].modified, 1);
- bp_pack_value (&bp, info->params[j].used, 1);
- }
+ bp_pack_value (&bp, info->params[j].used, 1);
lto_output_bitpack (&bp);
for (e = node->callees; e; e = e->next_callee)
{
bp = lto_input_bitpack (ib);
info->called_with_var_arguments = bp_unpack_value (&bp, 1);
- info->uses_analysis_done = bp_unpack_value (&bp, 1);
if (ipa_get_param_count (info) != 0)
- {
- info->modification_analysis_done = true;
- info->uses_analysis_done = true;
- }
+ info->uses_analysis_done = true;
info->node_enqueued = false;
for (k = 0; k < ipa_get_param_count (info); k++)
- {
- info->params[k].modified = bp_unpack_value (&bp, 1);
- info->params[k].used = bp_unpack_value (&bp, 1);
- }
+ info->params[k].used = bp_unpack_value (&bp, 1);
for (e = node->callees; e; e = e->next_callee)
{
struct ipa_edge_args *args = IPA_EDGE_REF (e);
OSDN Git Service
