mirror of
https://github.com/autc04/Retro68.git
synced 2024-06-20 11:29:44 +00:00
767 lines
21 KiB
C
767 lines
21 KiB
C
/* Manipulation of formal and actual parameters of functions and function
|
|
calls.
|
|
Copyright (C) 2017-2019 Free Software Foundation, Inc.
|
|
|
|
This file is part of GCC.
|
|
|
|
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
|
|
Software Foundation; either version 3, or (at your option) any later
|
|
version.
|
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GCC; see the file COPYING3. If not see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
#include "config.h"
|
|
#include "system.h"
|
|
#include "coretypes.h"
|
|
#include "backend.h"
|
|
#include "rtl.h"
|
|
#include "tree.h"
|
|
#include "gimple.h"
|
|
#include "ssa.h"
|
|
#include "cgraph.h"
|
|
#include "fold-const.h"
|
|
#include "stor-layout.h"
|
|
#include "gimplify.h"
|
|
#include "gimple-iterator.h"
|
|
#include "gimplify-me.h"
|
|
#include "tree-dfa.h"
|
|
#include "ipa-param-manipulation.h"
|
|
#include "print-tree.h"
|
|
#include "gimple-pretty-print.h"
|
|
#include "builtins.h"
|
|
|
|
/* Return a heap allocated vector containing formal parameters of FNDECL. */
|
|
|
|
vec<tree>
|
|
ipa_get_vector_of_formal_parms (tree fndecl)
|
|
{
|
|
vec<tree> args;
|
|
int count;
|
|
tree parm;
|
|
|
|
gcc_assert (!flag_wpa);
|
|
count = 0;
|
|
for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm))
|
|
count++;
|
|
|
|
args.create (count);
|
|
for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm))
|
|
args.quick_push (parm);
|
|
|
|
return args;
|
|
}
|
|
|
|
/* Return a heap allocated vector containing types of formal parameters of
|
|
function type FNTYPE. */
|
|
|
|
vec<tree>
|
|
ipa_get_vector_of_formal_parm_types (tree fntype)
|
|
{
|
|
vec<tree> types;
|
|
int count = 0;
|
|
tree t;
|
|
|
|
for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
|
|
count++;
|
|
|
|
types.create (count);
|
|
for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
|
|
types.quick_push (TREE_VALUE (t));
|
|
|
|
return types;
|
|
}
|
|
|
|
/* Modify the function declaration FNDECL and its type according to the plan in
|
|
ADJUSTMENTS. It also sets base fields of individual adjustments structures
|
|
to reflect the actual parameters being modified which are determined by the
|
|
base_index field. */
|
|
|
|
void
|
|
ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec adjustments)
|
|
{
|
|
vec<tree> oparms = ipa_get_vector_of_formal_parms (fndecl);
|
|
tree orig_type = TREE_TYPE (fndecl);
|
|
tree old_arg_types = TYPE_ARG_TYPES (orig_type);
|
|
|
|
/* The following test is an ugly hack, some functions simply don't have any
|
|
arguments in their type. This is probably a bug but well... */
|
|
bool care_for_types = (old_arg_types != NULL_TREE);
|
|
bool last_parm_void;
|
|
vec<tree> otypes;
|
|
if (care_for_types)
|
|
{
|
|
last_parm_void = (TREE_VALUE (tree_last (old_arg_types))
|
|
== void_type_node);
|
|
otypes = ipa_get_vector_of_formal_parm_types (orig_type);
|
|
if (last_parm_void)
|
|
gcc_assert (oparms.length () + 1 == otypes.length ());
|
|
else
|
|
gcc_assert (oparms.length () == otypes.length ());
|
|
}
|
|
else
|
|
{
|
|
last_parm_void = false;
|
|
otypes.create (0);
|
|
}
|
|
|
|
int len = adjustments.length ();
|
|
tree *link = &DECL_ARGUMENTS (fndecl);
|
|
tree new_arg_types = NULL;
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
struct ipa_parm_adjustment *adj;
|
|
gcc_assert (link);
|
|
|
|
adj = &adjustments[i];
|
|
tree parm;
|
|
if (adj->op == IPA_PARM_OP_NEW)
|
|
parm = NULL;
|
|
else
|
|
parm = oparms[adj->base_index];
|
|
adj->base = parm;
|
|
|
|
if (adj->op == IPA_PARM_OP_COPY)
|
|
{
|
|
if (care_for_types)
|
|
new_arg_types = tree_cons (NULL_TREE, otypes[adj->base_index],
|
|
new_arg_types);
|
|
*link = parm;
|
|
link = &DECL_CHAIN (parm);
|
|
}
|
|
else if (adj->op != IPA_PARM_OP_REMOVE)
|
|
{
|
|
tree new_parm;
|
|
tree ptype;
|
|
|
|
if (adj->by_ref)
|
|
ptype = build_pointer_type (adj->type);
|
|
else
|
|
{
|
|
ptype = adj->type;
|
|
if (is_gimple_reg_type (ptype)
|
|
&& TYPE_MODE (ptype) != BLKmode)
|
|
{
|
|
unsigned malign = GET_MODE_ALIGNMENT (TYPE_MODE (ptype));
|
|
if (TYPE_ALIGN (ptype) != malign)
|
|
ptype = build_aligned_type (ptype, malign);
|
|
}
|
|
}
|
|
|
|
if (care_for_types)
|
|
new_arg_types = tree_cons (NULL_TREE, ptype, new_arg_types);
|
|
|
|
new_parm = build_decl (UNKNOWN_LOCATION, PARM_DECL, NULL_TREE,
|
|
ptype);
|
|
const char *prefix = adj->arg_prefix ? adj->arg_prefix : "SYNTH";
|
|
DECL_NAME (new_parm) = create_tmp_var_name (prefix);
|
|
DECL_ARTIFICIAL (new_parm) = 1;
|
|
DECL_ARG_TYPE (new_parm) = ptype;
|
|
DECL_CONTEXT (new_parm) = fndecl;
|
|
TREE_USED (new_parm) = 1;
|
|
DECL_IGNORED_P (new_parm) = 1;
|
|
layout_decl (new_parm, 0);
|
|
|
|
if (adj->op == IPA_PARM_OP_NEW)
|
|
adj->base = NULL;
|
|
else
|
|
adj->base = parm;
|
|
adj->new_decl = new_parm;
|
|
|
|
*link = new_parm;
|
|
link = &DECL_CHAIN (new_parm);
|
|
}
|
|
}
|
|
|
|
*link = NULL_TREE;
|
|
|
|
tree new_reversed = NULL;
|
|
if (care_for_types)
|
|
{
|
|
new_reversed = nreverse (new_arg_types);
|
|
if (last_parm_void)
|
|
{
|
|
if (new_reversed)
|
|
TREE_CHAIN (new_arg_types) = void_list_node;
|
|
else
|
|
new_reversed = void_list_node;
|
|
}
|
|
}
|
|
|
|
/* Use copy_node to preserve as much as possible from original type
|
|
(debug info, attribute lists etc.)
|
|
Exception is METHOD_TYPEs must have THIS argument.
|
|
When we are asked to remove it, we need to build new FUNCTION_TYPE
|
|
instead. */
|
|
tree new_type = NULL;
|
|
if (TREE_CODE (orig_type) != METHOD_TYPE
|
|
|| (adjustments[0].op == IPA_PARM_OP_COPY
|
|
&& adjustments[0].base_index == 0))
|
|
{
|
|
new_type = build_distinct_type_copy (orig_type);
|
|
TYPE_ARG_TYPES (new_type) = new_reversed;
|
|
}
|
|
else
|
|
{
|
|
new_type
|
|
= build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type),
|
|
new_reversed));
|
|
TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type);
|
|
DECL_VINDEX (fndecl) = NULL_TREE;
|
|
}
|
|
|
|
/* When signature changes, we need to clear builtin info. */
|
|
if (fndecl_built_in_p (fndecl))
|
|
{
|
|
DECL_BUILT_IN_CLASS (fndecl) = NOT_BUILT_IN;
|
|
DECL_FUNCTION_CODE (fndecl) = (enum built_in_function) 0;
|
|
}
|
|
|
|
TREE_TYPE (fndecl) = new_type;
|
|
DECL_VIRTUAL_P (fndecl) = 0;
|
|
DECL_LANG_SPECIFIC (fndecl) = NULL;
|
|
otypes.release ();
|
|
oparms.release ();
|
|
}
|
|
|
|
/* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS.
|
|
If this is a directly recursive call, CS must be NULL. Otherwise it must
|
|
contain the corresponding call graph edge. */
|
|
|
|
void
|
|
ipa_modify_call_arguments (struct cgraph_edge *cs, gcall *stmt,
|
|
ipa_parm_adjustment_vec adjustments)
|
|
{
|
|
struct cgraph_node *current_node = cgraph_node::get (current_function_decl);
|
|
vec<tree> vargs;
|
|
vec<tree, va_gc> **debug_args = NULL;
|
|
gcall *new_stmt;
|
|
gimple_stmt_iterator gsi, prev_gsi;
|
|
tree callee_decl;
|
|
int i, len;
|
|
|
|
len = adjustments.length ();
|
|
vargs.create (len);
|
|
callee_decl = !cs ? gimple_call_fndecl (stmt) : cs->callee->decl;
|
|
current_node->remove_stmt_references (stmt);
|
|
|
|
gsi = gsi_for_stmt (stmt);
|
|
prev_gsi = gsi;
|
|
gsi_prev (&prev_gsi);
|
|
for (i = 0; i < len; i++)
|
|
{
|
|
struct ipa_parm_adjustment *adj;
|
|
|
|
adj = &adjustments[i];
|
|
|
|
if (adj->op == IPA_PARM_OP_COPY)
|
|
{
|
|
tree arg = gimple_call_arg (stmt, adj->base_index);
|
|
|
|
vargs.quick_push (arg);
|
|
}
|
|
else if (adj->op != IPA_PARM_OP_REMOVE)
|
|
{
|
|
tree expr, base, off;
|
|
location_t loc;
|
|
unsigned int deref_align = 0;
|
|
bool deref_base = false;
|
|
|
|
/* 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. */
|
|
|
|
poly_int64 byte_offset = exact_div (adj->offset, BITS_PER_UNIT);
|
|
base = gimple_call_arg (stmt, adj->base_index);
|
|
loc = gimple_location (stmt);
|
|
|
|
if (TREE_CODE (base) != ADDR_EXPR
|
|
&& POINTER_TYPE_P (TREE_TYPE (base)))
|
|
off = build_int_cst (adj->alias_ptr_type, byte_offset);
|
|
else
|
|
{
|
|
poly_int64 base_offset;
|
|
tree prev_base;
|
|
bool addrof;
|
|
|
|
if (TREE_CODE (base) == ADDR_EXPR)
|
|
{
|
|
base = TREE_OPERAND (base, 0);
|
|
addrof = true;
|
|
}
|
|
else
|
|
addrof = false;
|
|
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 (adj->alias_ptr_type, byte_offset);
|
|
}
|
|
else if (TREE_CODE (base) == MEM_REF)
|
|
{
|
|
if (!addrof)
|
|
{
|
|
deref_base = true;
|
|
deref_align = TYPE_ALIGN (TREE_TYPE (base));
|
|
}
|
|
off = build_int_cst (adj->alias_ptr_type,
|
|
base_offset + byte_offset);
|
|
off = int_const_binop (PLUS_EXPR, TREE_OPERAND (base, 1),
|
|
off);
|
|
base = TREE_OPERAND (base, 0);
|
|
}
|
|
else
|
|
{
|
|
off = build_int_cst (adj->alias_ptr_type,
|
|
base_offset + byte_offset);
|
|
base = build_fold_addr_expr (base);
|
|
}
|
|
}
|
|
|
|
if (!adj->by_ref)
|
|
{
|
|
tree type = adj->type;
|
|
unsigned int align;
|
|
unsigned HOST_WIDE_INT misalign;
|
|
|
|
if (deref_base)
|
|
{
|
|
align = deref_align;
|
|
misalign = 0;
|
|
}
|
|
else
|
|
{
|
|
get_pointer_alignment_1 (base, &align, &misalign);
|
|
if (TYPE_ALIGN (type) > align)
|
|
align = TYPE_ALIGN (type);
|
|
}
|
|
misalign += (offset_int::from (wi::to_wide (off),
|
|
SIGNED).to_short_addr ()
|
|
* BITS_PER_UNIT);
|
|
misalign = misalign & (align - 1);
|
|
if (misalign != 0)
|
|
align = least_bit_hwi (misalign);
|
|
if (align < TYPE_ALIGN (type))
|
|
type = build_aligned_type (type, align);
|
|
base = force_gimple_operand_gsi (&gsi, base,
|
|
true, NULL, true, GSI_SAME_STMT);
|
|
expr = fold_build2_loc (loc, MEM_REF, type, base, off);
|
|
REF_REVERSE_STORAGE_ORDER (expr) = adj->reverse;
|
|
/* If expr is not a valid gimple call argument emit
|
|
a load into a temporary. */
|
|
if (is_gimple_reg_type (TREE_TYPE (expr)))
|
|
{
|
|
gimple *tem = gimple_build_assign (NULL_TREE, expr);
|
|
if (gimple_in_ssa_p (cfun))
|
|
{
|
|
gimple_set_vuse (tem, gimple_vuse (stmt));
|
|
expr = make_ssa_name (TREE_TYPE (expr), tem);
|
|
}
|
|
else
|
|
expr = create_tmp_reg (TREE_TYPE (expr));
|
|
gimple_assign_set_lhs (tem, expr);
|
|
gimple_set_location (tem, loc);
|
|
gsi_insert_before (&gsi, tem, GSI_SAME_STMT);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
expr = fold_build2_loc (loc, MEM_REF, adj->type, base, off);
|
|
REF_REVERSE_STORAGE_ORDER (expr) = adj->reverse;
|
|
expr = build_fold_addr_expr (expr);
|
|
expr = force_gimple_operand_gsi (&gsi, expr,
|
|
true, NULL, true, GSI_SAME_STMT);
|
|
}
|
|
vargs.quick_push (expr);
|
|
}
|
|
if (adj->op != IPA_PARM_OP_COPY && MAY_HAVE_DEBUG_BIND_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_safe_iterate (*debug_args, ix, &ddecl); ix += 2)
|
|
if (ddecl == origin)
|
|
{
|
|
ddecl = (**debug_args)[ix + 1];
|
|
break;
|
|
}
|
|
if (ddecl == NULL)
|
|
{
|
|
ddecl = make_node (DEBUG_EXPR_DECL);
|
|
DECL_ARTIFICIAL (ddecl) = 1;
|
|
TREE_TYPE (ddecl) = TREE_TYPE (origin);
|
|
SET_DECL_MODE (ddecl, DECL_MODE (origin));
|
|
|
|
vec_safe_push (*debug_args, origin);
|
|
vec_safe_push (*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))
|
|
{
|
|
fprintf (dump_file, "replacing stmt:");
|
|
print_gimple_stmt (dump_file, gsi_stmt (gsi), 0);
|
|
}
|
|
|
|
new_stmt = gimple_build_call_vec (callee_decl, vargs);
|
|
vargs.release ();
|
|
if (gimple_call_lhs (stmt))
|
|
gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
|
|
|
|
gimple_set_block (new_stmt, gimple_block (stmt));
|
|
if (gimple_has_location (stmt))
|
|
gimple_set_location (new_stmt, gimple_location (stmt));
|
|
gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
|
|
gimple_call_copy_flags (new_stmt, stmt);
|
|
if (gimple_in_ssa_p (cfun))
|
|
{
|
|
gimple_set_vuse (new_stmt, gimple_vuse (stmt));
|
|
if (gimple_vdef (stmt))
|
|
{
|
|
gimple_set_vdef (new_stmt, gimple_vdef (stmt));
|
|
SSA_NAME_DEF_STMT (gimple_vdef (new_stmt)) = new_stmt;
|
|
}
|
|
}
|
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
|
{
|
|
fprintf (dump_file, "with stmt:");
|
|
print_gimple_stmt (dump_file, new_stmt, 0);
|
|
fprintf (dump_file, "\n");
|
|
}
|
|
gsi_replace (&gsi, new_stmt, true);
|
|
if (cs)
|
|
cs->set_call_stmt (new_stmt);
|
|
do
|
|
{
|
|
current_node->record_stmt_references (gsi_stmt (gsi));
|
|
gsi_prev (&gsi);
|
|
}
|
|
while (gsi_stmt (gsi) != gsi_stmt (prev_gsi));
|
|
}
|
|
|
|
/* Return true iff BASE_INDEX is in ADJUSTMENTS more than once. */
|
|
|
|
static bool
|
|
index_in_adjustments_multiple_times_p (int base_index,
|
|
ipa_parm_adjustment_vec adjustments)
|
|
{
|
|
int i, len = adjustments.length ();
|
|
bool one = false;
|
|
|
|
for (i = 0; i < len; i++)
|
|
{
|
|
struct ipa_parm_adjustment *adj;
|
|
adj = &adjustments[i];
|
|
|
|
if (adj->base_index == base_index)
|
|
{
|
|
if (one)
|
|
return true;
|
|
else
|
|
one = true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* Return adjustments that should have the same effect on function parameters
|
|
and call arguments as if they were first changed according to adjustments in
|
|
INNER and then by adjustments in OUTER. */
|
|
|
|
ipa_parm_adjustment_vec
|
|
ipa_combine_adjustments (ipa_parm_adjustment_vec inner,
|
|
ipa_parm_adjustment_vec outer)
|
|
{
|
|
int i, outlen = outer.length ();
|
|
int inlen = inner.length ();
|
|
int removals = 0;
|
|
ipa_parm_adjustment_vec adjustments, tmp;
|
|
|
|
tmp.create (inlen);
|
|
for (i = 0; i < inlen; i++)
|
|
{
|
|
struct ipa_parm_adjustment *n;
|
|
n = &inner[i];
|
|
|
|
if (n->op == IPA_PARM_OP_REMOVE)
|
|
removals++;
|
|
else
|
|
{
|
|
/* FIXME: Handling of new arguments are not implemented yet. */
|
|
gcc_assert (n->op != IPA_PARM_OP_NEW);
|
|
tmp.quick_push (*n);
|
|
}
|
|
}
|
|
|
|
adjustments.create (outlen + removals);
|
|
for (i = 0; i < outlen; i++)
|
|
{
|
|
struct ipa_parm_adjustment r;
|
|
struct ipa_parm_adjustment *out = &outer[i];
|
|
struct ipa_parm_adjustment *in = &tmp[out->base_index];
|
|
|
|
memset (&r, 0, sizeof (r));
|
|
gcc_assert (in->op != IPA_PARM_OP_REMOVE);
|
|
if (out->op == IPA_PARM_OP_REMOVE)
|
|
{
|
|
if (!index_in_adjustments_multiple_times_p (in->base_index, tmp))
|
|
{
|
|
r.op = IPA_PARM_OP_REMOVE;
|
|
adjustments.quick_push (r);
|
|
}
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
/* FIXME: Handling of new arguments are not implemented yet. */
|
|
gcc_assert (out->op != IPA_PARM_OP_NEW);
|
|
}
|
|
|
|
r.base_index = in->base_index;
|
|
r.type = out->type;
|
|
|
|
/* FIXME: Create nonlocal value too. */
|
|
|
|
if (in->op == IPA_PARM_OP_COPY && out->op == IPA_PARM_OP_COPY)
|
|
r.op = IPA_PARM_OP_COPY;
|
|
else if (in->op == IPA_PARM_OP_COPY)
|
|
r.offset = out->offset;
|
|
else if (out->op == IPA_PARM_OP_COPY)
|
|
r.offset = in->offset;
|
|
else
|
|
r.offset = in->offset + out->offset;
|
|
adjustments.quick_push (r);
|
|
}
|
|
|
|
for (i = 0; i < inlen; i++)
|
|
{
|
|
struct ipa_parm_adjustment *n = &inner[i];
|
|
|
|
if (n->op == IPA_PARM_OP_REMOVE)
|
|
adjustments.quick_push (*n);
|
|
}
|
|
|
|
tmp.release ();
|
|
return adjustments;
|
|
}
|
|
|
|
/* If T is an SSA_NAME, return NULL if it is not a default def or
|
|
return its base variable if it is. If IGNORE_DEFAULT_DEF is true,
|
|
the base variable is always returned, regardless if it is a default
|
|
def. Return T if it is not an SSA_NAME. */
|
|
|
|
static tree
|
|
get_ssa_base_param (tree t, bool ignore_default_def)
|
|
{
|
|
if (TREE_CODE (t) == SSA_NAME)
|
|
{
|
|
if (ignore_default_def || SSA_NAME_IS_DEFAULT_DEF (t))
|
|
return SSA_NAME_VAR (t);
|
|
else
|
|
return NULL_TREE;
|
|
}
|
|
return t;
|
|
}
|
|
|
|
/* Given an expression, return an adjustment entry specifying the
|
|
transformation to be done on EXPR. If no suitable adjustment entry
|
|
was found, returns NULL.
|
|
|
|
If IGNORE_DEFAULT_DEF is set, consider SSA_NAMEs which are not a
|
|
default def, otherwise bail on them.
|
|
|
|
If CONVERT is non-NULL, this function will set *CONVERT if the
|
|
expression provided is a component reference. ADJUSTMENTS is the
|
|
adjustments vector. */
|
|
|
|
ipa_parm_adjustment *
|
|
ipa_get_adjustment_candidate (tree **expr, bool *convert,
|
|
ipa_parm_adjustment_vec adjustments,
|
|
bool ignore_default_def)
|
|
{
|
|
if (TREE_CODE (**expr) == BIT_FIELD_REF
|
|
|| TREE_CODE (**expr) == IMAGPART_EXPR
|
|
|| TREE_CODE (**expr) == REALPART_EXPR)
|
|
{
|
|
*expr = &TREE_OPERAND (**expr, 0);
|
|
if (convert)
|
|
*convert = true;
|
|
}
|
|
|
|
poly_int64 offset, size, max_size;
|
|
bool reverse;
|
|
tree base
|
|
= get_ref_base_and_extent (**expr, &offset, &size, &max_size, &reverse);
|
|
if (!base || !known_size_p (size) || !known_size_p (max_size))
|
|
return NULL;
|
|
|
|
if (TREE_CODE (base) == MEM_REF)
|
|
{
|
|
offset += mem_ref_offset (base).force_shwi () * BITS_PER_UNIT;
|
|
base = TREE_OPERAND (base, 0);
|
|
}
|
|
|
|
base = get_ssa_base_param (base, ignore_default_def);
|
|
if (!base || TREE_CODE (base) != PARM_DECL)
|
|
return NULL;
|
|
|
|
struct ipa_parm_adjustment *cand = NULL;
|
|
unsigned int len = adjustments.length ();
|
|
for (unsigned i = 0; i < len; i++)
|
|
{
|
|
struct ipa_parm_adjustment *adj = &adjustments[i];
|
|
|
|
if (adj->base == base
|
|
&& (known_eq (adj->offset, offset) || adj->op == IPA_PARM_OP_REMOVE))
|
|
{
|
|
cand = adj;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!cand || cand->op == IPA_PARM_OP_COPY || cand->op == IPA_PARM_OP_REMOVE)
|
|
return NULL;
|
|
return cand;
|
|
}
|
|
|
|
/* If the expression *EXPR should be replaced by a reduction of a parameter, do
|
|
so. ADJUSTMENTS is a pointer to a vector of adjustments. CONVERT
|
|
specifies whether the function should care about type incompatibility the
|
|
current and new expressions. If it is false, the function will leave
|
|
incompatibility issues to the caller. Return true iff the expression
|
|
was modified. */
|
|
|
|
bool
|
|
ipa_modify_expr (tree *expr, bool convert,
|
|
ipa_parm_adjustment_vec adjustments)
|
|
{
|
|
struct ipa_parm_adjustment *cand
|
|
= ipa_get_adjustment_candidate (&expr, &convert, adjustments, false);
|
|
if (!cand)
|
|
return false;
|
|
|
|
tree src;
|
|
if (cand->by_ref)
|
|
{
|
|
src = build_simple_mem_ref (cand->new_decl);
|
|
REF_REVERSE_STORAGE_ORDER (src) = cand->reverse;
|
|
}
|
|
else
|
|
src = cand->new_decl;
|
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
|
{
|
|
fprintf (dump_file, "About to replace expr ");
|
|
print_generic_expr (dump_file, *expr);
|
|
fprintf (dump_file, " with ");
|
|
print_generic_expr (dump_file, src);
|
|
fprintf (dump_file, "\n");
|
|
}
|
|
|
|
if (convert && !useless_type_conversion_p (TREE_TYPE (*expr), cand->type))
|
|
{
|
|
tree vce = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (*expr), src);
|
|
*expr = vce;
|
|
}
|
|
else
|
|
*expr = src;
|
|
return true;
|
|
}
|
|
|
|
/* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human
|
|
friendly way, assuming they are meant to be applied to FNDECL. */
|
|
|
|
void
|
|
ipa_dump_param_adjustments (FILE *file, ipa_parm_adjustment_vec adjustments,
|
|
tree fndecl)
|
|
{
|
|
int i, len = adjustments.length ();
|
|
bool first = true;
|
|
vec<tree> parms = ipa_get_vector_of_formal_parms (fndecl);
|
|
|
|
fprintf (file, "IPA param adjustments: ");
|
|
for (i = 0; i < len; i++)
|
|
{
|
|
struct ipa_parm_adjustment *adj;
|
|
adj = &adjustments[i];
|
|
|
|
if (!first)
|
|
fprintf (file, " ");
|
|
else
|
|
first = false;
|
|
|
|
fprintf (file, "%i. base_index: %i - ", i, adj->base_index);
|
|
print_generic_expr (file, parms[adj->base_index]);
|
|
if (adj->base)
|
|
{
|
|
fprintf (file, ", base: ");
|
|
print_generic_expr (file, adj->base);
|
|
}
|
|
if (adj->new_decl)
|
|
{
|
|
fprintf (file, ", new_decl: ");
|
|
print_generic_expr (file, adj->new_decl);
|
|
}
|
|
if (adj->new_ssa_base)
|
|
{
|
|
fprintf (file, ", new_ssa_base: ");
|
|
print_generic_expr (file, adj->new_ssa_base);
|
|
}
|
|
|
|
if (adj->op == IPA_PARM_OP_COPY)
|
|
fprintf (file, ", copy_param");
|
|
else if (adj->op == IPA_PARM_OP_REMOVE)
|
|
fprintf (file, ", remove_param");
|
|
else
|
|
{
|
|
fprintf (file, ", offset ");
|
|
print_dec (adj->offset, file);
|
|
}
|
|
if (adj->by_ref)
|
|
fprintf (file, ", by_ref");
|
|
print_node_brief (file, ", type: ", adj->type, 0);
|
|
fprintf (file, "\n");
|
|
}
|
|
parms.release ();
|
|
}
|
|
|