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");
}
}
}
struct type_change_info
{
+ /* Offset into the object where there is the virtual method pointer we are
+ looking for. */
+ HOST_WIDE_INT offset;
+ /* The declaration or SSA_NAME pointer of the base that we are checking for
+ type change. */
+ tree object;
+ /* If we actually can tell the type that the object has changed to, it is
+ stored in this field. Otherwise it remains NULL_TREE. */
+ tree known_current_type;
/* Set to true if dynamic type change has been detected. */
bool type_maybe_changed;
+ /* Set to true if multiple types have been encountered. known_current_type
+ must be disregarded in that case. */
+ bool multiple_types_encountered;
};
/* Return true if STMT can modify a virtual method table pointer.
return true;
}
+/* If STMT can be proved to be an assignment to the virtual method table
+ pointer of ANALYZED_OBJ and the type associated with the new table
+ identified, return the type. Otherwise return NULL_TREE. */
+
+static tree
+extr_type_from_vtbl_ptr_store (gimple stmt, struct type_change_info *tci)
+{
+ HOST_WIDE_INT offset, size, max_size;
+ tree lhs, rhs, base;
+
+ if (!gimple_assign_single_p (stmt))
+ return NULL_TREE;
+
+ lhs = gimple_assign_lhs (stmt);
+ rhs = gimple_assign_rhs1 (stmt);
+ if (TREE_CODE (lhs) != COMPONENT_REF
+ || !DECL_VIRTUAL_P (TREE_OPERAND (lhs, 1))
+ || TREE_CODE (rhs) != ADDR_EXPR)
+ return NULL_TREE;
+ rhs = get_base_address (TREE_OPERAND (rhs, 0));
+ if (!rhs
+ || TREE_CODE (rhs) != VAR_DECL
+ || !DECL_VIRTUAL_P (rhs))
+ return NULL_TREE;
+
+ base = get_ref_base_and_extent (lhs, &offset, &size, &max_size);
+ if (offset != tci->offset
+ || size != POINTER_SIZE
+ || max_size != POINTER_SIZE)
+ return NULL_TREE;
+ if (TREE_CODE (base) == MEM_REF)
+ {
+ if (TREE_CODE (tci->object) != MEM_REF
+ || TREE_OPERAND (tci->object, 0) != TREE_OPERAND (base, 0)
+ || !tree_int_cst_equal (TREE_OPERAND (tci->object, 1),
+ TREE_OPERAND (base, 1)))
+ return NULL_TREE;
+ }
+ else if (tci->object != base)
+ return NULL_TREE;
+
+ return DECL_CONTEXT (rhs);
+}
+
/* Callback of walk_aliased_vdefs and a helper function for
detect_type_change to check whether a particular statement may modify
the virtual table pointer, and if possible also determine the new type of
if (stmt_may_be_vtbl_ptr_store (stmt))
{
+ tree type;
+ type = extr_type_from_vtbl_ptr_store (stmt, tci);
+ if (tci->type_maybe_changed
+ && type != tci->known_current_type)
+ tci->multiple_types_encountered = true;
+ tci->known_current_type = type;
tci->type_maybe_changed = true;
return true;
}
return false;
}
-/* Detect whether the dynamic type of ARG has changed (before callsite CALL) by
- looking for assignments to its virtual table pointer. If it is, return true
- and fill in the jump function JFUNC with relevant type information or set it
- to unknown. ARG is the object itself (not a pointer to it, unless
- dereferenced). BASE is the base of the memory access as returned by
- get_ref_base_and_extent, as is the offset. */
+
+
+/* Like detect_type_change but with extra argument COMP_TYPE which will become
+ the component type part of new JFUNC of dynamic type change is detected and
+ the new base type is identified. */
static bool
-detect_type_change (tree arg, tree base, gimple call,
- struct ipa_jump_func *jfunc, HOST_WIDE_INT offset)
+detect_type_change_1 (tree arg, tree base, tree comp_type, gimple call,
+ struct ipa_jump_func *jfunc, HOST_WIDE_INT offset)
{
struct type_change_info tci;
ao_ref ao;
if (!flag_devirtualize || !gimple_vuse (call))
return false;
- tci.type_maybe_changed = false;
-
ao.ref = arg;
ao.base = base;
ao.offset = offset;
ao.ref_alias_set = -1;
ao.base_alias_set = -1;
+ tci.offset = offset;
+ tci.object = get_base_address (arg);
+ tci.known_current_type = NULL_TREE;
+ tci.type_maybe_changed = false;
+ tci.multiple_types_encountered = false;
+
walk_aliased_vdefs (&ao, gimple_vuse (call), check_stmt_for_type_change,
&tci, NULL);
if (!tci.type_maybe_changed)
return false;
- jfunc->type = IPA_JF_UNKNOWN;
+ if (!tci.known_current_type
+ || tci.multiple_types_encountered
+ || 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;
+ }
+
return true;
}
+/* Detect whether the dynamic type of ARG has changed (before callsite CALL) by
+ looking for assignments to its virtual table pointer. If it is, return true
+ and fill in the jump function JFUNC with relevant type information or set it
+ to unknown. ARG is the object itself (not a pointer to it, unless
+ dereferenced). BASE is the base of the memory access as returned by
+ get_ref_base_and_extent, as is the offset. */
+
+static bool
+detect_type_change (tree arg, tree base, gimple call,
+ struct ipa_jump_func *jfunc, HOST_WIDE_INT offset)
+{
+ return detect_type_change_1 (arg, base, TREE_TYPE (arg), call, jfunc, offset);
+}
+
/* Like detect_type_change but ARG is supposed to be a non-dereferenced pointer
SSA name (its dereference will become the base and the offset is assumed to
be zero). */
static bool
detect_type_change_ssa (tree arg, gimple call, struct ipa_jump_func *jfunc)
{
+ tree comp_type;
+
gcc_checking_assert (TREE_CODE (arg) == SSA_NAME);
if (!flag_devirtualize
|| !POINTER_TYPE_P (TREE_TYPE (arg))
|| TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != RECORD_TYPE)
return false;
+ comp_type = TREE_TYPE (TREE_TYPE (arg));
arg = build2 (MEM_REF, ptr_type_node, arg,
- build_int_cst (ptr_type_node, 0));
+ build_int_cst (ptr_type_node, 0));
+
+ return detect_type_change_1 (arg, arg, comp_type, call, jfunc, 0);
+}
+
+/* Callback of walk_aliased_vdefs. Flags that it has been invoked to the
+ boolean variable pointed to by DATA. */
- return detect_type_change (arg, arg, call, jfunc, 0);
+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 STMT. PARM_AINFO is a pointer to a
+ structure containing temporary information about PARM. */
+
+static bool
+is_parm_modified_before_stmt (struct param_analysis_info *parm_ainfo,
+ gimple stmt, tree parm)
+{
+ bool modified = false;
+ ao_ref refd;
+
+ if (parm_ainfo->modified)
+ return true;
+
+ gcc_checking_assert (gimple_vuse (stmt) != NULL_TREE);
+ ao_ref_init (&refd, parm);
+ walk_aliased_vdefs (&refd, gimple_vuse (stmt), mark_modified,
+ &modified, &parm_ainfo->visited_statements);
+ if (modified)
+ {
+ parm_ainfo->modified = true;
+ return true;
+ }
+ return false;
+}
+
+/* If STMT is an assignment that loads a value from an parameter declaration,
+ return the index of the parameter in ipa_node_params which has not been
+ modified. Otherwise return -1. */
+
+static int
+load_from_unmodified_param (struct ipa_node_params *info,
+ struct param_analysis_info *parms_ainfo,
+ gimple stmt)
+{
+ int index;
+ tree op1;
+
+ if (!gimple_assign_single_p (stmt))
+ return -1;
+
+ op1 = gimple_assign_rhs1 (stmt);
+ if (TREE_CODE (op1) != PARM_DECL)
+ return -1;
+
+ index = ipa_get_param_decl_index (info, op1);
+ if (index < 0
+ || is_parm_modified_before_stmt (&parms_ainfo[index], stmt, op1))
+ return -1;
+
+ return index;
+}
/* Given that an actual argument is an SSA_NAME (given in NAME) and is a result
- of an assignment statement STMT, try to find out whether NAME can be
- described by a (possibly polynomial) pass-through jump-function or an
- ancestor jump function and if so, write the appropriate function into
- JFUNC */
+ of an assignment statement STMT, try to determine whether we are actually
+ handling any of the following cases and construct an appropriate jump
+ function into JFUNC if so:
+
+ 1) The passed value is loaded from a formal parameter which is not a gimple
+ register (most probably because it is addressable, the value has to be
+ scalar) and we can guarantee the value has not changed. This case can
+ therefore be described by a simple pass-through jump function. For example:
+
+ foo (int a)
+ {
+ int a.0;
+
+ a.0_2 = a;
+ bar (a.0_2);
+
+ 2) The passed value can be described by a simple arithmetic pass-through
+ jump function. E.g.
+
+ foo (int a)
+ {
+ int D.2064;
+
+ D.2064_4 = a.1(D) + 4;
+ bar (D.2064_4);
+
+ This case can also occur in combination of the previous one, e.g.:
+
+ foo (int a, int z)
+ {
+ int a.0;
+ int D.2064;
+
+ a.0_3 = a;
+ D.2064_4 = a.0_3 + 4;
+ foo (D.2064_4);
+
+ 3) The passed value is an address of an object within another one (which
+ also passed by reference). Such situations are described by an ancestor
+ jump function and describe situations such as:
+
+ B::foo() (struct B * const this)
+ {
+ struct A * D.1845;
+
+ D.1845_2 = &this_1(D)->D.1748;
+ A::bar (D.1845_2);
+
+ INFO is the structure describing individual parameters access different
+ stages of IPA optimizations. PARMS_AINFO contains the information that is
+ only needed for intraprocedural analysis. */
static void
compute_complex_assign_jump_func (struct ipa_node_params *info,
+ struct param_analysis_info *parms_ainfo,
struct ipa_jump_func *jfunc,
gimple call, gimple stmt, tree name)
{
HOST_WIDE_INT offset, size, max_size;
- tree op1, op2, base, ssa;
+ tree op1, tc_ssa, base, ssa;
int index;
op1 = gimple_assign_rhs1 (stmt);
- op2 = gimple_assign_rhs2 (stmt);
- if (TREE_CODE (op1) == SSA_NAME
- && SSA_NAME_IS_DEFAULT_DEF (op1))
+ if (TREE_CODE (op1) == SSA_NAME)
{
- index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
- if (index < 0)
- return;
+ if (SSA_NAME_IS_DEFAULT_DEF (op1))
+ index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
+ else
+ index = load_from_unmodified_param (info, parms_ainfo,
+ SSA_NAME_DEF_STMT (op1));
+ tc_ssa = op1;
+ }
+ else
+ {
+ index = load_from_unmodified_param (info, parms_ainfo, stmt);
+ tc_ssa = gimple_assign_lhs (stmt);
+ }
+
+ if (index >= 0)
+ {
+ tree op2 = gimple_assign_rhs2 (stmt);
if (op2)
{
jfunc->value.pass_through.operation = gimple_assign_rhs_code (stmt);
jfunc->value.pass_through.operand = op2;
}
- else if (gimple_assign_unary_nop_p (stmt)
- && !detect_type_change_ssa (op1, call, jfunc))
+ 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;
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);
}
/* Determine the jump functions of scalar arguments. Scalar means SSA names
and constants of a number of selected types. INFO is the ipa_node_params
- structure associated with the caller, FUNCTIONS is a pointer to an array of
- jump function structures associated with CALL which is the call statement
- being examined.*/
+ structure associated with the caller, PARMS_AINFO describes state of
+ analysis with respect to individual formal parameters. ARGS is the
+ ipa_edge_args structure describing the callsite CALL which is the call
+ statement being examined.*/
static void
compute_scalar_jump_functions (struct ipa_node_params *info,
+ struct param_analysis_info *parms_ainfo,
struct ipa_edge_args *args,
gimple call)
{
{
gimple stmt = SSA_NAME_DEF_STMT (arg);
if (is_gimple_assign (stmt))
- compute_complex_assign_jump_func (info, jfunc, call, stmt, arg);
+ compute_complex_assign_jump_func (info, parms_ainfo, jfunc,
+ call, stmt, arg);
else if (gimple_code (stmt) == GIMPLE_PHI)
compute_complex_ancestor_jump_func (info, jfunc, call, stmt);
}
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
static bool
compute_pass_through_member_ptrs (struct ipa_node_params *info,
- struct param_analysis_info *parms_info,
+ struct param_analysis_info *parms_ainfo,
struct ipa_edge_args *args,
gimple call)
{
int index = ipa_get_param_decl_index (info, arg);
gcc_assert (index >=0);
- if (!is_parm_modified_before_call (&parms_info[index], call, arg))
+ if (!is_parm_modified_before_stmt (&parms_ainfo[index], call,
+ arg))
{
struct ipa_jump_func *jfunc = ipa_get_ith_jump_func (args,
num);
to this callsite. */
static void
-ipa_compute_jump_functions_for_edge (struct param_analysis_info *parms_info,
+ipa_compute_jump_functions_for_edge (struct param_analysis_info *parms_ainfo,
struct cgraph_edge *cs)
{
struct ipa_node_params *info = IPA_NODE_REF (cs->caller);
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, args, call);
+ compute_scalar_jump_functions (info, parms_ainfo, 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, args, call))
+ if (!compute_pass_through_member_ptrs (info, parms_ainfo, args, call))
return;
/* Finally, let's check whether we actually pass a new constant member
static void
ipa_compute_jump_functions (struct cgraph_node *node,
- struct param_analysis_info *parms_info)
+ struct param_analysis_info *parms_ainfo)
{
struct cgraph_edge *cs;
functions unless they may become known during lto/whopr. */
if (!callee->analyzed && !flag_lto)
continue;
- ipa_compute_jump_functions_for_edge (parms_info, cs);
+ ipa_compute_jump_functions_for_edge (parms_ainfo, cs);
}
for (cs = node->indirect_calls; cs; cs = cs->next_callee)
- ipa_compute_jump_functions_for_edge (parms_info, cs);
+ ipa_compute_jump_functions_for_edge (parms_ainfo, cs);
}
/* If RHS looks like a rhs of a statement loading pfn from a member
}
/* Analyze the CALL and examine uses of formal parameters of the caller NODE
- (described by INFO). PARMS_INFO is a pointer to a vector containing
+ (described by INFO). PARMS_AINFO 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
static void
ipa_analyze_indirect_call_uses (struct cgraph_node *node,
struct ipa_node_params *info,
- struct param_analysis_info *parms_info,
+ struct param_analysis_info *parms_ainfo,
gimple call, tree target)
{
gimple def;
return;
index = ipa_get_param_decl_index (info, rec);
- if (index >= 0 && !is_parm_modified_before_call (&parms_info[index],
+ if (index >= 0 && !is_parm_modified_before_stmt (&parms_ainfo[index],
call, rec))
ipa_note_param_call (node, index, call);
}
/* Analyze a call statement CALL whether and how it utilizes formal parameters
- of the caller (described by INFO). PARMS_INFO is a pointer to a vector
+ of the caller (described by INFO). PARMS_AINFO 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,
- struct param_analysis_info *parms_info, gimple call)
+ struct param_analysis_info *parms_ainfo, gimple call)
{
tree target = gimple_call_fn (call);
if (!target)
return;
if (TREE_CODE (target) == SSA_NAME)
- ipa_analyze_indirect_call_uses (node, info, parms_info, call, target);
+ ipa_analyze_indirect_call_uses (node, info, parms_ainfo, 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. PARMS_INFO is a pointer to a vector containing
+ parameters are called. PARMS_AINFO 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,
- struct param_analysis_info *parms_info, gimple stmt)
+ struct param_analysis_info *parms_ainfo, gimple stmt)
{
if (is_gimple_call (stmt))
- ipa_analyze_call_uses (node, info, parms_info, stmt);
+ ipa_analyze_call_uses (node, info, parms_ainfo, stmt);
}
/* Callback of walk_stmt_load_store_addr_ops for the visit_load.
/* 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. PARMS_INFO is a pointer to a
+ structure, such as parameter flags, notes etc. PARMS_AINFO is a pointer to a
vector containing intermediate information about each formal parameter. */
static void
ipa_analyze_params_uses (struct cgraph_node *node,
- struct param_analysis_info *parms_info)
+ struct param_analysis_info *parms_ainfo)
{
tree decl = node->decl;
basic_block bb;
if (is_gimple_debug (stmt))
continue;
- ipa_analyze_stmt_uses (node, info, parms_info, stmt);
+ ipa_analyze_stmt_uses (node, info, parms_ainfo, stmt);
walk_stmt_load_store_addr_ops (stmt, info,
visit_ref_for_mod_analysis,
visit_ref_for_mod_analysis,
ipa_analyze_node (struct cgraph_node *node)
{
struct ipa_node_params *info;
- struct param_analysis_info *parms_info;
+ struct param_analysis_info *parms_ainfo;
int i, param_count;
ipa_check_create_node_params ();
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);
+ parms_ainfo = XALLOCAVEC (struct param_analysis_info, param_count);
+ memset (parms_ainfo, 0, sizeof (struct param_analysis_info) * param_count);
- ipa_analyze_params_uses (node, parms_info);
- ipa_compute_jump_functions (node, parms_info);
+ ipa_analyze_params_uses (node, parms_ainfo);
+ ipa_compute_jump_functions (node, parms_ainfo);
for (i = 0; i < param_count; i++)
- if (parms_info[i].visited_statements)
- BITMAP_FREE (parms_info[i].visited_statements);
+ if (parms_ainfo[i].visited_statements)
+ BITMAP_FREE (parms_ainfo[i].visited_statements);
current_function_decl = NULL;
pop_cfun ();
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
try_make_edge_direct_virtual_call (struct cgraph_edge *ie,
struct ipa_jump_func *jfunc)
{
- tree binfo, type, target;
- 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);
+ target = gimple_get_virt_method_for_binfo (ie->indirect_info->otr_token,
+ binfo);
else
return NULL;
case IPA_JF_UNKNOWN:
break;
case IPA_JF_KNOWN_TYPE:
- stream_write_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:
stream_write_tree (ob, jump_func->value.constant, true);
case IPA_JF_UNKNOWN:
break;
case IPA_JF_KNOWN_TYPE:
- jump_func->value.base_binfo = stream_read_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 = stream_read_tree (ib, data_in);
OSDN Git Service
