From 7b872d9e653928f1fbdc65310fa5cf8ee7b00f95 Mon Sep 17 00:00:00 2001 From: Martin Jambor Date: Mon, 4 Jun 2012 00:10:19 +0200 Subject: [PATCH] ipa-prop.h (ipa_get_jf_known_type_offset): New function. 2012-06-03 Martin Jambor * 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. From-SVN: r188156 --- gcc/ChangeLog | 45 +++++++++++ gcc/ipa-cp.c | 71 +++++++---------- gcc/ipa-inline-analysis.c | 12 +-- gcc/ipa-prop.c | 163 ++++++++++++++++++++++---------------- gcc/ipa-prop.h | 104 +++++++++++++++++++++++- 5 files changed, 276 insertions(+), 119 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 09a892366936..deb546de2f56 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,48 @@ +2012-06-03 Martin Jambor + + * 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 * config/pa/pa.h (MAX_PCREL17F_OFFSET): Define. diff --git a/gcc/ipa-cp.c b/gcc/ipa-cp.c index 4539d46ab734..3f3ab36119e0 100644 --- a/gcc/ipa-cp.c +++ b/gcc/ipa-cp.c @@ -638,17 +638,19 @@ ipa_get_jf_pass_through_result (struct ipa_jump_func *jfunc, tree input) { 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; @@ -662,12 +664,16 @@ ipa_get_jf_pass_through_result (struct ipa_jump_func *jfunc, tree input) 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 @@ -680,12 +686,12 @@ ipa_get_jf_ancestor_result (struct ipa_jump_func *jfunc, tree input) 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 @@ -697,7 +703,7 @@ tree 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 @@ -707,9 +713,9 @@ ipa_value_from_jfunc (struct ipa_node_params *info, struct ipa_jump_func *jfunc) 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); @@ -732,22 +738,9 @@ ipa_value_from_jfunc (struct ipa_node_params *info, struct ipa_jump_func *jfunc) 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; @@ -907,13 +900,13 @@ propagate_vals_accross_pass_through (struct cgraph_edge *cs, 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 @@ -956,13 +949,7 @@ propagate_vals_accross_ancestor (struct cgraph_edge *cs, 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); @@ -996,7 +983,7 @@ propagate_accross_jump_function (struct cgraph_edge *cs, 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 @@ -1008,9 +995,9 @@ propagate_accross_jump_function (struct cgraph_edge *cs, 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) diff --git a/gcc/ipa-inline-analysis.c b/gcc/ipa-inline-analysis.c index f0111cb66b45..a38d2608cbd9 100644 --- a/gcc/ipa-inline-analysis.c +++ b/gcc/ipa-inline-analysis.c @@ -2514,16 +2514,16 @@ remap_edge_change_prob (struct cgraph_edge *inlined_edge, { 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); @@ -2649,8 +2649,8 @@ inline_merge_summary (struct cgraph_edge *edge) 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))); } diff --git a/gcc/ipa-prop.c b/gcc/ipa-prop.c index af0f335a993f..ae35191e0f61 100644 --- a/gcc/ipa-prop.c +++ b/gcc/ipa-prop.c @@ -266,6 +266,73 @@ ipa_print_all_jump_functions (FILE *f) } } +/* 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. */ @@ -464,11 +531,7 @@ detect_type_change_1 (tree arg, tree base, tree comp_type, gimple call, || 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; } @@ -666,18 +729,12 @@ compute_complex_assign_jump_func (struct ipa_node_params *info, 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; } @@ -703,12 +760,7 @@ compute_complex_assign_jump_func (struct ipa_node_params *info, 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 @@ -832,12 +884,7 @@ compute_complex_ancestor_jump_func (struct ipa_node_params *info, } 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, @@ -869,10 +916,7 @@ compute_known_type_jump_func (tree op, struct ipa_jump_func *jfunc, || !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)); } @@ -898,10 +942,7 @@ compute_scalar_jump_functions (struct ipa_node_params *info, 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)) @@ -910,11 +951,7 @@ compute_scalar_jump_functions (struct ipa_node_params *info, 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 { @@ -997,9 +1034,7 @@ compute_pass_through_member_ptrs (struct ipa_node_params *info, { 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; @@ -1012,18 +1047,6 @@ compute_pass_through_member_ptrs (struct ipa_node_params *info, 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. */ @@ -1091,7 +1114,7 @@ determine_cst_member_ptr (gimple call, tree arg, tree method_field, 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; } } @@ -1107,7 +1130,7 @@ determine_cst_member_ptr (gimple call, tree arg, tree method_field, delta = rhs; if (method) { - fill_member_ptr_cst_jump_function (jfunc, rhs, delta); + ipa_set_jf_member_ptr_cst (jfunc, rhs, delta); return; } } @@ -1681,13 +1704,13 @@ combine_known_type_and_ancestor_jfs (struct ipa_jump_func *src, 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 @@ -1804,9 +1827,9 @@ try_make_edge_direct_simple_call (struct cgraph_edge *ie, 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; @@ -1827,9 +1850,9 @@ try_make_edge_direct_virtual_call (struct cgraph_edge *ie, 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) @@ -1881,12 +1904,12 @@ update_indirect_edges_after_inlining (struct cgraph_edge *cs, 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. */ diff --git a/gcc/ipa-prop.h b/gcc/ipa-prop.h index 1a609a5b5b79..7faa3e1eec0e 100644 --- a/gcc/ipa-prop.h +++ b/gcc/ipa-prop.h @@ -113,7 +113,7 @@ struct GTY(()) ipa_ancestor_jf_data { /* 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; @@ -149,6 +149,108 @@ typedef struct GTY (()) ipa_jump_func 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