+2012-06-03 Martin Jambor <mjambor@suse.cz>
+
+ * ipa-prop.h (ipa_get_jf_known_type_offset): New function.
+ (ipa_get_jf_known_type_base_type): Likewise.
+ (ipa_get_jf_known_type_component_type): Likewise.
+ (ipa_get_jf_constant): Likewise.
+ (ipa_get_jf_pass_through_formal_id): Likewise.
+ (ipa_get_jf_pass_through_operation): Likewise.
+ (ipa_get_jf_ancestor_offset): Likewise.
+ (ipa_get_jf_ancestor_type): Likewise.
+ (ipa_get_jf_ancestor_formal_id): Likewise.
+ (ipa_get_jf_member_ptr_pfn): Likewise.
+ * ipa-prop.c (ipa_set_jf_known_type): New function.
+ (ipa_set_jf_constant): Likewise.
+ (ipa_set_jf_simple_pass_through): Likewise.
+ (ipa_set_jf_arith_pass_through): Likewise.
+ (ipa_set_ancestor_jf): Likewise.
+ (fill_member_ptr_cst_jump_function): Moved up and renamed to
+ ipa_set_jf_member_ptr_cst.
+ (detect_type_change_1): Use the new jump function creation functions.
+ (compute_complex_assign_jump_func): Likewise.
+ (compute_complex_ancestor_jump_func): Likewise.
+ (compute_known_type_jump_func): Likewise.
+ (compute_scalar_jump_functions): Likewise.
+ (compute_pass_through_member_ptrs): Likewise.
+ (determine_cst_member_ptr): Likewise.
+ (combine_known_type_and_ancestor_jfs): Likewise.
+ (try_make_edge_direct_simple_call): Likewise.
+ (try_make_edge_direct_virtual_call): Likewise.
+ (update_indirect_edges_after_inlining): Likewise.
+ * ipa-cp.c (ipa_get_jf_pass_through_result): Use jump function
+ access functions. Incorporat NOP_EXPR and BINFO handling from its
+ callers.
+ (ipa_get_jf_ancestor_result): Likewise. Incorporate handling BINFOs
+ which was in its callers.
+ (ipa_value_from_jfunc): Use jump function access functions. Some
+ functionality moved to functions above.
+ (propagate_vals_accross_ancestor): Likewise.
+ (propagate_vals_accross_pass_through): Use jump function access
+ functions.
+ (propagate_accross_jump_function): Likewise.
+ * ipa-inline-analysis.c (remap_edge_change_prob): Use jump function
+ access functions.
+ (inline_merge_summary): Likewise.
+
2012-06-03 John David Anglin <dave.anglin@nrc-cnrc.gc.ca>
* config/pa/pa.h (MAX_PCREL17F_OFFSET): Define.
{
tree restype, res;
- gcc_checking_assert (is_gimple_ip_invariant (input));
- if (jfunc->value.pass_through.operation == NOP_EXPR)
+ if (ipa_get_jf_pass_through_operation (jfunc) == NOP_EXPR)
return input;
+ else if (TREE_CODE (input) == TREE_BINFO)
+ return NULL_TREE;
- if (TREE_CODE_CLASS (jfunc->value.pass_through.operation)
+ gcc_checking_assert (is_gimple_ip_invariant (input));
+ if (TREE_CODE_CLASS (ipa_get_jf_pass_through_operation (jfunc))
== tcc_comparison)
restype = boolean_type_node;
else
restype = TREE_TYPE (input);
- res = fold_binary (jfunc->value.pass_through.operation, restype,
- input, jfunc->value.pass_through.operand);
+ res = fold_binary (ipa_get_jf_pass_through_operation (jfunc), restype,
+ input, ipa_get_jf_pass_through_operand (jfunc));
if (res && !is_gimple_ip_invariant (res))
return NULL_TREE;
static tree
ipa_get_jf_ancestor_result (struct ipa_jump_func *jfunc, tree input)
{
- if (TREE_CODE (input) == ADDR_EXPR)
+ if (TREE_CODE (input) == TREE_BINFO)
+ return get_binfo_at_offset (input,
+ ipa_get_jf_ancestor_offset (jfunc),
+ ipa_get_jf_ancestor_type (jfunc));
+ else if (TREE_CODE (input) == ADDR_EXPR)
{
tree t = TREE_OPERAND (input, 0);
t = build_ref_for_offset (EXPR_LOCATION (t), t,
- jfunc->value.ancestor.offset,
- jfunc->value.ancestor.type, NULL, false);
+ ipa_get_jf_ancestor_offset (jfunc),
+ ipa_get_jf_ancestor_type (jfunc), NULL, false);
return build_fold_addr_expr (t);
}
else
static tree
ipa_value_from_known_type_jfunc (struct ipa_jump_func *jfunc)
{
- tree base_binfo = TYPE_BINFO (jfunc->value.known_type.base_type);
+ tree base_binfo = TYPE_BINFO (ipa_get_jf_known_type_base_type (jfunc));
if (!base_binfo)
return NULL_TREE;
return get_binfo_at_offset (base_binfo,
- jfunc->value.known_type.offset,
- jfunc->value.known_type.component_type);
+ ipa_get_jf_known_type_offset (jfunc),
+ ipa_get_jf_known_type_component_type (jfunc));
}
/* Determine whether JFUNC evaluates to a known value (that is either a
ipa_value_from_jfunc (struct ipa_node_params *info, struct ipa_jump_func *jfunc)
{
if (jfunc->type == IPA_JF_CONST)
- return jfunc->value.constant;
+ return ipa_get_jf_constant (jfunc);
else if (jfunc->type == IPA_JF_KNOWN_TYPE)
return ipa_value_from_known_type_jfunc (jfunc);
else if (jfunc->type == IPA_JF_PASS_THROUGH
int idx;
if (jfunc->type == IPA_JF_PASS_THROUGH)
- idx = jfunc->value.pass_through.formal_id;
+ idx = ipa_get_jf_pass_through_formal_id (jfunc);
else
- idx = jfunc->value.ancestor.formal_id;
+ idx = ipa_get_jf_ancestor_formal_id (jfunc);
if (info->ipcp_orig_node)
input = VEC_index (tree, info->known_vals, idx);
return NULL_TREE;
if (jfunc->type == IPA_JF_PASS_THROUGH)
- {
- if (jfunc->value.pass_through.operation == NOP_EXPR)
- return input;
- else if (TREE_CODE (input) == TREE_BINFO)
- return NULL_TREE;
- else
- return ipa_get_jf_pass_through_result (jfunc, input);
- }
+ return ipa_get_jf_pass_through_result (jfunc, input);
else
- {
- if (TREE_CODE (input) == TREE_BINFO)
- return get_binfo_at_offset (input, jfunc->value.ancestor.offset,
- jfunc->value.ancestor.type);
- else
- return ipa_get_jf_ancestor_result (jfunc, input);
- }
+ return ipa_get_jf_ancestor_result (jfunc, input);
}
else
return NULL_TREE;
struct ipcp_value *src_val;
bool ret = false;
- if (jfunc->value.pass_through.operation == NOP_EXPR)
+ if (ipa_get_jf_pass_through_operation (jfunc) == NOP_EXPR)
for (src_val = src_lat->values; src_val; src_val = src_val->next)
ret |= add_value_to_lattice (dest_lat, src_val->value, cs,
src_val, src_idx);
/* Do not create new values when propagating within an SCC because if there
- arithmetic functions with circular dependencies, there is infinite number
- of them and we would just make lattices bottom. */
+ are arithmetic functions with circular dependencies, there is infinite
+ number of them and we would just make lattices bottom. */
else if (edge_within_scc (cs))
ret = set_lattice_contains_variable (dest_lat);
else
for (src_val = src_lat->values; src_val; src_val = src_val->next)
{
- tree t = src_val->value;
-
- if (TREE_CODE (t) == TREE_BINFO)
- t = get_binfo_at_offset (t, jfunc->value.ancestor.offset,
- jfunc->value.ancestor.type);
- else
- t = ipa_get_jf_ancestor_result (jfunc, t);
+ tree t = ipa_get_jf_ancestor_result (jfunc, src_val->value);
if (t)
ret |= add_value_to_lattice (dest_lat, t, cs, src_val, src_idx);
return set_lattice_contains_variable (dest_lat);
}
else
- val = jfunc->value.constant;
+ val = ipa_get_jf_constant (jfunc);
return add_value_to_lattice (dest_lat, val, cs, NULL, 0);
}
else if (jfunc->type == IPA_JF_PASS_THROUGH
bool ret;
if (jfunc->type == IPA_JF_PASS_THROUGH)
- src_idx = jfunc->value.pass_through.formal_id;
+ src_idx = ipa_get_jf_pass_through_formal_id (jfunc);
else
- src_idx = jfunc->value.ancestor.formal_id;
+ src_idx = ipa_get_jf_ancestor_formal_id (jfunc);
src_lat = ipa_get_lattice (caller_info, src_idx);
if (src_lat->bottom)
{
struct ipa_jump_func *jfunc = ipa_get_ith_jump_func (args, i);
if (jfunc->type == IPA_JF_PASS_THROUGH
- && (jfunc->value.pass_through.formal_id
+ && (ipa_get_jf_pass_through_formal_id (jfunc)
< (int) VEC_length (inline_param_summary_t,
- inlined_es->param)))
+ inlined_es->param)))
{
+ int jf_formal_id = ipa_get_jf_pass_through_formal_id (jfunc);
int prob1 = VEC_index (inline_param_summary_t,
es->param, i)->change_prob;
int prob2 = VEC_index
(inline_param_summary_t,
- inlined_es->param,
- jfunc->value.pass_through.formal_id)->change_prob;
+ inlined_es->param, jf_formal_id)->change_prob;
int prob = ((prob1 * prob2 + REG_BR_PROB_BASE / 2)
/ REG_BR_PROB_BASE);
int map = -1;
/* TODO: handle non-NOPs when merging. */
if (jfunc->type == IPA_JF_PASS_THROUGH
- && jfunc->value.pass_through.operation == NOP_EXPR)
- map = jfunc->value.pass_through.formal_id;
+ && ipa_get_jf_pass_through_operation (jfunc) == NOP_EXPR)
+ map = ipa_get_jf_pass_through_formal_id (jfunc);
VEC_replace (int, operand_map, i, map);
gcc_assert (map < ipa_get_param_count (IPA_NODE_REF (to)));
}
}
}
+/* Set JFUNC to be a known type jump function. */
+
+static void
+ipa_set_jf_known_type (struct ipa_jump_func *jfunc, HOST_WIDE_INT offset,
+ tree base_type, tree component_type)
+{
+ jfunc->type = IPA_JF_KNOWN_TYPE;
+ jfunc->value.known_type.offset = offset,
+ jfunc->value.known_type.base_type = base_type;
+ jfunc->value.known_type.component_type = component_type;
+}
+
+/* Set JFUNC to be a constant jmp function. */
+
+static void
+ipa_set_jf_constant (struct ipa_jump_func *jfunc, tree constant)
+{
+ jfunc->type = IPA_JF_CONST;
+ jfunc->value.constant = constant;
+}
+
+/* Set JFUNC to be a simple pass-through jump function. */
+static void
+ipa_set_jf_simple_pass_through (struct ipa_jump_func *jfunc, int formal_id)
+{
+ jfunc->type = IPA_JF_PASS_THROUGH;
+ jfunc->value.pass_through.operand = NULL_TREE;
+ jfunc->value.pass_through.formal_id = formal_id;
+ jfunc->value.pass_through.operation = NOP_EXPR;
+}
+
+/* Set JFUNC to be an arithmetic pass through jump function. */
+
+static void
+ipa_set_jf_arith_pass_through (struct ipa_jump_func *jfunc, int formal_id,
+ tree operand, enum tree_code operation)
+{
+ jfunc->type = IPA_JF_PASS_THROUGH;
+ jfunc->value.pass_through.operand = operand;
+ jfunc->value.pass_through.formal_id = formal_id;
+ jfunc->value.pass_through.operation = operation;
+}
+
+/* Set JFUNC to be an ancestor jump function. */
+
+static void
+ipa_set_ancestor_jf (struct ipa_jump_func *jfunc, HOST_WIDE_INT offset,
+ tree type, int formal_id)
+{
+ jfunc->type = IPA_JF_ANCESTOR;
+ jfunc->value.ancestor.formal_id = formal_id;
+ jfunc->value.ancestor.offset = offset;
+ jfunc->value.ancestor.type = type;
+}
+
+/* Simple function filling in a member pointer constant jump function (with PFN
+ and DELTA as the constant value) into JFUNC. */
+
+static void
+ipa_set_jf_member_ptr_cst (struct ipa_jump_func *jfunc,
+ tree pfn, tree delta)
+{
+ jfunc->type = IPA_JF_CONST_MEMBER_PTR;
+ jfunc->value.member_cst.pfn = pfn;
+ jfunc->value.member_cst.delta = delta;
+}
+
/* Structure to be passed in between detect_type_change and
check_stmt_for_type_change. */
|| offset != 0)
jfunc->type = IPA_JF_UNKNOWN;
else
- {
- jfunc->type = IPA_JF_KNOWN_TYPE;
- jfunc->value.known_type.base_type = tci.known_current_type;
- jfunc->value.known_type.component_type = comp_type;
- }
+ ipa_set_jf_known_type (jfunc, 0, tci.known_current_type, comp_type);
return true;
}
TREE_TYPE (op1))))
return;
- jfunc->type = IPA_JF_PASS_THROUGH;
- jfunc->value.pass_through.formal_id = index;
- jfunc->value.pass_through.operation = gimple_assign_rhs_code (stmt);
- jfunc->value.pass_through.operand = op2;
+ ipa_set_jf_arith_pass_through (jfunc, index, op2,
+ gimple_assign_rhs_code (stmt));
}
else if (gimple_assign_single_p (stmt)
&& !detect_type_change_ssa (tc_ssa, call, jfunc))
- {
- jfunc->type = IPA_JF_PASS_THROUGH;
- jfunc->value.pass_through.formal_id = index;
- jfunc->value.pass_through.operation = NOP_EXPR;
- }
+ ipa_set_jf_simple_pass_through (jfunc, index);
return;
}
index = ipa_get_param_decl_index (info, SSA_NAME_VAR (ssa));
if (index >= 0
&& !detect_type_change (op1, base, call, jfunc, offset))
- {
- jfunc->type = IPA_JF_ANCESTOR;
- jfunc->value.ancestor.formal_id = index;
- jfunc->value.ancestor.offset = offset;
- jfunc->value.ancestor.type = TREE_TYPE (op1);
- }
+ ipa_set_ancestor_jf (jfunc, offset, TREE_TYPE (op1), index);
}
/* Extract the base, offset and MEM_REF expression from a statement ASSIGN if
}
if (!detect_type_change (obj, expr, call, jfunc, offset))
- {
- jfunc->type = IPA_JF_ANCESTOR;
- jfunc->value.ancestor.formal_id = index;
- jfunc->value.ancestor.offset = offset;
- jfunc->value.ancestor.type = TREE_TYPE (obj);
- }
+ ipa_set_ancestor_jf (jfunc, offset, TREE_TYPE (obj), index);
}
/* Given OP which is passed as an actual argument to a called function,
|| !TYPE_BINFO (TREE_TYPE (base)))
return;
- 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);
+ ipa_set_jf_known_type (jfunc, offset, TREE_TYPE (base), TREE_TYPE (op));
}
arg = gimple_call_arg (call, num);
if (is_gimple_ip_invariant (arg))
- {
- jfunc->type = IPA_JF_CONST;
- jfunc->value.constant = arg;
- }
+ ipa_set_jf_constant (jfunc, arg);
else if (TREE_CODE (arg) == SSA_NAME)
{
if (SSA_NAME_IS_DEFAULT_DEF (arg))
if (index >= 0
&& !detect_type_change_ssa (arg, call, jfunc))
- {
- jfunc->type = IPA_JF_PASS_THROUGH;
- jfunc->value.pass_through.formal_id = index;
- jfunc->value.pass_through.operation = NOP_EXPR;
- }
+ ipa_set_jf_simple_pass_through (jfunc, index);
}
else
{
{
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;
+ ipa_set_jf_simple_pass_through (jfunc, index);
}
else
undecided_members = true;
return undecided_members;
}
-/* Simple function filling in a member pointer constant jump function (with PFN
- and DELTA as the constant value) into JFUNC. */
-
-static void
-fill_member_ptr_cst_jump_function (struct ipa_jump_func *jfunc,
- tree pfn, tree delta)
-{
- jfunc->type = IPA_JF_CONST_MEMBER_PTR;
- jfunc->value.member_cst.pfn = pfn;
- jfunc->value.member_cst.delta = delta;
-}
-
/* If RHS is an SSA_NAME and it is defined by a simple copy assign statement,
return the rhs of its defining statement. */
method = TREE_OPERAND (rhs, 0);
if (delta)
{
- fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
+ ipa_set_jf_member_ptr_cst (jfunc, rhs, delta);
return;
}
}
delta = rhs;
if (method)
{
- fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
+ ipa_set_jf_member_ptr_cst (jfunc, rhs, delta);
return;
}
}
HOST_WIDE_INT combined_offset;
tree combined_type;
- combined_offset = src->value.known_type.offset + dst->value.ancestor.offset;
- combined_type = dst->value.ancestor.type;
+ combined_offset = ipa_get_jf_known_type_offset (src)
+ + ipa_get_jf_ancestor_offset (dst);
+ combined_type = ipa_get_jf_ancestor_type (dst);
- 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;
+ ipa_set_jf_known_type (dst, combined_offset,
+ ipa_get_jf_known_type_base_type (src),
+ combined_type);
}
/* Update the jump functions associated with call graph edge E when the call
tree target;
if (jfunc->type == IPA_JF_CONST)
- target = jfunc->value.constant;
+ target = ipa_get_jf_constant (jfunc);
else if (jfunc->type == IPA_JF_CONST_MEMBER_PTR)
- target = jfunc->value.member_cst.pfn;
+ target = ipa_get_jf_member_ptr_pfn (jfunc);
else
return NULL;
if (jfunc->type != IPA_JF_KNOWN_TYPE)
return NULL;
- binfo = TYPE_BINFO (jfunc->value.known_type.base_type);
+ binfo = TYPE_BINFO (ipa_get_jf_known_type_base_type (jfunc));
gcc_checking_assert (binfo);
- binfo = get_binfo_at_offset (binfo, jfunc->value.known_type.offset
+ binfo = get_binfo_at_offset (binfo, ipa_get_jf_known_type_offset (jfunc)
+ ie->indirect_info->anc_offset,
ie->indirect_info->otr_type);
if (binfo)
jfunc = ipa_get_ith_jump_func (top, ici->param_index);
if (jfunc->type == IPA_JF_PASS_THROUGH
- && jfunc->value.pass_through.operation == NOP_EXPR)
- ici->param_index = jfunc->value.pass_through.formal_id;
+ && ipa_get_jf_pass_through_operation (jfunc) == NOP_EXPR)
+ ici->param_index = ipa_get_jf_pass_through_formal_id (jfunc);
else if (jfunc->type == IPA_JF_ANCESTOR)
{
- ici->param_index = jfunc->value.ancestor.formal_id;
- ici->anc_offset += jfunc->value.ancestor.offset;
+ ici->param_index = ipa_get_jf_ancestor_formal_id (jfunc);
+ ici->anc_offset += ipa_get_jf_ancestor_offset (jfunc);
}
else
/* Either we can find a destination for this edge now or never. */
{
/* Offset of the field representing the ancestor. */
HOST_WIDE_INT offset;
- /* TYpe of the result. */
+ /* Type of the result. */
tree type;
/* Number of the caller's formal parameter being passed. */
int formal_id;
DEF_VEC_O (ipa_jump_func_t);
DEF_VEC_ALLOC_O (ipa_jump_func_t, gc);
+/* Return the offset of the component that is decribed by a known type jump
+ function JFUNC. */
+
+static inline HOST_WIDE_INT
+ipa_get_jf_known_type_offset (struct ipa_jump_func *jfunc)
+{
+ gcc_checking_assert (jfunc->type == IPA_JF_KNOWN_TYPE);
+ return jfunc->value.known_type.offset;
+}
+
+/* Return the base type of a known type jump function JFUNC. */
+
+static inline tree
+ipa_get_jf_known_type_base_type (struct ipa_jump_func *jfunc)
+{
+ gcc_checking_assert (jfunc->type == IPA_JF_KNOWN_TYPE);
+ return jfunc->value.known_type.base_type;
+}
+
+/* Return the component type of a known type jump function JFUNC. */
+
+static inline tree
+ipa_get_jf_known_type_component_type (struct ipa_jump_func *jfunc)
+{
+ gcc_checking_assert (jfunc->type == IPA_JF_KNOWN_TYPE);
+ return jfunc->value.known_type.component_type;
+}
+
+/* Return the constant stored in a constant jump functin JFUNC. */
+
+static inline tree
+ipa_get_jf_constant (struct ipa_jump_func *jfunc)
+{
+ gcc_checking_assert (jfunc->type == IPA_JF_CONST);
+ return jfunc->value.constant;
+}
+
+/* Return the operand of a pass through jmp function JFUNC. */
+
+static inline tree
+ipa_get_jf_pass_through_operand (struct ipa_jump_func *jfunc)
+{
+ gcc_checking_assert (jfunc->type == IPA_JF_PASS_THROUGH);
+ return jfunc->value.pass_through.operand;
+}
+
+/* Return the number of the caller's formal parameter that a pass through jump
+ function JFUNC refers to. */
+
+static inline int
+ipa_get_jf_pass_through_formal_id (struct ipa_jump_func *jfunc)
+{
+ gcc_checking_assert (jfunc->type == IPA_JF_PASS_THROUGH);
+ return jfunc->value.pass_through.formal_id;
+}
+
+/* Return operation of a pass through jump function JFUNC. */
+
+static inline enum tree_code
+ipa_get_jf_pass_through_operation (struct ipa_jump_func *jfunc)
+{
+ gcc_checking_assert (jfunc->type == IPA_JF_PASS_THROUGH);
+ return jfunc->value.pass_through.operation;
+}
+
+/* Return the offset of an ancestor jump function JFUNC. */
+
+static inline HOST_WIDE_INT
+ipa_get_jf_ancestor_offset (struct ipa_jump_func *jfunc)
+{
+ gcc_checking_assert (jfunc->type == IPA_JF_ANCESTOR);
+ return jfunc->value.ancestor.offset;
+}
+
+/* Return the result type of an ancestor jump function JFUNC. */
+
+static inline tree
+ipa_get_jf_ancestor_type (struct ipa_jump_func *jfunc)
+{
+ gcc_checking_assert (jfunc->type == IPA_JF_ANCESTOR);
+ return jfunc->value.ancestor.type;
+}
+
+/* Return the number of the caller's formal parameter that an ancestor jump
+ function JFUNC refers to. */
+
+static inline int
+ipa_get_jf_ancestor_formal_id (struct ipa_jump_func *jfunc)
+{
+ gcc_checking_assert (jfunc->type == IPA_JF_ANCESTOR);
+ return jfunc->value.ancestor.formal_id;
+}
+
+/* Return the pfn part of a member pointer constant jump function JFUNC. */
+
+static inline tree
+ipa_get_jf_member_ptr_pfn (struct ipa_jump_func *jfunc)
+{
+ gcc_checking_assert (jfunc->type == IPA_JF_CONST_MEMBER_PTR);
+ return jfunc->value.member_cst.pfn;
+}
+
/* Summary describing a single formal parameter. */
struct ipa_param_descriptor
projects / gcc.git / commitdiff