1 /* Interprocedural analyses.
2 Copyright (C) 2005, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
25 #include "langhooks.h"
30 #include "tree-flow.h"
31 #include "tree-pass.h"
32 #include "tree-inline.h"
37 #include "diagnostic.h"
38 #include "tree-pretty-print.h"
39 #include "gimple-pretty-print.h"
40 #include "lto-streamer.h"
42 /* Vector where the parameter infos are actually stored. */
43 VEC (ipa_node_params_t, heap) *ipa_node_params_vector;
44 /* Vector where the parameter infos are actually stored. */
45 VEC (ipa_edge_args_t, gc) *ipa_edge_args_vector;
47 /* Bitmap with all UIDs of call graph edges that have been already processed
48 by indirect inlining. */
49 static bitmap iinlining_processed_edges;
51 /* Holders of ipa cgraph hooks: */
52 static struct cgraph_edge_hook_list *edge_removal_hook_holder;
53 static struct cgraph_node_hook_list *node_removal_hook_holder;
54 static struct cgraph_2edge_hook_list *edge_duplication_hook_holder;
55 static struct cgraph_2node_hook_list *node_duplication_hook_holder;
57 /* Add cgraph NODE described by INFO to the worklist WL regardless of whether
58 it is in one or not. It should almost never be used directly, as opposed to
59 ipa_push_func_to_list. */
62 ipa_push_func_to_list_1 (struct ipa_func_list **wl,
63 struct cgraph_node *node,
64 struct ipa_node_params *info)
66 struct ipa_func_list *temp;
68 info->node_enqueued = 1;
69 temp = XCNEW (struct ipa_func_list);
75 /* Initialize worklist to contain all functions. */
77 struct ipa_func_list *
78 ipa_init_func_list (void)
80 struct cgraph_node *node;
81 struct ipa_func_list * wl;
84 for (node = cgraph_nodes; node; node = node->next)
87 struct ipa_node_params *info = IPA_NODE_REF (node);
88 /* Unreachable nodes should have been eliminated before ipcp and
90 gcc_assert (node->needed || node->reachable);
91 ipa_push_func_to_list_1 (&wl, node, info);
97 /* Remove a function from the worklist WL and return it. */
100 ipa_pop_func_from_list (struct ipa_func_list **wl)
102 struct ipa_node_params *info;
103 struct ipa_func_list *first;
104 struct cgraph_node *node;
111 info = IPA_NODE_REF (node);
112 info->node_enqueued = 0;
116 /* Return index of the formal whose tree is PTREE in function which corresponds
120 ipa_get_param_decl_index (struct ipa_node_params *info, tree ptree)
124 count = ipa_get_param_count (info);
125 for (i = 0; i < count; i++)
126 if (ipa_get_param(info, i) == ptree)
132 /* Populate the param_decl field in parameter descriptors of INFO that
133 corresponds to NODE. */
136 ipa_populate_param_decls (struct cgraph_node *node,
137 struct ipa_node_params *info)
145 fnargs = DECL_ARGUMENTS (fndecl);
147 for (parm = fnargs; parm; parm = TREE_CHAIN (parm))
149 info->params[param_num].decl = parm;
154 /* Return how many formal parameters FNDECL has. */
157 count_formal_params_1 (tree fndecl)
162 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
168 /* Count number of formal parameters in NOTE. Store the result to the
169 appropriate field of INFO. */
172 ipa_count_formal_params (struct cgraph_node *node,
173 struct ipa_node_params *info)
177 param_num = count_formal_params_1 (node->decl);
178 ipa_set_param_count (info, param_num);
181 /* Initialize the ipa_node_params structure associated with NODE by counting
182 the function parameters, creating the descriptors and populating their
186 ipa_initialize_node_params (struct cgraph_node *node)
188 struct ipa_node_params *info = IPA_NODE_REF (node);
192 ipa_count_formal_params (node, info);
193 info->params = XCNEWVEC (struct ipa_param_descriptor,
194 ipa_get_param_count (info));
195 ipa_populate_param_decls (node, info);
199 /* Callback of walk_stmt_load_store_addr_ops for the visit_store and visit_addr
200 parameters. If OP is a parameter declaration, mark it as modified in the
201 info structure passed in DATA. */
204 visit_store_addr_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED,
207 struct ipa_node_params *info = (struct ipa_node_params *) data;
209 op = get_base_address (op);
211 && TREE_CODE (op) == PARM_DECL)
213 int index = ipa_get_param_decl_index (info, op);
214 gcc_assert (index >= 0);
215 info->params[index].modified = true;
216 info->params[index].used = true;
222 /* Callback of walk_stmt_load_store_addr_ops for the visit_load.
223 If OP is a parameter declaration, mark it as used in the info structure
227 visit_load_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED,
230 struct ipa_node_params *info = (struct ipa_node_params *) data;
232 op = get_base_address (op);
234 && TREE_CODE (op) == PARM_DECL)
236 int index = ipa_get_param_decl_index (info, op);
237 gcc_assert (index >= 0);
238 info->params[index].used = true;
244 /* Compute which formal parameters of function associated with NODE are locally
245 modified or their address is taken. Note that this does not apply on
246 parameters with SSA names but those can and should be analyzed
250 ipa_detect_param_modifications (struct cgraph_node *node)
252 tree decl = node->decl;
254 struct function *func;
255 gimple_stmt_iterator gsi;
256 struct ipa_node_params *info = IPA_NODE_REF (node);
259 if (ipa_get_param_count (info) == 0 || info->modification_analysis_done)
262 for (i = 0; i < ipa_get_param_count (info); i++)
264 tree parm = ipa_get_param (info, i);
265 /* For SSA regs see if parameter is used. For non-SSA we compute
266 the flag during modification analysis. */
267 if (is_gimple_reg (parm)
268 && gimple_default_def (DECL_STRUCT_FUNCTION (node->decl), parm))
269 info->params[i].used = true;
272 func = DECL_STRUCT_FUNCTION (decl);
273 FOR_EACH_BB_FN (bb, func)
275 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
276 walk_stmt_load_store_addr_ops (gsi_stmt (gsi), info,
277 visit_load_for_mod_analysis,
278 visit_store_addr_for_mod_analysis,
279 visit_store_addr_for_mod_analysis);
280 for (gsi = gsi_start (phi_nodes (bb)); !gsi_end_p (gsi); gsi_next (&gsi))
281 walk_stmt_load_store_addr_ops (gsi_stmt (gsi), info,
282 visit_load_for_mod_analysis,
283 visit_store_addr_for_mod_analysis,
284 visit_store_addr_for_mod_analysis);
287 info->modification_analysis_done = 1;
290 /* Count number of arguments callsite CS has and store it in
291 ipa_edge_args structure corresponding to this callsite. */
294 ipa_count_arguments (struct cgraph_edge *cs)
299 stmt = cs->call_stmt;
300 gcc_assert (is_gimple_call (stmt));
301 arg_num = gimple_call_num_args (stmt);
302 if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
303 <= (unsigned) cgraph_edge_max_uid)
304 VEC_safe_grow_cleared (ipa_edge_args_t, gc,
305 ipa_edge_args_vector, cgraph_edge_max_uid + 1);
306 ipa_set_cs_argument_count (IPA_EDGE_REF (cs), arg_num);
309 /* Print the jump functions associated with call graph edge CS to file F. */
312 ipa_print_node_jump_functions_for_edge (FILE *f, struct cgraph_edge *cs)
316 count = ipa_get_cs_argument_count (IPA_EDGE_REF (cs));
317 for (i = 0; i < count; i++)
319 struct ipa_jump_func *jump_func;
320 enum jump_func_type type;
322 jump_func = ipa_get_ith_jump_func (IPA_EDGE_REF (cs), i);
323 type = jump_func->type;
325 fprintf (f, " param %d: ", i);
326 if (type == IPA_JF_UNKNOWN)
327 fprintf (f, "UNKNOWN\n");
328 else if (type == IPA_JF_KNOWN_TYPE)
330 tree binfo_type = TREE_TYPE (jump_func->value.base_binfo);
331 fprintf (f, "KNOWN TYPE, type in binfo is: ");
332 print_generic_expr (f, binfo_type, 0);
333 fprintf (f, " (%u)\n", TYPE_UID (binfo_type));
335 else if (type == IPA_JF_CONST)
337 tree val = jump_func->value.constant;
338 fprintf (f, "CONST: ");
339 print_generic_expr (f, val, 0);
340 if (TREE_CODE (val) == ADDR_EXPR
341 && TREE_CODE (TREE_OPERAND (val, 0)) == CONST_DECL)
344 print_generic_expr (f, DECL_INITIAL (TREE_OPERAND (val, 0)),
349 else if (type == IPA_JF_CONST_MEMBER_PTR)
351 fprintf (f, "CONST MEMBER PTR: ");
352 print_generic_expr (f, jump_func->value.member_cst.pfn, 0);
354 print_generic_expr (f, jump_func->value.member_cst.delta, 0);
357 else if (type == IPA_JF_PASS_THROUGH)
359 fprintf (f, "PASS THROUGH: ");
360 fprintf (f, "%d, op %s ",
361 jump_func->value.pass_through.formal_id,
363 jump_func->value.pass_through.operation]);
364 if (jump_func->value.pass_through.operation != NOP_EXPR)
365 print_generic_expr (dump_file,
366 jump_func->value.pass_through.operand, 0);
367 fprintf (dump_file, "\n");
369 else if (type == IPA_JF_ANCESTOR)
371 fprintf (f, "ANCESTOR: ");
372 fprintf (f, "%d, offset "HOST_WIDE_INT_PRINT_DEC", ",
373 jump_func->value.ancestor.formal_id,
374 jump_func->value.ancestor.offset);
375 print_generic_expr (f, jump_func->value.ancestor.type, 0);
376 fprintf (dump_file, "\n");
382 /* Print the jump functions of all arguments on all call graph edges going from
386 ipa_print_node_jump_functions (FILE *f, struct cgraph_node *node)
388 struct cgraph_edge *cs;
391 fprintf (f, " Jump functions of caller %s:\n", cgraph_node_name (node));
392 for (cs = node->callees; cs; cs = cs->next_callee)
394 if (!ipa_edge_args_info_available_for_edge_p (cs))
397 fprintf (f, " callsite %s/%i -> %s/%i : \n",
398 cgraph_node_name (node), node->uid,
399 cgraph_node_name (cs->callee), cs->callee->uid);
400 ipa_print_node_jump_functions_for_edge (f, cs);
403 for (cs = node->indirect_calls, i = 0; cs; cs = cs->next_callee, i++)
405 if (!ipa_edge_args_info_available_for_edge_p (cs))
410 fprintf (f, " indirect callsite %d for stmt ", i);
411 print_gimple_stmt (f, cs->call_stmt, 0, TDF_SLIM);
414 fprintf (f, " indirect callsite %d :\n", i);
415 ipa_print_node_jump_functions_for_edge (f, cs);
420 /* Print ipa_jump_func data structures of all nodes in the call graph to F. */
423 ipa_print_all_jump_functions (FILE *f)
425 struct cgraph_node *node;
427 fprintf (f, "\nJump functions:\n");
428 for (node = cgraph_nodes; node; node = node->next)
430 ipa_print_node_jump_functions (f, node);
434 /* Given that an actual argument is an SSA_NAME (given in NAME) and is a result
435 of an assignment statement STMT, try to find out whether NAME can be
436 described by a (possibly polynomial) pass-through jump-function or an
437 ancestor jump function and if so, write the appropriate function into
441 compute_complex_assign_jump_func (struct ipa_node_params *info,
442 struct ipa_jump_func *jfunc,
443 gimple stmt, tree name)
445 HOST_WIDE_INT offset, size, max_size;
449 op1 = gimple_assign_rhs1 (stmt);
450 op2 = gimple_assign_rhs2 (stmt);
452 if (TREE_CODE (op1) == SSA_NAME
453 && SSA_NAME_IS_DEFAULT_DEF (op1))
455 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
461 if (!is_gimple_ip_invariant (op2)
462 || (TREE_CODE_CLASS (gimple_expr_code (stmt)) != tcc_comparison
463 && !useless_type_conversion_p (TREE_TYPE (name),
467 jfunc->type = IPA_JF_PASS_THROUGH;
468 jfunc->value.pass_through.formal_id = index;
469 jfunc->value.pass_through.operation = gimple_assign_rhs_code (stmt);
470 jfunc->value.pass_through.operand = op2;
472 else if (gimple_assign_unary_nop_p (stmt))
474 jfunc->type = IPA_JF_PASS_THROUGH;
475 jfunc->value.pass_through.formal_id = index;
476 jfunc->value.pass_through.operation = NOP_EXPR;
481 if (TREE_CODE (op1) != ADDR_EXPR)
484 op1 = TREE_OPERAND (op1, 0);
485 type = TREE_TYPE (op1);
486 if (TREE_CODE (type) != RECORD_TYPE)
488 op1 = get_ref_base_and_extent (op1, &offset, &size, &max_size);
489 if (TREE_CODE (op1) != INDIRECT_REF
490 /* If this is a varying address, punt. */
494 op1 = TREE_OPERAND (op1, 0);
495 if (TREE_CODE (op1) != SSA_NAME
496 || !SSA_NAME_IS_DEFAULT_DEF (op1))
499 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
502 jfunc->type = IPA_JF_ANCESTOR;
503 jfunc->value.ancestor.formal_id = index;
504 jfunc->value.ancestor.offset = offset;
505 jfunc->value.ancestor.type = type;
510 /* Given that an actual argument is an SSA_NAME that is a result of a phi
511 statement PHI, try to find out whether NAME is in fact a
512 multiple-inheritance typecast from a descendant into an ancestor of a formal
513 parameter and thus can be described by an ancestor jump function and if so,
514 write the appropriate function into JFUNC.
516 Essentially we want to match the following pattern:
524 iftmp.1_3 = &obj_2(D)->D.1762;
527 # iftmp.1_1 = PHI <iftmp.1_3(3), 0B(2)>
528 D.1879_6 = middleman_1 (iftmp.1_1, i_5(D));
532 compute_complex_ancestor_jump_func (struct ipa_node_params *info,
533 struct ipa_jump_func *jfunc,
536 HOST_WIDE_INT offset, size, max_size;
538 basic_block phi_bb, assign_bb, cond_bb;
539 tree tmp, parm, expr;
542 if (gimple_phi_num_args (phi) != 2
543 || !integer_zerop (PHI_ARG_DEF (phi, 1)))
546 tmp = PHI_ARG_DEF (phi, 0);
547 if (TREE_CODE (tmp) != SSA_NAME
548 || SSA_NAME_IS_DEFAULT_DEF (tmp)
549 || !POINTER_TYPE_P (TREE_TYPE (tmp))
550 || TREE_CODE (TREE_TYPE (TREE_TYPE (tmp))) != RECORD_TYPE)
553 assign = SSA_NAME_DEF_STMT (tmp);
554 assign_bb = gimple_bb (assign);
555 if (!single_pred_p (assign_bb)
556 || !gimple_assign_single_p (assign))
558 expr = gimple_assign_rhs1 (assign);
560 if (TREE_CODE (expr) != ADDR_EXPR)
562 expr = TREE_OPERAND (expr, 0);
563 expr = get_ref_base_and_extent (expr, &offset, &size, &max_size);
565 if (TREE_CODE (expr) != INDIRECT_REF
566 /* If this is a varying address, punt. */
570 parm = TREE_OPERAND (expr, 0);
571 if (TREE_CODE (parm) != SSA_NAME
572 || !SSA_NAME_IS_DEFAULT_DEF (parm))
575 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (parm));
579 cond_bb = single_pred (assign_bb);
580 cond = last_stmt (cond_bb);
582 || gimple_code (cond) != GIMPLE_COND
583 || gimple_cond_code (cond) != NE_EXPR
584 || gimple_cond_lhs (cond) != parm
585 || !integer_zerop (gimple_cond_rhs (cond)))
589 phi_bb = gimple_bb (phi);
590 for (i = 0; i < 2; i++)
592 basic_block pred = EDGE_PRED (phi_bb, i)->src;
593 if (pred != assign_bb && pred != cond_bb)
597 jfunc->type = IPA_JF_ANCESTOR;
598 jfunc->value.ancestor.formal_id = index;
599 jfunc->value.ancestor.offset = offset;
600 jfunc->value.ancestor.type = TREE_TYPE (TREE_TYPE (tmp));
603 /* Given OP whch is passed as an actual argument to a called function,
604 determine if it is possible to construct a KNOWN_TYPE jump function for it
605 and if so, create one and store it to JFUNC. */
608 compute_known_type_jump_func (tree op, struct ipa_jump_func *jfunc)
612 if (TREE_CODE (op) != ADDR_EXPR)
615 op = TREE_OPERAND (op, 0);
616 binfo = gimple_get_relevant_ref_binfo (op, NULL_TREE);
619 jfunc->type = IPA_JF_KNOWN_TYPE;
620 jfunc->value.base_binfo = binfo;
625 /* Determine the jump functions of scalar arguments. Scalar means SSA names
626 and constants of a number of selected types. INFO is the ipa_node_params
627 structure associated with the caller, FUNCTIONS is a pointer to an array of
628 jump function structures associated with CALL which is the call statement
632 compute_scalar_jump_functions (struct ipa_node_params *info,
633 struct ipa_jump_func *functions,
639 for (num = 0; num < gimple_call_num_args (call); num++)
641 arg = gimple_call_arg (call, num);
643 if (is_gimple_ip_invariant (arg))
645 functions[num].type = IPA_JF_CONST;
646 functions[num].value.constant = arg;
648 else if (TREE_CODE (arg) == SSA_NAME)
650 if (SSA_NAME_IS_DEFAULT_DEF (arg))
652 int index = ipa_get_param_decl_index (info, SSA_NAME_VAR (arg));
656 functions[num].type = IPA_JF_PASS_THROUGH;
657 functions[num].value.pass_through.formal_id = index;
658 functions[num].value.pass_through.operation = NOP_EXPR;
663 gimple stmt = SSA_NAME_DEF_STMT (arg);
664 if (is_gimple_assign (stmt))
665 compute_complex_assign_jump_func (info, &functions[num],
667 else if (gimple_code (stmt) == GIMPLE_PHI)
668 compute_complex_ancestor_jump_func (info, &functions[num],
673 compute_known_type_jump_func (arg, &functions[num]);
677 /* Inspect the given TYPE and return true iff it has the same structure (the
678 same number of fields of the same types) as a C++ member pointer. If
679 METHOD_PTR and DELTA are non-NULL, store the trees representing the
680 corresponding fields there. */
683 type_like_member_ptr_p (tree type, tree *method_ptr, tree *delta)
687 if (TREE_CODE (type) != RECORD_TYPE)
690 fld = TYPE_FIELDS (type);
691 if (!fld || !POINTER_TYPE_P (TREE_TYPE (fld))
692 || TREE_CODE (TREE_TYPE (TREE_TYPE (fld))) != METHOD_TYPE)
698 fld = TREE_CHAIN (fld);
699 if (!fld || INTEGRAL_TYPE_P (fld))
704 if (TREE_CHAIN (fld))
710 /* Go through arguments of the CALL and for every one that looks like a member
711 pointer, check whether it can be safely declared pass-through and if so,
712 mark that to the corresponding item of jump FUNCTIONS. Return true iff
713 there are non-pass-through member pointers within the arguments. INFO
714 describes formal parameters of the caller. */
717 compute_pass_through_member_ptrs (struct ipa_node_params *info,
718 struct ipa_jump_func *functions,
721 bool undecided_members = false;
725 for (num = 0; num < gimple_call_num_args (call); num++)
727 arg = gimple_call_arg (call, num);
729 if (type_like_member_ptr_p (TREE_TYPE (arg), NULL, NULL))
731 if (TREE_CODE (arg) == PARM_DECL)
733 int index = ipa_get_param_decl_index (info, arg);
735 gcc_assert (index >=0);
736 if (!ipa_is_param_modified (info, index))
738 functions[num].type = IPA_JF_PASS_THROUGH;
739 functions[num].value.pass_through.formal_id = index;
740 functions[num].value.pass_through.operation = NOP_EXPR;
743 undecided_members = true;
746 undecided_members = true;
750 return undecided_members;
753 /* Simple function filling in a member pointer constant jump function (with PFN
754 and DELTA as the constant value) into JFUNC. */
757 fill_member_ptr_cst_jump_function (struct ipa_jump_func *jfunc,
758 tree pfn, tree delta)
760 jfunc->type = IPA_JF_CONST_MEMBER_PTR;
761 jfunc->value.member_cst.pfn = pfn;
762 jfunc->value.member_cst.delta = delta;
765 /* If RHS is an SSA_NAMe and it is defined by a simple copy assign statement,
766 return the rhs of its defining statement. */
769 get_ssa_def_if_simple_copy (tree rhs)
771 while (TREE_CODE (rhs) == SSA_NAME && !SSA_NAME_IS_DEFAULT_DEF (rhs))
773 gimple def_stmt = SSA_NAME_DEF_STMT (rhs);
775 if (gimple_assign_single_p (def_stmt))
776 rhs = gimple_assign_rhs1 (def_stmt);
783 /* Traverse statements from CALL backwards, scanning whether the argument ARG
784 which is a member pointer is filled in with constant values. If it is, fill
785 the jump function JFUNC in appropriately. METHOD_FIELD and DELTA_FIELD are
786 fields of the record type of the member pointer. To give an example, we
787 look for a pattern looking like the following:
789 D.2515.__pfn ={v} printStuff;
790 D.2515.__delta ={v} 0;
791 i_1 = doprinting (D.2515); */
794 determine_cst_member_ptr (gimple call, tree arg, tree method_field,
795 tree delta_field, struct ipa_jump_func *jfunc)
797 gimple_stmt_iterator gsi;
798 tree method = NULL_TREE;
799 tree delta = NULL_TREE;
801 gsi = gsi_for_stmt (call);
804 for (; !gsi_end_p (gsi); gsi_prev (&gsi))
806 gimple stmt = gsi_stmt (gsi);
809 if (!stmt_may_clobber_ref_p (stmt, arg))
811 if (!gimple_assign_single_p (stmt))
814 lhs = gimple_assign_lhs (stmt);
815 rhs = gimple_assign_rhs1 (stmt);
817 if (TREE_CODE (lhs) != COMPONENT_REF
818 || TREE_OPERAND (lhs, 0) != arg)
821 fld = TREE_OPERAND (lhs, 1);
822 if (!method && fld == method_field)
824 rhs = get_ssa_def_if_simple_copy (rhs);
825 if (TREE_CODE (rhs) == ADDR_EXPR
826 && TREE_CODE (TREE_OPERAND (rhs, 0)) == FUNCTION_DECL
827 && TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs, 0))) == METHOD_TYPE)
829 method = TREE_OPERAND (rhs, 0);
832 fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
840 if (!delta && fld == delta_field)
842 rhs = get_ssa_def_if_simple_copy (rhs);
843 if (TREE_CODE (rhs) == INTEGER_CST)
848 fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
860 /* Go through the arguments of the CALL and for every member pointer within
861 tries determine whether it is a constant. If it is, create a corresponding
862 constant jump function in FUNCTIONS which is an array of jump functions
863 associated with the call. */
866 compute_cst_member_ptr_arguments (struct ipa_jump_func *functions,
870 tree arg, method_field, delta_field;
872 for (num = 0; num < gimple_call_num_args (call); num++)
874 arg = gimple_call_arg (call, num);
876 if (functions[num].type == IPA_JF_UNKNOWN
877 && type_like_member_ptr_p (TREE_TYPE (arg), &method_field,
879 determine_cst_member_ptr (call, arg, method_field, delta_field,
884 /* Compute jump function for all arguments of callsite CS and insert the
885 information in the jump_functions array in the ipa_edge_args corresponding
889 ipa_compute_jump_functions_for_edge (struct cgraph_edge *cs)
891 struct ipa_node_params *info = IPA_NODE_REF (cs->caller);
892 struct ipa_edge_args *arguments = IPA_EDGE_REF (cs);
895 if (ipa_get_cs_argument_count (arguments) == 0 || arguments->jump_functions)
897 arguments->jump_functions = ggc_alloc_cleared_vec_ipa_jump_func
898 (ipa_get_cs_argument_count (arguments));
900 call = cs->call_stmt;
901 gcc_assert (is_gimple_call (call));
903 /* We will deal with constants and SSA scalars first: */
904 compute_scalar_jump_functions (info, arguments->jump_functions, call);
906 /* Let's check whether there are any potential member pointers and if so,
907 whether we can determine their functions as pass_through. */
908 if (!compute_pass_through_member_ptrs (info, arguments->jump_functions, call))
911 /* Finally, let's check whether we actually pass a new constant member
913 compute_cst_member_ptr_arguments (arguments->jump_functions, call);
916 /* Compute jump functions for all edges - both direct and indirect - outgoing
917 from NODE. Also count the actual arguments in the process. */
920 ipa_compute_jump_functions (struct cgraph_node *node)
922 struct cgraph_edge *cs;
924 for (cs = node->callees; cs; cs = cs->next_callee)
926 /* We do not need to bother analyzing calls to unknown
927 functions unless they may become known during lto/whopr. */
928 if (!cs->callee->analyzed && !flag_lto && !flag_whopr)
930 ipa_count_arguments (cs);
931 if (ipa_get_cs_argument_count (IPA_EDGE_REF (cs))
932 != ipa_get_param_count (IPA_NODE_REF (cs->callee)))
933 ipa_set_called_with_variable_arg (IPA_NODE_REF (cs->callee));
934 ipa_compute_jump_functions_for_edge (cs);
937 for (cs = node->indirect_calls; cs; cs = cs->next_callee)
939 ipa_count_arguments (cs);
940 ipa_compute_jump_functions_for_edge (cs);
944 /* If RHS looks like a rhs of a statement loading pfn from a member
945 pointer formal parameter, return the parameter, otherwise return
946 NULL. If USE_DELTA, then we look for a use of the delta field
947 rather than the pfn. */
950 ipa_get_member_ptr_load_param (tree rhs, bool use_delta)
956 if (TREE_CODE (rhs) != COMPONENT_REF)
959 rec = TREE_OPERAND (rhs, 0);
960 if (TREE_CODE (rec) != PARM_DECL
961 || !type_like_member_ptr_p (TREE_TYPE (rec), &ptr_field, &delta_field))
964 fld = TREE_OPERAND (rhs, 1);
965 if (use_delta ? (fld == delta_field) : (fld == ptr_field))
971 /* If STMT looks like a statement loading a value from a member pointer formal
972 parameter, this function returns that parameter. */
975 ipa_get_stmt_member_ptr_load_param (gimple stmt, bool use_delta)
979 if (!gimple_assign_single_p (stmt))
982 rhs = gimple_assign_rhs1 (stmt);
983 return ipa_get_member_ptr_load_param (rhs, use_delta);
986 /* Returns true iff T is an SSA_NAME defined by a statement. */
989 ipa_is_ssa_with_stmt_def (tree t)
991 if (TREE_CODE (t) == SSA_NAME
992 && !SSA_NAME_IS_DEFAULT_DEF (t))
998 /* Find the indirect call graph edge corresponding to STMT and add to it all
999 information necessary to describe a call to a parameter number PARAM_INDEX.
1000 NODE is the caller. POLYMORPHIC should be set to true iff the call is a
1004 ipa_note_param_call (struct cgraph_node *node, int param_index, gimple stmt,
1007 struct cgraph_edge *cs;
1009 cs = cgraph_edge (node, stmt);
1010 cs->indirect_info->param_index = param_index;
1011 cs->indirect_info->anc_offset = 0;
1012 cs->indirect_info->polymorphic = polymorphic;
1015 tree otr = gimple_call_fn (stmt);
1016 tree type, token = OBJ_TYPE_REF_TOKEN (otr);
1017 cs->indirect_info->otr_token = tree_low_cst (token, 1);
1018 type = TREE_TYPE (TREE_TYPE (OBJ_TYPE_REF_OBJECT (otr)));
1019 cs->indirect_info->otr_type = type;
1023 /* Analyze the CALL and examine uses of formal parameters of the caller NODE
1024 (described by INFO). Currently it checks whether the call calls a pointer
1025 that is a formal parameter and if so, the parameter is marked with the
1026 called flag and an indirect call graph edge describing the call is created.
1027 This is very simple for ordinary pointers represented in SSA but not-so-nice
1028 when it comes to member pointers. The ugly part of this function does
1029 nothing more than trying to match the pattern of such a call. An example of
1030 such a pattern is the gimple dump below, the call is on the last line:
1033 f$__delta_5 = f.__delta;
1034 f$__pfn_24 = f.__pfn;
1039 D.2496_3 = (int) f$__pfn_24;
1040 D.2497_4 = D.2496_3 & 1;
1047 D.2500_7 = (unsigned int) f$__delta_5;
1048 D.2501_8 = &S + D.2500_7;
1049 D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8;
1050 D.2503_10 = *D.2502_9;
1051 D.2504_12 = f$__pfn_24 + -1;
1052 D.2505_13 = (unsigned int) D.2504_12;
1053 D.2506_14 = D.2503_10 + D.2505_13;
1054 D.2507_15 = *D.2506_14;
1055 iftmp.11_16 = (String:: *) D.2507_15;
1058 # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)>
1059 D.2500_19 = (unsigned int) f$__delta_5;
1060 D.2508_20 = &S + D.2500_19;
1061 D.2493_21 = iftmp.11_1 (D.2508_20, 4);
1063 Such patterns are results of simple calls to a member pointer:
1065 int doprinting (int (MyString::* f)(int) const)
1067 MyString S ("somestring");
1074 ipa_analyze_indirect_call_uses (struct cgraph_node *node,
1075 struct ipa_node_params *info,
1076 gimple call, tree target)
1081 tree rec, rec2, cond;
1084 basic_block bb, virt_bb, join;
1086 if (SSA_NAME_IS_DEFAULT_DEF (target))
1088 tree var = SSA_NAME_VAR (target);
1089 index = ipa_get_param_decl_index (info, var);
1091 ipa_note_param_call (node, index, call, false);
1095 /* Now we need to try to match the complex pattern of calling a member
1098 if (!POINTER_TYPE_P (TREE_TYPE (target))
1099 || TREE_CODE (TREE_TYPE (TREE_TYPE (target))) != METHOD_TYPE)
1102 def = SSA_NAME_DEF_STMT (target);
1103 if (gimple_code (def) != GIMPLE_PHI)
1106 if (gimple_phi_num_args (def) != 2)
1109 /* First, we need to check whether one of these is a load from a member
1110 pointer that is a parameter to this function. */
1111 n1 = PHI_ARG_DEF (def, 0);
1112 n2 = PHI_ARG_DEF (def, 1);
1113 if (!ipa_is_ssa_with_stmt_def (n1) || !ipa_is_ssa_with_stmt_def (n2))
1115 d1 = SSA_NAME_DEF_STMT (n1);
1116 d2 = SSA_NAME_DEF_STMT (n2);
1118 join = gimple_bb (def);
1119 if ((rec = ipa_get_stmt_member_ptr_load_param (d1, false)))
1121 if (ipa_get_stmt_member_ptr_load_param (d2, false))
1124 bb = EDGE_PRED (join, 0)->src;
1125 virt_bb = gimple_bb (d2);
1127 else if ((rec = ipa_get_stmt_member_ptr_load_param (d2, false)))
1129 bb = EDGE_PRED (join, 1)->src;
1130 virt_bb = gimple_bb (d1);
1135 /* Second, we need to check that the basic blocks are laid out in the way
1136 corresponding to the pattern. */
1138 if (!single_pred_p (virt_bb) || !single_succ_p (virt_bb)
1139 || single_pred (virt_bb) != bb
1140 || single_succ (virt_bb) != join)
1143 /* Third, let's see that the branching is done depending on the least
1144 significant bit of the pfn. */
1146 branch = last_stmt (bb);
1147 if (!branch || gimple_code (branch) != GIMPLE_COND)
1150 if (gimple_cond_code (branch) != NE_EXPR
1151 || !integer_zerop (gimple_cond_rhs (branch)))
1154 cond = gimple_cond_lhs (branch);
1155 if (!ipa_is_ssa_with_stmt_def (cond))
1158 def = SSA_NAME_DEF_STMT (cond);
1159 if (!is_gimple_assign (def)
1160 || gimple_assign_rhs_code (def) != BIT_AND_EXPR
1161 || !integer_onep (gimple_assign_rhs2 (def)))
1164 cond = gimple_assign_rhs1 (def);
1165 if (!ipa_is_ssa_with_stmt_def (cond))
1168 def = SSA_NAME_DEF_STMT (cond);
1170 if (is_gimple_assign (def)
1171 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def)))
1173 cond = gimple_assign_rhs1 (def);
1174 if (!ipa_is_ssa_with_stmt_def (cond))
1176 def = SSA_NAME_DEF_STMT (cond);
1179 rec2 = ipa_get_stmt_member_ptr_load_param (def,
1180 (TARGET_PTRMEMFUNC_VBIT_LOCATION
1181 == ptrmemfunc_vbit_in_delta));
1186 index = ipa_get_param_decl_index (info, rec);
1187 if (index >= 0 && !ipa_is_param_modified (info, index))
1188 ipa_note_param_call (node, index, call, false);
1193 /* Analyze a CALL to an OBJ_TYPE_REF which is passed in TARGET and if the
1194 object referenced in the expression is a formal parameter of the caller
1195 (described by INFO), create a call note for the statement. */
1198 ipa_analyze_virtual_call_uses (struct cgraph_node *node,
1199 struct ipa_node_params *info, gimple call,
1202 tree obj = OBJ_TYPE_REF_OBJECT (target);
1206 if (TREE_CODE (obj) == ADDR_EXPR)
1210 obj = TREE_OPERAND (obj, 0);
1212 while (TREE_CODE (obj) == COMPONENT_REF);
1213 if (TREE_CODE (obj) != INDIRECT_REF)
1215 obj = TREE_OPERAND (obj, 0);
1218 if (TREE_CODE (obj) != SSA_NAME
1219 || !SSA_NAME_IS_DEFAULT_DEF (obj))
1222 var = SSA_NAME_VAR (obj);
1223 index = ipa_get_param_decl_index (info, var);
1226 ipa_note_param_call (node, index, call, true);
1229 /* Analyze a call statement CALL whether and how it utilizes formal parameters
1230 of the caller (described by INFO). */
1233 ipa_analyze_call_uses (struct cgraph_node *node,
1234 struct ipa_node_params *info, gimple call)
1236 tree target = gimple_call_fn (call);
1238 if (TREE_CODE (target) == SSA_NAME)
1239 ipa_analyze_indirect_call_uses (node, info, call, target);
1240 else if (TREE_CODE (target) == OBJ_TYPE_REF)
1241 ipa_analyze_virtual_call_uses (node, info, call, target);
1245 /* Analyze the call statement STMT with respect to formal parameters (described
1246 in INFO) of caller given by NODE. Currently it only checks whether formal
1247 parameters are called. */
1250 ipa_analyze_stmt_uses (struct cgraph_node *node, struct ipa_node_params *info,
1253 if (is_gimple_call (stmt))
1254 ipa_analyze_call_uses (node, info, stmt);
1257 /* Scan the function body of NODE and inspect the uses of formal parameters.
1258 Store the findings in various structures of the associated ipa_node_params
1259 structure, such as parameter flags, notes etc. */
1262 ipa_analyze_params_uses (struct cgraph_node *node)
1264 tree decl = node->decl;
1266 struct function *func;
1267 gimple_stmt_iterator gsi;
1268 struct ipa_node_params *info = IPA_NODE_REF (node);
1270 if (ipa_get_param_count (info) == 0 || info->uses_analysis_done)
1273 func = DECL_STRUCT_FUNCTION (decl);
1274 FOR_EACH_BB_FN (bb, func)
1276 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1278 gimple stmt = gsi_stmt (gsi);
1279 ipa_analyze_stmt_uses (node, info, stmt);
1283 info->uses_analysis_done = 1;
1286 /* Update the jump function DST when the call graph edge correspondng to SRC is
1287 is being inlined, knowing that DST is of type ancestor and src of known
1291 combine_known_type_and_ancestor_jfs (struct ipa_jump_func *src,
1292 struct ipa_jump_func *dst)
1296 new_binfo = get_binfo_at_offset (src->value.base_binfo,
1297 dst->value.ancestor.offset,
1298 dst->value.ancestor.type);
1301 dst->type = IPA_JF_KNOWN_TYPE;
1302 dst->value.base_binfo = new_binfo;
1305 dst->type = IPA_JF_UNKNOWN;
1308 /* Update the jump functions associated with call graph edge E when the call
1309 graph edge CS is being inlined, assuming that E->caller is already (possibly
1310 indirectly) inlined into CS->callee and that E has not been inlined. */
1313 update_jump_functions_after_inlining (struct cgraph_edge *cs,
1314 struct cgraph_edge *e)
1316 struct ipa_edge_args *top = IPA_EDGE_REF (cs);
1317 struct ipa_edge_args *args = IPA_EDGE_REF (e);
1318 int count = ipa_get_cs_argument_count (args);
1321 for (i = 0; i < count; i++)
1323 struct ipa_jump_func *dst = ipa_get_ith_jump_func (args, i);
1325 if (dst->type == IPA_JF_ANCESTOR)
1327 struct ipa_jump_func *src;
1329 /* Variable number of arguments can cause havoc if we try to access
1330 one that does not exist in the inlined edge. So make sure we
1332 if (dst->value.ancestor.formal_id >= ipa_get_cs_argument_count (top))
1334 dst->type = IPA_JF_UNKNOWN;
1338 src = ipa_get_ith_jump_func (top, dst->value.ancestor.formal_id);
1339 if (src->type == IPA_JF_KNOWN_TYPE)
1340 combine_known_type_and_ancestor_jfs (src, dst);
1341 else if (src->type == IPA_JF_CONST)
1343 struct ipa_jump_func kt_func;
1345 kt_func.type = IPA_JF_UNKNOWN;
1346 compute_known_type_jump_func (src->value.constant, &kt_func);
1347 if (kt_func.type == IPA_JF_KNOWN_TYPE)
1348 combine_known_type_and_ancestor_jfs (&kt_func, dst);
1350 dst->type = IPA_JF_UNKNOWN;
1352 else if (src->type == IPA_JF_PASS_THROUGH
1353 && src->value.pass_through.operation == NOP_EXPR)
1354 dst->value.ancestor.formal_id = src->value.pass_through.formal_id;
1355 else if (src->type == IPA_JF_ANCESTOR)
1357 dst->value.ancestor.formal_id = src->value.ancestor.formal_id;
1358 dst->value.ancestor.offset += src->value.ancestor.offset;
1361 dst->type = IPA_JF_UNKNOWN;
1363 else if (dst->type == IPA_JF_PASS_THROUGH)
1365 struct ipa_jump_func *src;
1366 /* We must check range due to calls with variable number of arguments
1367 and we cannot combine jump functions with operations. */
1368 if (dst->value.pass_through.operation == NOP_EXPR
1369 && (dst->value.pass_through.formal_id
1370 < ipa_get_cs_argument_count (top)))
1372 src = ipa_get_ith_jump_func (top,
1373 dst->value.pass_through.formal_id);
1377 dst->type = IPA_JF_UNKNOWN;
1382 /* If TARGET is an addr_expr of a function declaration, make it the destination
1383 of an indirect edge IE and return the edge. Otherwise, return NULL. */
1385 static struct cgraph_edge *
1386 make_edge_direct_to_target (struct cgraph_edge *ie, tree target)
1388 struct cgraph_node *callee;
1390 if (TREE_CODE (target) != ADDR_EXPR)
1392 target = TREE_OPERAND (target, 0);
1393 if (TREE_CODE (target) != FUNCTION_DECL)
1395 callee = cgraph_node (target);
1399 cgraph_make_edge_direct (ie, callee);
1402 fprintf (dump_file, "ipa-prop: Discovered %s call to a known target "
1403 "(%s/%i -> %s/%i) for stmt ",
1404 ie->indirect_info->polymorphic ? "a virtual" : "an indirect",
1405 cgraph_node_name (ie->caller), ie->caller->uid,
1406 cgraph_node_name (ie->callee), ie->callee->uid);
1409 print_gimple_stmt (dump_file, ie->call_stmt, 2, TDF_SLIM);
1411 fprintf (dump_file, "with uid %i\n", ie->lto_stmt_uid);
1414 if (ipa_get_cs_argument_count (IPA_EDGE_REF (ie))
1415 != ipa_get_param_count (IPA_NODE_REF (callee)))
1416 ipa_set_called_with_variable_arg (IPA_NODE_REF (callee));
1421 /* Try to find a destination for indirect edge IE that corresponds to a simple
1422 call or a call of a member function pointer and where the destination is a
1423 pointer formal parameter described by jump function JFUNC. If it can be
1424 determined, return the newly direct edge, otherwise return NULL. */
1426 static struct cgraph_edge *
1427 try_make_edge_direct_simple_call (struct cgraph_edge *ie,
1428 struct ipa_jump_func *jfunc)
1432 if (jfunc->type == IPA_JF_CONST)
1433 target = jfunc->value.constant;
1434 else if (jfunc->type == IPA_JF_CONST_MEMBER_PTR)
1435 target = jfunc->value.member_cst.pfn;
1439 return make_edge_direct_to_target (ie, target);
1442 /* Try to find a destination for indirect edge IE that corresponds to a
1443 virtuall call based on a formal parameter which is described by jump
1444 function JFUNC and if it can be determined, make it direct and return the
1445 direct edge. Otherwise, return NULL. */
1447 static struct cgraph_edge *
1448 try_make_edge_direct_virtual_call (struct cgraph_edge *ie,
1449 struct ipa_jump_func *jfunc)
1451 tree binfo, type, target;
1452 HOST_WIDE_INT token;
1454 if (jfunc->type == IPA_JF_KNOWN_TYPE)
1455 binfo = jfunc->value.base_binfo;
1456 else if (jfunc->type == IPA_JF_CONST)
1458 tree cst = jfunc->value.constant;
1459 if (TREE_CODE (cst) == ADDR_EXPR)
1460 binfo = gimple_get_relevant_ref_binfo (TREE_OPERAND (cst, 0),
1471 token = ie->indirect_info->otr_token;
1472 type = ie->indirect_info->otr_type;
1473 binfo = get_binfo_at_offset (binfo, ie->indirect_info->anc_offset, type);
1475 target = gimple_fold_obj_type_ref_known_binfo (token, binfo);
1480 return make_edge_direct_to_target (ie, target);
1485 /* Update the param called notes associated with NODE when CS is being inlined,
1486 assuming NODE is (potentially indirectly) inlined into CS->callee.
1487 Moreover, if the callee is discovered to be constant, create a new cgraph
1488 edge for it. Newly discovered indirect edges will be added to *NEW_EDGES,
1489 unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
1492 update_indirect_edges_after_inlining (struct cgraph_edge *cs,
1493 struct cgraph_node *node,
1494 VEC (cgraph_edge_p, heap) **new_edges)
1496 struct ipa_edge_args *top = IPA_EDGE_REF (cs);
1497 struct cgraph_edge *ie, *next_ie, *new_direct_edge;
1500 ipa_check_create_edge_args ();
1502 for (ie = node->indirect_calls; ie; ie = next_ie)
1504 struct cgraph_indirect_call_info *ici = ie->indirect_info;
1505 struct ipa_jump_func *jfunc;
1507 next_ie = ie->next_callee;
1508 if (bitmap_bit_p (iinlining_processed_edges, ie->uid))
1511 /* If we ever use indirect edges for anything other than indirect
1512 inlining, we will need to skip those with negative param_indices. */
1513 if (ici->param_index == -1)
1516 /* We must check range due to calls with variable number of arguments: */
1517 if (ici->param_index >= ipa_get_cs_argument_count (top))
1519 bitmap_set_bit (iinlining_processed_edges, ie->uid);
1523 jfunc = ipa_get_ith_jump_func (top, ici->param_index);
1524 if (jfunc->type == IPA_JF_PASS_THROUGH
1525 && jfunc->value.pass_through.operation == NOP_EXPR)
1526 ici->param_index = jfunc->value.pass_through.formal_id;
1527 else if (jfunc->type == IPA_JF_ANCESTOR)
1529 ici->param_index = jfunc->value.ancestor.formal_id;
1530 ici->anc_offset += jfunc->value.ancestor.offset;
1533 /* Either we can find a destination for this edge now or never. */
1534 bitmap_set_bit (iinlining_processed_edges, ie->uid);
1536 if (ici->polymorphic)
1537 new_direct_edge = try_make_edge_direct_virtual_call (ie, jfunc);
1539 new_direct_edge = try_make_edge_direct_simple_call (ie, jfunc);
1541 if (new_direct_edge)
1543 new_direct_edge->indirect_inlining_edge = 1;
1546 VEC_safe_push (cgraph_edge_p, heap, *new_edges,
1548 top = IPA_EDGE_REF (cs);
1557 /* Recursively traverse subtree of NODE (including node) made of inlined
1558 cgraph_edges when CS has been inlined and invoke
1559 update_indirect_edges_after_inlining on all nodes and
1560 update_jump_functions_after_inlining on all non-inlined edges that lead out
1561 of this subtree. Newly discovered indirect edges will be added to
1562 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were
1566 propagate_info_to_inlined_callees (struct cgraph_edge *cs,
1567 struct cgraph_node *node,
1568 VEC (cgraph_edge_p, heap) **new_edges)
1570 struct cgraph_edge *e;
1573 res = update_indirect_edges_after_inlining (cs, node, new_edges);
1575 for (e = node->callees; e; e = e->next_callee)
1576 if (!e->inline_failed)
1577 res |= propagate_info_to_inlined_callees (cs, e->callee, new_edges);
1579 update_jump_functions_after_inlining (cs, e);
1584 /* Update jump functions and call note functions on inlining the call site CS.
1585 CS is expected to lead to a node already cloned by
1586 cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to
1587 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were +
1591 ipa_propagate_indirect_call_infos (struct cgraph_edge *cs,
1592 VEC (cgraph_edge_p, heap) **new_edges)
1594 /* FIXME lto: We do not stream out indirect call information. */
1598 /* Do nothing if the preparation phase has not been carried out yet
1599 (i.e. during early inlining). */
1600 if (!ipa_node_params_vector)
1602 gcc_assert (ipa_edge_args_vector);
1604 return propagate_info_to_inlined_callees (cs, cs->callee, new_edges);
1607 /* Frees all dynamically allocated structures that the argument info points
1611 ipa_free_edge_args_substructures (struct ipa_edge_args *args)
1613 if (args->jump_functions)
1614 ggc_free (args->jump_functions);
1616 memset (args, 0, sizeof (*args));
1619 /* Free all ipa_edge structures. */
1622 ipa_free_all_edge_args (void)
1625 struct ipa_edge_args *args;
1628 VEC_iterate (ipa_edge_args_t, ipa_edge_args_vector, i, args);
1630 ipa_free_edge_args_substructures (args);
1632 VEC_free (ipa_edge_args_t, gc, ipa_edge_args_vector);
1633 ipa_edge_args_vector = NULL;
1636 /* Frees all dynamically allocated structures that the param info points
1640 ipa_free_node_params_substructures (struct ipa_node_params *info)
1643 free (info->params);
1645 memset (info, 0, sizeof (*info));
1648 /* Free all ipa_node_params structures. */
1651 ipa_free_all_node_params (void)
1654 struct ipa_node_params *info;
1657 VEC_iterate (ipa_node_params_t, ipa_node_params_vector, i, info);
1659 ipa_free_node_params_substructures (info);
1661 VEC_free (ipa_node_params_t, heap, ipa_node_params_vector);
1662 ipa_node_params_vector = NULL;
1665 /* Hook that is called by cgraph.c when an edge is removed. */
1668 ipa_edge_removal_hook (struct cgraph_edge *cs, void *data ATTRIBUTE_UNUSED)
1670 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1671 if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
1672 <= (unsigned)cs->uid)
1674 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs));
1677 /* Hook that is called by cgraph.c when a node is removed. */
1680 ipa_node_removal_hook (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
1682 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1683 if (VEC_length (ipa_node_params_t, ipa_node_params_vector)
1684 <= (unsigned)node->uid)
1686 ipa_free_node_params_substructures (IPA_NODE_REF (node));
1689 /* Helper function to duplicate an array of size N that is at SRC and store a
1690 pointer to it to DST. Nothing is done if SRC is NULL. */
1693 duplicate_array (void *src, size_t n)
1705 static struct ipa_jump_func *
1706 duplicate_ipa_jump_func_array (const struct ipa_jump_func * src, size_t n)
1708 struct ipa_jump_func *p;
1713 p = ggc_alloc_vec_ipa_jump_func (n);
1714 memcpy (p, src, n * sizeof (struct ipa_jump_func));
1718 /* Hook that is called by cgraph.c when a node is duplicated. */
1721 ipa_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst,
1722 __attribute__((unused)) void *data)
1724 struct ipa_edge_args *old_args, *new_args;
1727 ipa_check_create_edge_args ();
1729 old_args = IPA_EDGE_REF (src);
1730 new_args = IPA_EDGE_REF (dst);
1732 arg_count = ipa_get_cs_argument_count (old_args);
1733 ipa_set_cs_argument_count (new_args, arg_count);
1734 new_args->jump_functions =
1735 duplicate_ipa_jump_func_array (old_args->jump_functions, arg_count);
1737 if (iinlining_processed_edges
1738 && bitmap_bit_p (iinlining_processed_edges, src->uid))
1739 bitmap_set_bit (iinlining_processed_edges, dst->uid);
1742 /* Hook that is called by cgraph.c when a node is duplicated. */
1745 ipa_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst,
1746 __attribute__((unused)) void *data)
1748 struct ipa_node_params *old_info, *new_info;
1751 ipa_check_create_node_params ();
1752 old_info = IPA_NODE_REF (src);
1753 new_info = IPA_NODE_REF (dst);
1754 param_count = ipa_get_param_count (old_info);
1756 ipa_set_param_count (new_info, param_count);
1757 new_info->params = (struct ipa_param_descriptor *)
1758 duplicate_array (old_info->params,
1759 sizeof (struct ipa_param_descriptor) * param_count);
1760 new_info->ipcp_orig_node = old_info->ipcp_orig_node;
1761 new_info->count_scale = old_info->count_scale;
1764 /* Register our cgraph hooks if they are not already there. */
1767 ipa_register_cgraph_hooks (void)
1769 if (!edge_removal_hook_holder)
1770 edge_removal_hook_holder =
1771 cgraph_add_edge_removal_hook (&ipa_edge_removal_hook, NULL);
1772 if (!node_removal_hook_holder)
1773 node_removal_hook_holder =
1774 cgraph_add_node_removal_hook (&ipa_node_removal_hook, NULL);
1775 if (!edge_duplication_hook_holder)
1776 edge_duplication_hook_holder =
1777 cgraph_add_edge_duplication_hook (&ipa_edge_duplication_hook, NULL);
1778 if (!node_duplication_hook_holder)
1779 node_duplication_hook_holder =
1780 cgraph_add_node_duplication_hook (&ipa_node_duplication_hook, NULL);
1783 /* Unregister our cgraph hooks if they are not already there. */
1786 ipa_unregister_cgraph_hooks (void)
1788 cgraph_remove_edge_removal_hook (edge_removal_hook_holder);
1789 edge_removal_hook_holder = NULL;
1790 cgraph_remove_node_removal_hook (node_removal_hook_holder);
1791 node_removal_hook_holder = NULL;
1792 cgraph_remove_edge_duplication_hook (edge_duplication_hook_holder);
1793 edge_duplication_hook_holder = NULL;
1794 cgraph_remove_node_duplication_hook (node_duplication_hook_holder);
1795 node_duplication_hook_holder = NULL;
1798 /* Allocate all necessary data strucutures necessary for indirect inlining. */
1801 ipa_create_all_structures_for_iinln (void)
1803 iinlining_processed_edges = BITMAP_ALLOC (NULL);
1806 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
1807 longer needed after ipa-cp. */
1810 ipa_free_all_structures_after_ipa_cp (void)
1812 if (!flag_indirect_inlining)
1814 ipa_free_all_edge_args ();
1815 ipa_free_all_node_params ();
1816 ipa_unregister_cgraph_hooks ();
1820 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
1821 longer needed after indirect inlining. */
1824 ipa_free_all_structures_after_iinln (void)
1826 BITMAP_FREE (iinlining_processed_edges);
1828 ipa_free_all_edge_args ();
1829 ipa_free_all_node_params ();
1830 ipa_unregister_cgraph_hooks ();
1833 /* Print ipa_tree_map data structures of all functions in the
1837 ipa_print_node_params (FILE * f, struct cgraph_node *node)
1841 struct ipa_node_params *info;
1843 if (!node->analyzed)
1845 info = IPA_NODE_REF (node);
1846 fprintf (f, " function %s parameter descriptors:\n",
1847 cgraph_node_name (node));
1848 count = ipa_get_param_count (info);
1849 for (i = 0; i < count; i++)
1851 temp = ipa_get_param (info, i);
1852 if (TREE_CODE (temp) == PARM_DECL)
1853 fprintf (f, " param %d : %s", i,
1855 ? (*lang_hooks.decl_printable_name) (temp, 2)
1857 if (ipa_is_param_modified (info, i))
1858 fprintf (f, " modified");
1859 if (ipa_is_param_used (info, i))
1860 fprintf (f, " used");
1865 /* Print ipa_tree_map data structures of all functions in the
1869 ipa_print_all_params (FILE * f)
1871 struct cgraph_node *node;
1873 fprintf (f, "\nFunction parameters:\n");
1874 for (node = cgraph_nodes; node; node = node->next)
1875 ipa_print_node_params (f, node);
1878 /* Return a heap allocated vector containing formal parameters of FNDECL. */
1881 ipa_get_vector_of_formal_parms (tree fndecl)
1883 VEC(tree, heap) *args;
1887 count = count_formal_params_1 (fndecl);
1888 args = VEC_alloc (tree, heap, count);
1889 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
1890 VEC_quick_push (tree, args, parm);
1895 /* Return a heap allocated vector containing types of formal parameters of
1896 function type FNTYPE. */
1898 static inline VEC(tree, heap) *
1899 get_vector_of_formal_parm_types (tree fntype)
1901 VEC(tree, heap) *types;
1905 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
1908 types = VEC_alloc (tree, heap, count);
1909 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
1910 VEC_quick_push (tree, types, TREE_VALUE (t));
1915 /* Modify the function declaration FNDECL and its type according to the plan in
1916 ADJUSTMENTS. It also sets base fields of individual adjustments structures
1917 to reflect the actual parameters being modified which are determined by the
1918 base_index field. */
1921 ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec adjustments,
1922 const char *synth_parm_prefix)
1924 VEC(tree, heap) *oparms, *otypes;
1925 tree orig_type, new_type = NULL;
1926 tree old_arg_types, t, new_arg_types = NULL;
1927 tree parm, *link = &DECL_ARGUMENTS (fndecl);
1928 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
1929 tree new_reversed = NULL;
1930 bool care_for_types, last_parm_void;
1932 if (!synth_parm_prefix)
1933 synth_parm_prefix = "SYNTH";
1935 oparms = ipa_get_vector_of_formal_parms (fndecl);
1936 orig_type = TREE_TYPE (fndecl);
1937 old_arg_types = TYPE_ARG_TYPES (orig_type);
1939 /* The following test is an ugly hack, some functions simply don't have any
1940 arguments in their type. This is probably a bug but well... */
1941 care_for_types = (old_arg_types != NULL_TREE);
1944 last_parm_void = (TREE_VALUE (tree_last (old_arg_types))
1946 otypes = get_vector_of_formal_parm_types (orig_type);
1948 gcc_assert (VEC_length (tree, oparms) + 1 == VEC_length (tree, otypes));
1950 gcc_assert (VEC_length (tree, oparms) == VEC_length (tree, otypes));
1954 last_parm_void = false;
1958 for (i = 0; i < len; i++)
1960 struct ipa_parm_adjustment *adj;
1963 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
1964 parm = VEC_index (tree, oparms, adj->base_index);
1967 if (adj->copy_param)
1970 new_arg_types = tree_cons (NULL_TREE, VEC_index (tree, otypes,
1974 link = &TREE_CHAIN (parm);
1976 else if (!adj->remove_param)
1982 ptype = build_pointer_type (adj->type);
1987 new_arg_types = tree_cons (NULL_TREE, ptype, new_arg_types);
1989 new_parm = build_decl (UNKNOWN_LOCATION, PARM_DECL, NULL_TREE,
1991 DECL_NAME (new_parm) = create_tmp_var_name (synth_parm_prefix);
1993 DECL_ARTIFICIAL (new_parm) = 1;
1994 DECL_ARG_TYPE (new_parm) = ptype;
1995 DECL_CONTEXT (new_parm) = fndecl;
1996 TREE_USED (new_parm) = 1;
1997 DECL_IGNORED_P (new_parm) = 1;
1998 layout_decl (new_parm, 0);
2000 add_referenced_var (new_parm);
2001 mark_sym_for_renaming (new_parm);
2003 adj->reduction = new_parm;
2007 link = &TREE_CHAIN (new_parm);
2015 new_reversed = nreverse (new_arg_types);
2019 TREE_CHAIN (new_arg_types) = void_list_node;
2021 new_reversed = void_list_node;
2025 /* Use copy_node to preserve as much as possible from original type
2026 (debug info, attribute lists etc.)
2027 Exception is METHOD_TYPEs must have THIS argument.
2028 When we are asked to remove it, we need to build new FUNCTION_TYPE
2030 if (TREE_CODE (orig_type) != METHOD_TYPE
2031 || (VEC_index (ipa_parm_adjustment_t, adjustments, 0)->copy_param
2032 && VEC_index (ipa_parm_adjustment_t, adjustments, 0)->base_index == 0))
2034 new_type = copy_node (orig_type);
2035 TYPE_ARG_TYPES (new_type) = new_reversed;
2040 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type),
2042 TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type);
2043 DECL_VINDEX (fndecl) = NULL_TREE;
2046 /* This is a new type, not a copy of an old type. Need to reassociate
2047 variants. We can handle everything except the main variant lazily. */
2048 t = TYPE_MAIN_VARIANT (orig_type);
2051 TYPE_MAIN_VARIANT (new_type) = t;
2052 TYPE_NEXT_VARIANT (new_type) = TYPE_NEXT_VARIANT (t);
2053 TYPE_NEXT_VARIANT (t) = new_type;
2057 TYPE_MAIN_VARIANT (new_type) = new_type;
2058 TYPE_NEXT_VARIANT (new_type) = NULL;
2061 TREE_TYPE (fndecl) = new_type;
2063 VEC_free (tree, heap, otypes);
2064 VEC_free (tree, heap, oparms);
2067 /* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS.
2068 If this is a directly recursive call, CS must be NULL. Otherwise it must
2069 contain the corresponding call graph edge. */
2072 ipa_modify_call_arguments (struct cgraph_edge *cs, gimple stmt,
2073 ipa_parm_adjustment_vec adjustments)
2075 VEC(tree, heap) *vargs;
2077 gimple_stmt_iterator gsi;
2081 len = VEC_length (ipa_parm_adjustment_t, adjustments);
2082 vargs = VEC_alloc (tree, heap, len);
2084 gsi = gsi_for_stmt (stmt);
2085 for (i = 0; i < len; i++)
2087 struct ipa_parm_adjustment *adj;
2089 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2091 if (adj->copy_param)
2093 tree arg = gimple_call_arg (stmt, adj->base_index);
2095 VEC_quick_push (tree, vargs, arg);
2097 else if (!adj->remove_param)
2099 tree expr, orig_expr;
2100 bool allow_ptr, repl_found;
2102 orig_expr = expr = gimple_call_arg (stmt, adj->base_index);
2103 if (TREE_CODE (expr) == ADDR_EXPR)
2106 expr = TREE_OPERAND (expr, 0);
2111 repl_found = build_ref_for_offset (&expr, TREE_TYPE (expr),
2112 adj->offset, adj->type,
2117 expr = build_fold_addr_expr (expr);
2121 tree ptrtype = build_pointer_type (adj->type);
2123 if (!POINTER_TYPE_P (TREE_TYPE (expr)))
2124 expr = build_fold_addr_expr (expr);
2125 if (!useless_type_conversion_p (ptrtype, TREE_TYPE (expr)))
2126 expr = fold_convert (ptrtype, expr);
2127 expr = fold_build2 (POINTER_PLUS_EXPR, ptrtype, expr,
2128 build_int_cst (sizetype,
2129 adj->offset / BITS_PER_UNIT));
2131 expr = fold_build1 (INDIRECT_REF, adj->type, expr);
2133 expr = force_gimple_operand_gsi (&gsi, expr,
2135 || is_gimple_reg_type (adj->type),
2136 NULL, true, GSI_SAME_STMT);
2137 VEC_quick_push (tree, vargs, expr);
2141 if (dump_file && (dump_flags & TDF_DETAILS))
2143 fprintf (dump_file, "replacing stmt:");
2144 print_gimple_stmt (dump_file, gsi_stmt (gsi), 0, 0);
2147 callee_decl = !cs ? gimple_call_fndecl (stmt) : cs->callee->decl;
2148 new_stmt = gimple_build_call_vec (callee_decl, vargs);
2149 VEC_free (tree, heap, vargs);
2150 if (gimple_call_lhs (stmt))
2151 gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
2153 gimple_set_block (new_stmt, gimple_block (stmt));
2154 if (gimple_has_location (stmt))
2155 gimple_set_location (new_stmt, gimple_location (stmt));
2156 gimple_call_copy_flags (new_stmt, stmt);
2157 gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
2159 if (dump_file && (dump_flags & TDF_DETAILS))
2161 fprintf (dump_file, "with stmt:");
2162 print_gimple_stmt (dump_file, new_stmt, 0, 0);
2163 fprintf (dump_file, "\n");
2165 gsi_replace (&gsi, new_stmt, true);
2167 cgraph_set_call_stmt (cs, new_stmt);
2168 update_ssa (TODO_update_ssa);
2169 free_dominance_info (CDI_DOMINATORS);
2172 /* Return true iff BASE_INDEX is in ADJUSTMENTS more than once. */
2175 index_in_adjustments_multiple_times_p (int base_index,
2176 ipa_parm_adjustment_vec adjustments)
2178 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
2181 for (i = 0; i < len; i++)
2183 struct ipa_parm_adjustment *adj;
2184 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2186 if (adj->base_index == base_index)
2198 /* Return adjustments that should have the same effect on function parameters
2199 and call arguments as if they were first changed according to adjustments in
2200 INNER and then by adjustments in OUTER. */
2202 ipa_parm_adjustment_vec
2203 ipa_combine_adjustments (ipa_parm_adjustment_vec inner,
2204 ipa_parm_adjustment_vec outer)
2206 int i, outlen = VEC_length (ipa_parm_adjustment_t, outer);
2207 int inlen = VEC_length (ipa_parm_adjustment_t, inner);
2209 ipa_parm_adjustment_vec adjustments, tmp;
2211 tmp = VEC_alloc (ipa_parm_adjustment_t, heap, inlen);
2212 for (i = 0; i < inlen; i++)
2214 struct ipa_parm_adjustment *n;
2215 n = VEC_index (ipa_parm_adjustment_t, inner, i);
2217 if (n->remove_param)
2220 VEC_quick_push (ipa_parm_adjustment_t, tmp, n);
2223 adjustments = VEC_alloc (ipa_parm_adjustment_t, heap, outlen + removals);
2224 for (i = 0; i < outlen; i++)
2226 struct ipa_parm_adjustment *r;
2227 struct ipa_parm_adjustment *out = VEC_index (ipa_parm_adjustment_t,
2229 struct ipa_parm_adjustment *in = VEC_index (ipa_parm_adjustment_t, tmp,
2232 gcc_assert (!in->remove_param);
2233 if (out->remove_param)
2235 if (!index_in_adjustments_multiple_times_p (in->base_index, tmp))
2237 r = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
2238 memset (r, 0, sizeof (*r));
2239 r->remove_param = true;
2244 r = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
2245 memset (r, 0, sizeof (*r));
2246 r->base_index = in->base_index;
2247 r->type = out->type;
2249 /* FIXME: Create nonlocal value too. */
2251 if (in->copy_param && out->copy_param)
2252 r->copy_param = true;
2253 else if (in->copy_param)
2254 r->offset = out->offset;
2255 else if (out->copy_param)
2256 r->offset = in->offset;
2258 r->offset = in->offset + out->offset;
2261 for (i = 0; i < inlen; i++)
2263 struct ipa_parm_adjustment *n = VEC_index (ipa_parm_adjustment_t,
2266 if (n->remove_param)
2267 VEC_quick_push (ipa_parm_adjustment_t, adjustments, n);
2270 VEC_free (ipa_parm_adjustment_t, heap, tmp);
2274 /* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human
2275 friendly way, assuming they are meant to be applied to FNDECL. */
2278 ipa_dump_param_adjustments (FILE *file, ipa_parm_adjustment_vec adjustments,
2281 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
2283 VEC(tree, heap) *parms = ipa_get_vector_of_formal_parms (fndecl);
2285 fprintf (file, "IPA param adjustments: ");
2286 for (i = 0; i < len; i++)
2288 struct ipa_parm_adjustment *adj;
2289 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2292 fprintf (file, " ");
2296 fprintf (file, "%i. base_index: %i - ", i, adj->base_index);
2297 print_generic_expr (file, VEC_index (tree, parms, adj->base_index), 0);
2300 fprintf (file, ", base: ");
2301 print_generic_expr (file, adj->base, 0);
2305 fprintf (file, ", reduction: ");
2306 print_generic_expr (file, adj->reduction, 0);
2308 if (adj->new_ssa_base)
2310 fprintf (file, ", new_ssa_base: ");
2311 print_generic_expr (file, adj->new_ssa_base, 0);
2314 if (adj->copy_param)
2315 fprintf (file, ", copy_param");
2316 else if (adj->remove_param)
2317 fprintf (file, ", remove_param");
2319 fprintf (file, ", offset %li", (long) adj->offset);
2321 fprintf (file, ", by_ref");
2322 print_node_brief (file, ", type: ", adj->type, 0);
2323 fprintf (file, "\n");
2325 VEC_free (tree, heap, parms);
2328 /* Stream out jump function JUMP_FUNC to OB. */
2331 ipa_write_jump_function (struct output_block *ob,
2332 struct ipa_jump_func *jump_func)
2334 lto_output_uleb128_stream (ob->main_stream,
2337 switch (jump_func->type)
2339 case IPA_JF_UNKNOWN:
2341 case IPA_JF_KNOWN_TYPE:
2342 lto_output_tree (ob, jump_func->value.base_binfo, true);
2345 lto_output_tree (ob, jump_func->value.constant, true);
2347 case IPA_JF_PASS_THROUGH:
2348 lto_output_tree (ob, jump_func->value.pass_through.operand, true);
2349 lto_output_uleb128_stream (ob->main_stream,
2350 jump_func->value.pass_through.formal_id);
2351 lto_output_uleb128_stream (ob->main_stream,
2352 jump_func->value.pass_through.operation);
2354 case IPA_JF_ANCESTOR:
2355 lto_output_uleb128_stream (ob->main_stream,
2356 jump_func->value.ancestor.offset);
2357 lto_output_tree (ob, jump_func->value.ancestor.type, true);
2358 lto_output_uleb128_stream (ob->main_stream,
2359 jump_func->value.ancestor.formal_id);
2361 case IPA_JF_CONST_MEMBER_PTR:
2362 lto_output_tree (ob, jump_func->value.member_cst.pfn, true);
2363 lto_output_tree (ob, jump_func->value.member_cst.delta, false);
2368 /* Read in jump function JUMP_FUNC from IB. */
2371 ipa_read_jump_function (struct lto_input_block *ib,
2372 struct ipa_jump_func *jump_func,
2373 struct data_in *data_in)
2375 jump_func->type = (enum jump_func_type) lto_input_uleb128 (ib);
2377 switch (jump_func->type)
2379 case IPA_JF_UNKNOWN:
2381 case IPA_JF_KNOWN_TYPE:
2382 jump_func->value.base_binfo = lto_input_tree (ib, data_in);
2385 jump_func->value.constant = lto_input_tree (ib, data_in);
2387 case IPA_JF_PASS_THROUGH:
2388 jump_func->value.pass_through.operand = lto_input_tree (ib, data_in);
2389 jump_func->value.pass_through.formal_id = lto_input_uleb128 (ib);
2390 jump_func->value.pass_through.operation = (enum tree_code) lto_input_uleb128 (ib);
2392 case IPA_JF_ANCESTOR:
2393 jump_func->value.ancestor.offset = lto_input_uleb128 (ib);
2394 jump_func->value.ancestor.type = lto_input_tree (ib, data_in);
2395 jump_func->value.ancestor.formal_id = lto_input_uleb128 (ib);
2397 case IPA_JF_CONST_MEMBER_PTR:
2398 jump_func->value.member_cst.pfn = lto_input_tree (ib, data_in);
2399 jump_func->value.member_cst.delta = lto_input_tree (ib, data_in);
2404 /* Stream out parts of cgraph_indirect_call_info corresponding to CS that are
2405 relevant to indirect inlining to OB. */
2408 ipa_write_indirect_edge_info (struct output_block *ob,
2409 struct cgraph_edge *cs)
2411 struct cgraph_indirect_call_info *ii = cs->indirect_info;
2412 struct bitpack_d bp;
2414 lto_output_sleb128_stream (ob->main_stream, ii->param_index);
2415 lto_output_sleb128_stream (ob->main_stream, ii->anc_offset);
2416 bp = bitpack_create (ob->main_stream);
2417 bp_pack_value (&bp, ii->polymorphic, 1);
2418 lto_output_bitpack (&bp);
2420 if (ii->polymorphic)
2422 lto_output_sleb128_stream (ob->main_stream, ii->otr_token);
2423 lto_output_tree (ob, ii->otr_type, true);
2427 /* Read in parts of cgraph_indirect_call_info corresponding to CS that are
2428 relevant to indirect inlining from IB. */
2431 ipa_read_indirect_edge_info (struct lto_input_block *ib,
2432 struct data_in *data_in ATTRIBUTE_UNUSED,
2433 struct cgraph_edge *cs)
2435 struct cgraph_indirect_call_info *ii = cs->indirect_info;
2436 struct bitpack_d bp;
2438 ii->param_index = (int) lto_input_sleb128 (ib);
2439 ii->anc_offset = (HOST_WIDE_INT) lto_input_sleb128 (ib);
2440 bp = lto_input_bitpack (ib);
2441 ii->polymorphic = bp_unpack_value (&bp, 1);
2442 if (ii->polymorphic)
2444 ii->otr_token = (HOST_WIDE_INT) lto_input_sleb128 (ib);
2445 ii->otr_type = lto_input_tree (ib, data_in);
2449 /* Stream out NODE info to OB. */
2452 ipa_write_node_info (struct output_block *ob, struct cgraph_node *node)
2455 lto_cgraph_encoder_t encoder;
2456 struct ipa_node_params *info = IPA_NODE_REF (node);
2458 struct cgraph_edge *e;
2459 struct bitpack_d bp;
2461 encoder = ob->decl_state->cgraph_node_encoder;
2462 node_ref = lto_cgraph_encoder_encode (encoder, node);
2463 lto_output_uleb128_stream (ob->main_stream, node_ref);
2465 bp = bitpack_create (ob->main_stream);
2466 bp_pack_value (&bp, info->called_with_var_arguments, 1);
2467 bp_pack_value (&bp, info->uses_analysis_done, 1);
2468 gcc_assert (info->modification_analysis_done
2469 || ipa_get_param_count (info) == 0);
2470 gcc_assert (!info->node_enqueued);
2471 gcc_assert (!info->ipcp_orig_node);
2472 for (j = 0; j < ipa_get_param_count (info); j++)
2474 bp_pack_value (&bp, info->params[j].modified, 1);
2475 bp_pack_value (&bp, info->params[j].used, 1);
2477 lto_output_bitpack (&bp);
2478 for (e = node->callees; e; e = e->next_callee)
2480 struct ipa_edge_args *args = IPA_EDGE_REF (e);
2482 lto_output_uleb128_stream (ob->main_stream,
2483 ipa_get_cs_argument_count (args));
2484 for (j = 0; j < ipa_get_cs_argument_count (args); j++)
2485 ipa_write_jump_function (ob, ipa_get_ith_jump_func (args, j));
2487 for (e = node->indirect_calls; e; e = e->next_callee)
2488 ipa_write_indirect_edge_info (ob, e);
2491 /* Srtream in NODE info from IB. */
2494 ipa_read_node_info (struct lto_input_block *ib, struct cgraph_node *node,
2495 struct data_in *data_in)
2497 struct ipa_node_params *info = IPA_NODE_REF (node);
2499 struct cgraph_edge *e;
2500 struct bitpack_d bp;
2502 ipa_initialize_node_params (node);
2504 bp = lto_input_bitpack (ib);
2505 info->called_with_var_arguments = bp_unpack_value (&bp, 1);
2506 info->uses_analysis_done = bp_unpack_value (&bp, 1);
2507 if (ipa_get_param_count (info) != 0)
2509 info->modification_analysis_done = true;
2510 info->uses_analysis_done = true;
2512 info->node_enqueued = false;
2513 for (k = 0; k < ipa_get_param_count (info); k++)
2515 info->params[k].modified = bp_unpack_value (&bp, 1);
2516 info->params[k].used = bp_unpack_value (&bp, 1);
2518 for (e = node->callees; e; e = e->next_callee)
2520 struct ipa_edge_args *args = IPA_EDGE_REF (e);
2521 int count = lto_input_uleb128 (ib);
2523 ipa_set_cs_argument_count (args, count);
2527 args->jump_functions = ggc_alloc_cleared_vec_ipa_jump_func
2528 (ipa_get_cs_argument_count (args));
2529 for (k = 0; k < ipa_get_cs_argument_count (args); k++)
2530 ipa_read_jump_function (ib, ipa_get_ith_jump_func (args, k), data_in);
2532 for (e = node->indirect_calls; e; e = e->next_callee)
2533 ipa_read_indirect_edge_info (ib, data_in, e);
2536 /* Write jump functions for nodes in SET. */
2539 ipa_prop_write_jump_functions (cgraph_node_set set)
2541 struct cgraph_node *node;
2542 struct output_block *ob = create_output_block (LTO_section_jump_functions);
2543 unsigned int count = 0;
2544 cgraph_node_set_iterator csi;
2546 ob->cgraph_node = NULL;
2548 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2550 node = csi_node (csi);
2551 if (node->analyzed && IPA_NODE_REF (node) != NULL)
2555 lto_output_uleb128_stream (ob->main_stream, count);
2557 /* Process all of the functions. */
2558 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2560 node = csi_node (csi);
2561 if (node->analyzed && IPA_NODE_REF (node) != NULL)
2562 ipa_write_node_info (ob, node);
2564 lto_output_1_stream (ob->main_stream, 0);
2565 produce_asm (ob, NULL);
2566 destroy_output_block (ob);
2569 /* Read section in file FILE_DATA of length LEN with data DATA. */
2572 ipa_prop_read_section (struct lto_file_decl_data *file_data, const char *data,
2575 const struct lto_function_header *header =
2576 (const struct lto_function_header *) data;
2577 const int32_t cfg_offset = sizeof (struct lto_function_header);
2578 const int32_t main_offset = cfg_offset + header->cfg_size;
2579 const int32_t string_offset = main_offset + header->main_size;
2580 struct data_in *data_in;
2581 struct lto_input_block ib_main;
2585 LTO_INIT_INPUT_BLOCK (ib_main, (const char *) data + main_offset, 0,
2589 lto_data_in_create (file_data, (const char *) data + string_offset,
2590 header->string_size, NULL);
2591 count = lto_input_uleb128 (&ib_main);
2593 for (i = 0; i < count; i++)
2596 struct cgraph_node *node;
2597 lto_cgraph_encoder_t encoder;
2599 index = lto_input_uleb128 (&ib_main);
2600 encoder = file_data->cgraph_node_encoder;
2601 node = lto_cgraph_encoder_deref (encoder, index);
2602 gcc_assert (node->analyzed);
2603 ipa_read_node_info (&ib_main, node, data_in);
2605 lto_free_section_data (file_data, LTO_section_jump_functions, NULL, data,
2607 lto_data_in_delete (data_in);
2610 /* Read ipcp jump functions. */
2613 ipa_prop_read_jump_functions (void)
2615 struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
2616 struct lto_file_decl_data *file_data;
2619 ipa_check_create_node_params ();
2620 ipa_check_create_edge_args ();
2621 ipa_register_cgraph_hooks ();
2623 while ((file_data = file_data_vec[j++]))
2626 const char *data = lto_get_section_data (file_data, LTO_section_jump_functions, NULL, &len);
2629 ipa_prop_read_section (file_data, data, len);
2633 /* After merging units, we can get mismatch in argument counts.
2634 Also decl merging might've rendered parameter lists obsolette.
2635 Also compute called_with_variable_arg info. */
2638 ipa_update_after_lto_read (void)
2640 struct cgraph_node *node;
2641 struct cgraph_edge *cs;
2643 ipa_check_create_node_params ();
2644 ipa_check_create_edge_args ();
2646 for (node = cgraph_nodes; node; node = node->next)
2648 ipa_initialize_node_params (node);
2650 for (node = cgraph_nodes; node; node = node->next)
2652 for (cs = node->callees; cs; cs = cs->next_callee)
2654 if (ipa_get_cs_argument_count (IPA_EDGE_REF (cs))
2655 != ipa_get_param_count (IPA_NODE_REF (cs->callee)))
2656 ipa_set_called_with_variable_arg (IPA_NODE_REF (cs->callee));