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 "lto-streamer.h"
40 /* Vector where the parameter infos are actually stored. */
41 VEC (ipa_node_params_t, heap) *ipa_node_params_vector;
42 /* Vector where the parameter infos are actually stored. */
43 VEC (ipa_edge_args_t, gc) *ipa_edge_args_vector;
45 /* Bitmap with all UIDs of call graph edges that have been already processed
46 by indirect inlining. */
47 static bitmap iinlining_processed_edges;
49 /* Holders of ipa cgraph hooks: */
50 static struct cgraph_edge_hook_list *edge_removal_hook_holder;
51 static struct cgraph_node_hook_list *node_removal_hook_holder;
52 static struct cgraph_2edge_hook_list *edge_duplication_hook_holder;
53 static struct cgraph_2node_hook_list *node_duplication_hook_holder;
55 /* Add cgraph NODE described by INFO to the worklist WL regardless of whether
56 it is in one or not. It should almost never be used directly, as opposed to
57 ipa_push_func_to_list. */
60 ipa_push_func_to_list_1 (struct ipa_func_list **wl,
61 struct cgraph_node *node,
62 struct ipa_node_params *info)
64 struct ipa_func_list *temp;
66 info->node_enqueued = 1;
67 temp = XCNEW (struct ipa_func_list);
73 /* Initialize worklist to contain all functions. */
75 struct ipa_func_list *
76 ipa_init_func_list (void)
78 struct cgraph_node *node;
79 struct ipa_func_list * wl;
82 for (node = cgraph_nodes; node; node = node->next)
85 struct ipa_node_params *info = IPA_NODE_REF (node);
86 /* Unreachable nodes should have been eliminated before ipcp and
88 gcc_assert (node->needed || node->reachable);
89 ipa_push_func_to_list_1 (&wl, node, info);
95 /* Remove a function from the worklist WL and return it. */
98 ipa_pop_func_from_list (struct ipa_func_list **wl)
100 struct ipa_node_params *info;
101 struct ipa_func_list *first;
102 struct cgraph_node *node;
109 info = IPA_NODE_REF (node);
110 info->node_enqueued = 0;
114 /* Return index of the formal whose tree is PTREE in function which corresponds
118 ipa_get_param_decl_index (struct ipa_node_params *info, tree ptree)
122 count = ipa_get_param_count (info);
123 for (i = 0; i < count; i++)
124 if (ipa_get_param(info, i) == ptree)
130 /* Populate the param_decl field in parameter descriptors of INFO that
131 corresponds to NODE. */
134 ipa_populate_param_decls (struct cgraph_node *node,
135 struct ipa_node_params *info)
143 fnargs = DECL_ARGUMENTS (fndecl);
145 for (parm = fnargs; parm; parm = TREE_CHAIN (parm))
147 info->params[param_num].decl = parm;
152 /* Return how many formal parameters FNDECL has. */
155 count_formal_params_1 (tree fndecl)
160 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
166 /* Count number of formal parameters in NOTE. Store the result to the
167 appropriate field of INFO. */
170 ipa_count_formal_params (struct cgraph_node *node,
171 struct ipa_node_params *info)
175 param_num = count_formal_params_1 (node->decl);
176 ipa_set_param_count (info, param_num);
179 /* Initialize the ipa_node_params structure associated with NODE by counting
180 the function parameters, creating the descriptors and populating their
184 ipa_initialize_node_params (struct cgraph_node *node)
186 struct ipa_node_params *info = IPA_NODE_REF (node);
190 ipa_count_formal_params (node, info);
191 info->params = XCNEWVEC (struct ipa_param_descriptor,
192 ipa_get_param_count (info));
193 ipa_populate_param_decls (node, info);
197 /* Callback of walk_stmt_load_store_addr_ops for the visit_store and visit_addr
198 parameters. If OP is a parameter declaration, mark it as modified in the
199 info structure passed in DATA. */
202 visit_store_addr_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED,
205 struct ipa_node_params *info = (struct ipa_node_params *) data;
207 op = get_base_address (op);
209 && TREE_CODE (op) == PARM_DECL)
211 int index = ipa_get_param_decl_index (info, op);
212 gcc_assert (index >= 0);
213 info->params[index].modified = true;
214 info->params[index].used = true;
220 /* Callback of walk_stmt_load_store_addr_ops for the visit_load.
221 If OP is a parameter declaration, mark it as used in the info structure
225 visit_load_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED,
228 struct ipa_node_params *info = (struct ipa_node_params *) data;
230 op = get_base_address (op);
232 && TREE_CODE (op) == PARM_DECL)
234 int index = ipa_get_param_decl_index (info, op);
235 gcc_assert (index >= 0);
236 info->params[index].used = true;
242 /* Compute which formal parameters of function associated with NODE are locally
243 modified or their address is taken. Note that this does not apply on
244 parameters with SSA names but those can and should be analyzed
248 ipa_detect_param_modifications (struct cgraph_node *node)
250 tree decl = node->decl;
252 struct function *func;
253 gimple_stmt_iterator gsi;
254 struct ipa_node_params *info = IPA_NODE_REF (node);
257 if (ipa_get_param_count (info) == 0 || info->modification_analysis_done)
260 for (i = 0; i < ipa_get_param_count (info); i++)
262 tree parm = ipa_get_param (info, i);
263 /* For SSA regs see if parameter is used. For non-SSA we compute
264 the flag during modification analysis. */
265 if (is_gimple_reg (parm)
266 && gimple_default_def (DECL_STRUCT_FUNCTION (node->decl), parm))
267 info->params[i].used = true;
270 func = DECL_STRUCT_FUNCTION (decl);
271 FOR_EACH_BB_FN (bb, func)
273 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
274 walk_stmt_load_store_addr_ops (gsi_stmt (gsi), info,
275 visit_load_for_mod_analysis,
276 visit_store_addr_for_mod_analysis,
277 visit_store_addr_for_mod_analysis);
278 for (gsi = gsi_start (phi_nodes (bb)); !gsi_end_p (gsi); gsi_next (&gsi))
279 walk_stmt_load_store_addr_ops (gsi_stmt (gsi), info,
280 visit_load_for_mod_analysis,
281 visit_store_addr_for_mod_analysis,
282 visit_store_addr_for_mod_analysis);
285 info->modification_analysis_done = 1;
288 /* Count number of arguments callsite CS has and store it in
289 ipa_edge_args structure corresponding to this callsite. */
292 ipa_count_arguments (struct cgraph_edge *cs)
297 stmt = cs->call_stmt;
298 gcc_assert (is_gimple_call (stmt));
299 arg_num = gimple_call_num_args (stmt);
300 if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
301 <= (unsigned) cgraph_edge_max_uid)
302 VEC_safe_grow_cleared (ipa_edge_args_t, gc,
303 ipa_edge_args_vector, cgraph_edge_max_uid + 1);
304 ipa_set_cs_argument_count (IPA_EDGE_REF (cs), arg_num);
307 /* Print the jump functions associated with call graph edge CS to file F. */
310 ipa_print_node_jump_functions_for_edge (FILE *f, struct cgraph_edge *cs)
314 count = ipa_get_cs_argument_count (IPA_EDGE_REF (cs));
315 for (i = 0; i < count; i++)
317 struct ipa_jump_func *jump_func;
318 enum jump_func_type type;
320 jump_func = ipa_get_ith_jump_func (IPA_EDGE_REF (cs), i);
321 type = jump_func->type;
323 fprintf (f, " param %d: ", i);
324 if (type == IPA_JF_UNKNOWN)
325 fprintf (f, "UNKNOWN\n");
326 else if (type == IPA_JF_KNOWN_TYPE)
328 tree binfo_type = TREE_TYPE (jump_func->value.base_binfo);
329 fprintf (f, "KNOWN TYPE, type in binfo is: ");
330 print_generic_expr (f, binfo_type, 0);
331 fprintf (f, " (%u)\n", TYPE_UID (binfo_type));
333 else if (type == IPA_JF_CONST)
335 tree val = jump_func->value.constant;
336 fprintf (f, "CONST: ");
337 print_generic_expr (f, val, 0);
338 if (TREE_CODE (val) == ADDR_EXPR
339 && TREE_CODE (TREE_OPERAND (val, 0)) == CONST_DECL)
342 print_generic_expr (f, DECL_INITIAL (TREE_OPERAND (val, 0)),
347 else if (type == IPA_JF_CONST_MEMBER_PTR)
349 fprintf (f, "CONST MEMBER PTR: ");
350 print_generic_expr (f, jump_func->value.member_cst.pfn, 0);
352 print_generic_expr (f, jump_func->value.member_cst.delta, 0);
355 else if (type == IPA_JF_PASS_THROUGH)
357 fprintf (f, "PASS THROUGH: ");
358 fprintf (f, "%d, op %s ",
359 jump_func->value.pass_through.formal_id,
361 jump_func->value.pass_through.operation]);
362 if (jump_func->value.pass_through.operation != NOP_EXPR)
363 print_generic_expr (dump_file,
364 jump_func->value.pass_through.operand, 0);
365 fprintf (dump_file, "\n");
367 else if (type == IPA_JF_ANCESTOR)
369 fprintf (f, "ANCESTOR: ");
370 fprintf (f, "%d, offset "HOST_WIDE_INT_PRINT_DEC", ",
371 jump_func->value.ancestor.formal_id,
372 jump_func->value.ancestor.offset);
373 print_generic_expr (f, jump_func->value.ancestor.type, 0);
374 fprintf (dump_file, "\n");
380 /* Print the jump functions of all arguments on all call graph edges going from
384 ipa_print_node_jump_functions (FILE *f, struct cgraph_node *node)
386 struct cgraph_edge *cs;
389 fprintf (f, " Jump functions of caller %s:\n", cgraph_node_name (node));
390 for (cs = node->callees; cs; cs = cs->next_callee)
392 if (!ipa_edge_args_info_available_for_edge_p (cs))
395 fprintf (f, " callsite %s/%i -> %s/%i : \n",
396 cgraph_node_name (node), node->uid,
397 cgraph_node_name (cs->callee), cs->callee->uid);
398 ipa_print_node_jump_functions_for_edge (f, cs);
401 for (cs = node->indirect_calls, i = 0; cs; cs = cs->next_callee, i++)
403 if (!ipa_edge_args_info_available_for_edge_p (cs))
408 fprintf (f, " indirect callsite %d for stmt ", i);
409 print_gimple_stmt (f, cs->call_stmt, 0, TDF_SLIM);
412 fprintf (f, " indirect callsite %d :\n", i);
413 ipa_print_node_jump_functions_for_edge (f, cs);
418 /* Print ipa_jump_func data structures of all nodes in the call graph to F. */
421 ipa_print_all_jump_functions (FILE *f)
423 struct cgraph_node *node;
425 fprintf (f, "\nJump functions:\n");
426 for (node = cgraph_nodes; node; node = node->next)
428 ipa_print_node_jump_functions (f, node);
432 /* Given that an actual argument is an SSA_NAME (given in NAME) and is a result
433 of an assignment statement STMT, try to find out whether NAME can be
434 described by a (possibly polynomial) pass-through jump-function or an
435 ancestor jump function and if so, write the appropriate function into
439 compute_complex_assign_jump_func (struct ipa_node_params *info,
440 struct ipa_jump_func *jfunc,
441 gimple stmt, tree name)
443 HOST_WIDE_INT offset, size, max_size;
447 op1 = gimple_assign_rhs1 (stmt);
448 op2 = gimple_assign_rhs2 (stmt);
450 if (TREE_CODE (op1) == SSA_NAME
451 && SSA_NAME_IS_DEFAULT_DEF (op1))
453 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
459 if (!is_gimple_ip_invariant (op2)
460 || (TREE_CODE_CLASS (gimple_expr_code (stmt)) != tcc_comparison
461 && !useless_type_conversion_p (TREE_TYPE (name),
465 jfunc->type = IPA_JF_PASS_THROUGH;
466 jfunc->value.pass_through.formal_id = index;
467 jfunc->value.pass_through.operation = gimple_assign_rhs_code (stmt);
468 jfunc->value.pass_through.operand = op2;
470 else if (gimple_assign_unary_nop_p (stmt))
472 jfunc->type = IPA_JF_PASS_THROUGH;
473 jfunc->value.pass_through.formal_id = index;
474 jfunc->value.pass_through.operation = NOP_EXPR;
479 if (TREE_CODE (op1) != ADDR_EXPR)
482 op1 = TREE_OPERAND (op1, 0);
483 type = TREE_TYPE (op1);
484 if (TREE_CODE (type) != RECORD_TYPE)
486 op1 = get_ref_base_and_extent (op1, &offset, &size, &max_size);
487 if (TREE_CODE (op1) != INDIRECT_REF
488 /* If this is a varying address, punt. */
492 op1 = TREE_OPERAND (op1, 0);
493 if (TREE_CODE (op1) != SSA_NAME
494 || !SSA_NAME_IS_DEFAULT_DEF (op1))
497 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
500 jfunc->type = IPA_JF_ANCESTOR;
501 jfunc->value.ancestor.formal_id = index;
502 jfunc->value.ancestor.offset = offset;
503 jfunc->value.ancestor.type = type;
508 /* Given that an actual argument is an SSA_NAME that is a result of a phi
509 statement PHI, try to find out whether NAME is in fact a
510 multiple-inheritance typecast from a descendant into an ancestor of a formal
511 parameter and thus can be described by an ancestor jump function and if so,
512 write the appropriate function into JFUNC.
514 Essentially we want to match the following pattern:
522 iftmp.1_3 = &obj_2(D)->D.1762;
525 # iftmp.1_1 = PHI <iftmp.1_3(3), 0B(2)>
526 D.1879_6 = middleman_1 (iftmp.1_1, i_5(D));
530 compute_complex_ancestor_jump_func (struct ipa_node_params *info,
531 struct ipa_jump_func *jfunc,
534 HOST_WIDE_INT offset, size, max_size;
536 basic_block phi_bb, assign_bb, cond_bb;
537 tree tmp, parm, expr;
540 if (gimple_phi_num_args (phi) != 2
541 || !integer_zerop (PHI_ARG_DEF (phi, 1)))
544 tmp = PHI_ARG_DEF (phi, 0);
545 if (TREE_CODE (tmp) != SSA_NAME
546 || SSA_NAME_IS_DEFAULT_DEF (tmp)
547 || !POINTER_TYPE_P (TREE_TYPE (tmp))
548 || TREE_CODE (TREE_TYPE (TREE_TYPE (tmp))) != RECORD_TYPE)
551 assign = SSA_NAME_DEF_STMT (tmp);
552 assign_bb = gimple_bb (assign);
553 if (!single_pred_p (assign_bb)
554 || !gimple_assign_single_p (assign))
556 expr = gimple_assign_rhs1 (assign);
558 if (TREE_CODE (expr) != ADDR_EXPR)
560 expr = TREE_OPERAND (expr, 0);
561 expr = get_ref_base_and_extent (expr, &offset, &size, &max_size);
563 if (TREE_CODE (expr) != INDIRECT_REF
564 /* If this is a varying address, punt. */
568 parm = TREE_OPERAND (expr, 0);
569 if (TREE_CODE (parm) != SSA_NAME
570 || !SSA_NAME_IS_DEFAULT_DEF (parm))
573 index = ipa_get_param_decl_index (info, SSA_NAME_VAR (parm));
577 cond_bb = single_pred (assign_bb);
578 cond = last_stmt (cond_bb);
579 if (gimple_code (cond) != GIMPLE_COND
580 || gimple_cond_code (cond) != NE_EXPR
581 || gimple_cond_lhs (cond) != parm
582 || !integer_zerop (gimple_cond_rhs (cond)))
586 phi_bb = gimple_bb (phi);
587 for (i = 0; i < 2; i++)
589 basic_block pred = EDGE_PRED (phi_bb, i)->src;
590 if (pred != assign_bb && pred != cond_bb)
594 jfunc->type = IPA_JF_ANCESTOR;
595 jfunc->value.ancestor.formal_id = index;
596 jfunc->value.ancestor.offset = offset;
597 jfunc->value.ancestor.type = TREE_TYPE (TREE_TYPE (tmp));
600 /* Given OP whch is passed as an actual argument to a called function,
601 determine if it is possible to construct a KNOWN_TYPE jump function for it
602 and if so, create one and store it to JFUNC. */
605 compute_known_type_jump_func (tree op, struct ipa_jump_func *jfunc)
609 if (TREE_CODE (op) != ADDR_EXPR)
612 op = TREE_OPERAND (op, 0);
613 binfo = gimple_get_relevant_ref_binfo (op, NULL_TREE);
616 jfunc->type = IPA_JF_KNOWN_TYPE;
617 jfunc->value.base_binfo = binfo;
622 /* Determine the jump functions of scalar arguments. Scalar means SSA names
623 and constants of a number of selected types. INFO is the ipa_node_params
624 structure associated with the caller, FUNCTIONS is a pointer to an array of
625 jump function structures associated with CALL which is the call statement
629 compute_scalar_jump_functions (struct ipa_node_params *info,
630 struct ipa_jump_func *functions,
636 for (num = 0; num < gimple_call_num_args (call); num++)
638 arg = gimple_call_arg (call, num);
640 if (is_gimple_ip_invariant (arg))
642 functions[num].type = IPA_JF_CONST;
643 functions[num].value.constant = arg;
645 else if (TREE_CODE (arg) == SSA_NAME)
647 if (SSA_NAME_IS_DEFAULT_DEF (arg))
649 int index = ipa_get_param_decl_index (info, SSA_NAME_VAR (arg));
653 functions[num].type = IPA_JF_PASS_THROUGH;
654 functions[num].value.pass_through.formal_id = index;
655 functions[num].value.pass_through.operation = NOP_EXPR;
660 gimple stmt = SSA_NAME_DEF_STMT (arg);
661 if (is_gimple_assign (stmt))
662 compute_complex_assign_jump_func (info, &functions[num],
664 else if (gimple_code (stmt) == GIMPLE_PHI)
665 compute_complex_ancestor_jump_func (info, &functions[num],
670 compute_known_type_jump_func (arg, &functions[num]);
674 /* Inspect the given TYPE and return true iff it has the same structure (the
675 same number of fields of the same types) as a C++ member pointer. If
676 METHOD_PTR and DELTA are non-NULL, store the trees representing the
677 corresponding fields there. */
680 type_like_member_ptr_p (tree type, tree *method_ptr, tree *delta)
684 if (TREE_CODE (type) != RECORD_TYPE)
687 fld = TYPE_FIELDS (type);
688 if (!fld || !POINTER_TYPE_P (TREE_TYPE (fld))
689 || TREE_CODE (TREE_TYPE (TREE_TYPE (fld))) != METHOD_TYPE)
695 fld = TREE_CHAIN (fld);
696 if (!fld || INTEGRAL_TYPE_P (fld))
701 if (TREE_CHAIN (fld))
707 /* Go through arguments of the CALL and for every one that looks like a member
708 pointer, check whether it can be safely declared pass-through and if so,
709 mark that to the corresponding item of jump FUNCTIONS. Return true iff
710 there are non-pass-through member pointers within the arguments. INFO
711 describes formal parameters of the caller. */
714 compute_pass_through_member_ptrs (struct ipa_node_params *info,
715 struct ipa_jump_func *functions,
718 bool undecided_members = false;
722 for (num = 0; num < gimple_call_num_args (call); num++)
724 arg = gimple_call_arg (call, num);
726 if (type_like_member_ptr_p (TREE_TYPE (arg), NULL, NULL))
728 if (TREE_CODE (arg) == PARM_DECL)
730 int index = ipa_get_param_decl_index (info, arg);
732 gcc_assert (index >=0);
733 if (!ipa_is_param_modified (info, index))
735 functions[num].type = IPA_JF_PASS_THROUGH;
736 functions[num].value.pass_through.formal_id = index;
737 functions[num].value.pass_through.operation = NOP_EXPR;
740 undecided_members = true;
743 undecided_members = true;
747 return undecided_members;
750 /* Simple function filling in a member pointer constant jump function (with PFN
751 and DELTA as the constant value) into JFUNC. */
754 fill_member_ptr_cst_jump_function (struct ipa_jump_func *jfunc,
755 tree pfn, tree delta)
757 jfunc->type = IPA_JF_CONST_MEMBER_PTR;
758 jfunc->value.member_cst.pfn = pfn;
759 jfunc->value.member_cst.delta = delta;
762 /* If RHS is an SSA_NAMe and it is defined by a simple copy assign statement,
763 return the rhs of its defining statement. */
766 get_ssa_def_if_simple_copy (tree rhs)
768 while (TREE_CODE (rhs) == SSA_NAME && !SSA_NAME_IS_DEFAULT_DEF (rhs))
770 gimple def_stmt = SSA_NAME_DEF_STMT (rhs);
772 if (gimple_assign_single_p (def_stmt))
773 rhs = gimple_assign_rhs1 (def_stmt);
780 /* Traverse statements from CALL backwards, scanning whether the argument ARG
781 which is a member pointer is filled in with constant values. If it is, fill
782 the jump function JFUNC in appropriately. METHOD_FIELD and DELTA_FIELD are
783 fields of the record type of the member pointer. To give an example, we
784 look for a pattern looking like the following:
786 D.2515.__pfn ={v} printStuff;
787 D.2515.__delta ={v} 0;
788 i_1 = doprinting (D.2515); */
791 determine_cst_member_ptr (gimple call, tree arg, tree method_field,
792 tree delta_field, struct ipa_jump_func *jfunc)
794 gimple_stmt_iterator gsi;
795 tree method = NULL_TREE;
796 tree delta = NULL_TREE;
798 gsi = gsi_for_stmt (call);
801 for (; !gsi_end_p (gsi); gsi_prev (&gsi))
803 gimple stmt = gsi_stmt (gsi);
806 if (!gimple_assign_single_p (stmt))
809 lhs = gimple_assign_lhs (stmt);
810 rhs = gimple_assign_rhs1 (stmt);
812 if (TREE_CODE (lhs) != COMPONENT_REF
813 || TREE_OPERAND (lhs, 0) != arg)
816 fld = TREE_OPERAND (lhs, 1);
817 if (!method && fld == method_field)
819 rhs = get_ssa_def_if_simple_copy (rhs);
820 if (TREE_CODE (rhs) == ADDR_EXPR
821 && TREE_CODE (TREE_OPERAND (rhs, 0)) == FUNCTION_DECL
822 && TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs, 0))) == METHOD_TYPE)
824 method = TREE_OPERAND (rhs, 0);
827 fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
835 if (!delta && fld == delta_field)
837 rhs = get_ssa_def_if_simple_copy (rhs);
838 if (TREE_CODE (rhs) == INTEGER_CST)
843 fill_member_ptr_cst_jump_function (jfunc, rhs, delta);
855 /* Go through the arguments of the CALL and for every member pointer within
856 tries determine whether it is a constant. If it is, create a corresponding
857 constant jump function in FUNCTIONS which is an array of jump functions
858 associated with the call. */
861 compute_cst_member_ptr_arguments (struct ipa_jump_func *functions,
865 tree arg, method_field, delta_field;
867 for (num = 0; num < gimple_call_num_args (call); num++)
869 arg = gimple_call_arg (call, num);
871 if (functions[num].type == IPA_JF_UNKNOWN
872 && type_like_member_ptr_p (TREE_TYPE (arg), &method_field,
874 determine_cst_member_ptr (call, arg, method_field, delta_field,
879 /* Compute jump function for all arguments of callsite CS and insert the
880 information in the jump_functions array in the ipa_edge_args corresponding
884 ipa_compute_jump_functions_for_edge (struct cgraph_edge *cs)
886 struct ipa_node_params *info = IPA_NODE_REF (cs->caller);
887 struct ipa_edge_args *arguments = IPA_EDGE_REF (cs);
890 if (ipa_get_cs_argument_count (arguments) == 0 || arguments->jump_functions)
892 arguments->jump_functions = GGC_CNEWVEC (struct ipa_jump_func,
893 ipa_get_cs_argument_count (arguments));
895 call = cs->call_stmt;
896 gcc_assert (is_gimple_call (call));
898 /* We will deal with constants and SSA scalars first: */
899 compute_scalar_jump_functions (info, arguments->jump_functions, call);
901 /* Let's check whether there are any potential member pointers and if so,
902 whether we can determine their functions as pass_through. */
903 if (!compute_pass_through_member_ptrs (info, arguments->jump_functions, call))
906 /* Finally, let's check whether we actually pass a new constant member
908 compute_cst_member_ptr_arguments (arguments->jump_functions, call);
911 /* Compute jump functions for all edges - both direct and indirect - outgoing
912 from NODE. Also count the actual arguments in the process. */
915 ipa_compute_jump_functions (struct cgraph_node *node)
917 struct cgraph_edge *cs;
919 for (cs = node->callees; cs; cs = cs->next_callee)
921 /* We do not need to bother analyzing calls to unknown
922 functions unless they may become known during lto/whopr. */
923 if (!cs->callee->analyzed && !flag_lto && !flag_whopr)
925 ipa_count_arguments (cs);
926 if (ipa_get_cs_argument_count (IPA_EDGE_REF (cs))
927 != ipa_get_param_count (IPA_NODE_REF (cs->callee)))
928 ipa_set_called_with_variable_arg (IPA_NODE_REF (cs->callee));
929 ipa_compute_jump_functions_for_edge (cs);
932 for (cs = node->indirect_calls; cs; cs = cs->next_callee)
934 ipa_count_arguments (cs);
935 ipa_compute_jump_functions_for_edge (cs);
939 /* If RHS looks like a rhs of a statement loading pfn from a member
940 pointer formal parameter, return the parameter, otherwise return
941 NULL. If USE_DELTA, then we look for a use of the delta field
942 rather than the pfn. */
945 ipa_get_member_ptr_load_param (tree rhs, bool use_delta)
951 if (TREE_CODE (rhs) != COMPONENT_REF)
954 rec = TREE_OPERAND (rhs, 0);
955 if (TREE_CODE (rec) != PARM_DECL
956 || !type_like_member_ptr_p (TREE_TYPE (rec), &ptr_field, &delta_field))
959 fld = TREE_OPERAND (rhs, 1);
960 if (use_delta ? (fld == delta_field) : (fld == ptr_field))
966 /* If STMT looks like a statement loading a value from a member pointer formal
967 parameter, this function returns that parameter. */
970 ipa_get_stmt_member_ptr_load_param (gimple stmt, bool use_delta)
974 if (!gimple_assign_single_p (stmt))
977 rhs = gimple_assign_rhs1 (stmt);
978 return ipa_get_member_ptr_load_param (rhs, use_delta);
981 /* Returns true iff T is an SSA_NAME defined by a statement. */
984 ipa_is_ssa_with_stmt_def (tree t)
986 if (TREE_CODE (t) == SSA_NAME
987 && !SSA_NAME_IS_DEFAULT_DEF (t))
993 /* Find the indirect call graph edge corresponding to STMT and add to it all
994 information necessary to describe a call to a parameter number PARAM_INDEX.
995 NODE is the caller. POLYMORPHIC should be set to true iff the call is a
999 ipa_note_param_call (struct cgraph_node *node, int param_index, gimple stmt,
1002 struct cgraph_edge *cs;
1004 cs = cgraph_edge (node, stmt);
1005 cs->indirect_info->param_index = param_index;
1006 cs->indirect_info->anc_offset = 0;
1007 cs->indirect_info->polymorphic = polymorphic;
1010 tree otr = gimple_call_fn (stmt);
1011 tree type, token = OBJ_TYPE_REF_TOKEN (otr);
1012 cs->indirect_info->otr_token = tree_low_cst (token, 1);
1013 type = TREE_TYPE (TREE_TYPE (OBJ_TYPE_REF_OBJECT (otr)));
1014 cs->indirect_info->otr_type = type;
1018 /* Analyze the CALL and examine uses of formal parameters of the caller NODE
1019 (described by INFO). Currently it checks whether the call calls a pointer
1020 that is a formal parameter and if so, the parameter is marked with the
1021 called flag and an indirect call graph edge describing the call is created.
1022 This is very simple for ordinary pointers represented in SSA but not-so-nice
1023 when it comes to member pointers. The ugly part of this function does
1024 nothing more than trying to match the pattern of such a call. An example of
1025 such a pattern is the gimple dump below, the call is on the last line:
1028 f$__delta_5 = f.__delta;
1029 f$__pfn_24 = f.__pfn;
1030 D.2496_3 = (int) f$__pfn_24;
1031 D.2497_4 = D.2496_3 & 1;
1038 D.2500_7 = (unsigned int) f$__delta_5;
1039 D.2501_8 = &S + D.2500_7;
1040 D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8;
1041 D.2503_10 = *D.2502_9;
1042 D.2504_12 = f$__pfn_24 + -1;
1043 D.2505_13 = (unsigned int) D.2504_12;
1044 D.2506_14 = D.2503_10 + D.2505_13;
1045 D.2507_15 = *D.2506_14;
1046 iftmp.11_16 = (String:: *) D.2507_15;
1049 # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)>
1050 D.2500_19 = (unsigned int) f$__delta_5;
1051 D.2508_20 = &S + D.2500_19;
1052 D.2493_21 = iftmp.11_1 (D.2508_20, 4);
1054 Such patterns are results of simple calls to a member pointer:
1056 int doprinting (int (MyString::* f)(int) const)
1058 MyString S ("somestring");
1065 ipa_analyze_indirect_call_uses (struct cgraph_node *node,
1066 struct ipa_node_params *info,
1067 gimple call, tree target)
1072 tree rec, rec2, cond;
1075 basic_block bb, virt_bb, join;
1077 if (SSA_NAME_IS_DEFAULT_DEF (target))
1079 tree var = SSA_NAME_VAR (target);
1080 index = ipa_get_param_decl_index (info, var);
1082 ipa_note_param_call (node, index, call, false);
1086 /* Now we need to try to match the complex pattern of calling a member
1089 if (!POINTER_TYPE_P (TREE_TYPE (target))
1090 || TREE_CODE (TREE_TYPE (TREE_TYPE (target))) != METHOD_TYPE)
1093 def = SSA_NAME_DEF_STMT (target);
1094 if (gimple_code (def) != GIMPLE_PHI)
1097 if (gimple_phi_num_args (def) != 2)
1100 /* First, we need to check whether one of these is a load from a member
1101 pointer that is a parameter to this function. */
1102 n1 = PHI_ARG_DEF (def, 0);
1103 n2 = PHI_ARG_DEF (def, 1);
1104 if (!ipa_is_ssa_with_stmt_def (n1) || !ipa_is_ssa_with_stmt_def (n2))
1106 d1 = SSA_NAME_DEF_STMT (n1);
1107 d2 = SSA_NAME_DEF_STMT (n2);
1109 if ((rec = ipa_get_stmt_member_ptr_load_param (d1, false)))
1111 if (ipa_get_stmt_member_ptr_load_param (d2, false))
1114 bb = gimple_bb (d1);
1115 virt_bb = gimple_bb (d2);
1117 else if ((rec = ipa_get_stmt_member_ptr_load_param (d2, false)))
1119 bb = gimple_bb (d2);
1120 virt_bb = gimple_bb (d1);
1125 /* Second, we need to check that the basic blocks are laid out in the way
1126 corresponding to the pattern. */
1128 join = gimple_bb (def);
1129 if (!single_pred_p (virt_bb) || !single_succ_p (virt_bb)
1130 || single_pred (virt_bb) != bb
1131 || single_succ (virt_bb) != join)
1134 /* Third, let's see that the branching is done depending on the least
1135 significant bit of the pfn. */
1137 branch = last_stmt (bb);
1138 if (gimple_code (branch) != GIMPLE_COND)
1141 if (gimple_cond_code (branch) != NE_EXPR
1142 || !integer_zerop (gimple_cond_rhs (branch)))
1145 cond = gimple_cond_lhs (branch);
1146 if (!ipa_is_ssa_with_stmt_def (cond))
1149 def = SSA_NAME_DEF_STMT (cond);
1150 if (!is_gimple_assign (def)
1151 || gimple_assign_rhs_code (def) != BIT_AND_EXPR
1152 || !integer_onep (gimple_assign_rhs2 (def)))
1155 cond = gimple_assign_rhs1 (def);
1156 if (!ipa_is_ssa_with_stmt_def (cond))
1159 def = SSA_NAME_DEF_STMT (cond);
1161 if (is_gimple_assign (def)
1162 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def)))
1164 cond = gimple_assign_rhs1 (def);
1165 if (!ipa_is_ssa_with_stmt_def (cond))
1167 def = SSA_NAME_DEF_STMT (cond);
1170 rec2 = ipa_get_stmt_member_ptr_load_param (def,
1171 (TARGET_PTRMEMFUNC_VBIT_LOCATION
1172 == ptrmemfunc_vbit_in_delta));
1177 index = ipa_get_param_decl_index (info, rec);
1178 if (index >= 0 && !ipa_is_param_modified (info, index))
1179 ipa_note_param_call (node, index, call, false);
1184 /* Analyze a CALL to an OBJ_TYPE_REF which is passed in TARGET and if the
1185 object referenced in the expression is a formal parameter of the caller
1186 (described by INFO), create a call note for the statement. */
1189 ipa_analyze_virtual_call_uses (struct cgraph_node *node,
1190 struct ipa_node_params *info, gimple call,
1193 tree obj = OBJ_TYPE_REF_OBJECT (target);
1197 if (TREE_CODE (obj) == ADDR_EXPR)
1201 obj = TREE_OPERAND (obj, 0);
1203 while (TREE_CODE (obj) == COMPONENT_REF);
1204 if (TREE_CODE (obj) != INDIRECT_REF)
1206 obj = TREE_OPERAND (obj, 0);
1209 if (TREE_CODE (obj) != SSA_NAME
1210 || !SSA_NAME_IS_DEFAULT_DEF (obj))
1213 var = SSA_NAME_VAR (obj);
1214 index = ipa_get_param_decl_index (info, var);
1217 ipa_note_param_call (node, index, call, true);
1220 /* Analyze a call statement CALL whether and how it utilizes formal parameters
1221 of the caller (described by INFO). */
1224 ipa_analyze_call_uses (struct cgraph_node *node,
1225 struct ipa_node_params *info, gimple call)
1227 tree target = gimple_call_fn (call);
1229 if (TREE_CODE (target) == SSA_NAME)
1230 ipa_analyze_indirect_call_uses (node, info, call, target);
1231 else if (TREE_CODE (target) == OBJ_TYPE_REF)
1232 ipa_analyze_virtual_call_uses (node, info, call, target);
1236 /* Analyze the call statement STMT with respect to formal parameters (described
1237 in INFO) of caller given by NODE. Currently it only checks whether formal
1238 parameters are called. */
1241 ipa_analyze_stmt_uses (struct cgraph_node *node, struct ipa_node_params *info,
1244 if (is_gimple_call (stmt))
1245 ipa_analyze_call_uses (node, info, stmt);
1248 /* Scan the function body of NODE and inspect the uses of formal parameters.
1249 Store the findings in various structures of the associated ipa_node_params
1250 structure, such as parameter flags, notes etc. */
1253 ipa_analyze_params_uses (struct cgraph_node *node)
1255 tree decl = node->decl;
1257 struct function *func;
1258 gimple_stmt_iterator gsi;
1259 struct ipa_node_params *info = IPA_NODE_REF (node);
1261 if (ipa_get_param_count (info) == 0 || info->uses_analysis_done)
1264 func = DECL_STRUCT_FUNCTION (decl);
1265 FOR_EACH_BB_FN (bb, func)
1267 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1269 gimple stmt = gsi_stmt (gsi);
1270 ipa_analyze_stmt_uses (node, info, stmt);
1274 info->uses_analysis_done = 1;
1277 /* Update the jump function DST when the call graph edge correspondng to SRC is
1278 is being inlined, knowing that DST is of type ancestor and src of known
1282 combine_known_type_and_ancestor_jfs (struct ipa_jump_func *src,
1283 struct ipa_jump_func *dst)
1287 new_binfo = get_binfo_at_offset (src->value.base_binfo,
1288 dst->value.ancestor.offset,
1289 dst->value.ancestor.type);
1292 dst->type = IPA_JF_KNOWN_TYPE;
1293 dst->value.base_binfo = new_binfo;
1296 dst->type = IPA_JF_UNKNOWN;
1299 /* Update the jump functions associated with call graph edge E when the call
1300 graph edge CS is being inlined, assuming that E->caller is already (possibly
1301 indirectly) inlined into CS->callee and that E has not been inlined. */
1304 update_jump_functions_after_inlining (struct cgraph_edge *cs,
1305 struct cgraph_edge *e)
1307 struct ipa_edge_args *top = IPA_EDGE_REF (cs);
1308 struct ipa_edge_args *args = IPA_EDGE_REF (e);
1309 int count = ipa_get_cs_argument_count (args);
1312 for (i = 0; i < count; i++)
1314 struct ipa_jump_func *dst = ipa_get_ith_jump_func (args, i);
1316 if (dst->type == IPA_JF_ANCESTOR)
1318 struct ipa_jump_func *src;
1320 /* Variable number of arguments can cause havoc if we try to access
1321 one that does not exist in the inlined edge. So make sure we
1323 if (dst->value.ancestor.formal_id >= ipa_get_cs_argument_count (top))
1325 dst->type = IPA_JF_UNKNOWN;
1329 src = ipa_get_ith_jump_func (top, dst->value.ancestor.formal_id);
1330 if (src->type == IPA_JF_KNOWN_TYPE)
1331 combine_known_type_and_ancestor_jfs (src, dst);
1332 else if (src->type == IPA_JF_CONST)
1334 struct ipa_jump_func kt_func;
1336 kt_func.type = IPA_JF_UNKNOWN;
1337 compute_known_type_jump_func (src->value.constant, &kt_func);
1338 if (kt_func.type == IPA_JF_KNOWN_TYPE)
1339 combine_known_type_and_ancestor_jfs (&kt_func, dst);
1341 dst->type = IPA_JF_UNKNOWN;
1343 else if (src->type == IPA_JF_PASS_THROUGH
1344 && src->value.pass_through.operation == NOP_EXPR)
1345 dst->value.ancestor.formal_id = src->value.pass_through.formal_id;
1346 else if (src->type == IPA_JF_ANCESTOR)
1348 dst->value.ancestor.formal_id = src->value.ancestor.formal_id;
1349 dst->value.ancestor.offset += src->value.ancestor.offset;
1352 dst->type = IPA_JF_UNKNOWN;
1354 else if (dst->type == IPA_JF_PASS_THROUGH)
1356 struct ipa_jump_func *src;
1357 /* We must check range due to calls with variable number of arguments
1358 and we cannot combine jump functions with operations. */
1359 if (dst->value.pass_through.operation == NOP_EXPR
1360 && (dst->value.pass_through.formal_id
1361 < ipa_get_cs_argument_count (top)))
1363 src = ipa_get_ith_jump_func (top,
1364 dst->value.pass_through.formal_id);
1368 dst->type = IPA_JF_UNKNOWN;
1373 /* If TARGET is an addr_expr of a function declaration, make it the destination
1374 of an indirect edge IE and return the edge. Otherwise, return NULL. */
1376 static struct cgraph_edge *
1377 make_edge_direct_to_target (struct cgraph_edge *ie, tree target)
1379 struct cgraph_node *callee;
1381 if (TREE_CODE (target) != ADDR_EXPR)
1383 target = TREE_OPERAND (target, 0);
1384 if (TREE_CODE (target) != FUNCTION_DECL)
1386 callee = cgraph_node (target);
1390 cgraph_make_edge_direct (ie, callee);
1393 fprintf (dump_file, "ipa-prop: Discovered %s call to a known target "
1394 "(%s/%i -> %s/%i) for stmt ",
1395 ie->indirect_info->polymorphic ? "a virtual" : "an indirect",
1396 cgraph_node_name (ie->caller), ie->caller->uid,
1397 cgraph_node_name (ie->callee), ie->callee->uid);
1400 print_gimple_stmt (dump_file, ie->call_stmt, 2, TDF_SLIM);
1402 fprintf (dump_file, "with uid %i\n", ie->lto_stmt_uid);
1405 if (ipa_get_cs_argument_count (IPA_EDGE_REF (ie))
1406 != ipa_get_param_count (IPA_NODE_REF (callee)))
1407 ipa_set_called_with_variable_arg (IPA_NODE_REF (callee));
1412 /* Try to find a destination for indirect edge IE that corresponds to a simple
1413 call or a call of a member function pointer and where the destination is a
1414 pointer formal parameter described by jump function JFUNC. If it can be
1415 determined, return the newly direct edge, otherwise return NULL. */
1417 static struct cgraph_edge *
1418 try_make_edge_direct_simple_call (struct cgraph_edge *ie,
1419 struct ipa_jump_func *jfunc)
1423 if (jfunc->type == IPA_JF_CONST)
1424 target = jfunc->value.constant;
1425 else if (jfunc->type == IPA_JF_CONST_MEMBER_PTR)
1426 target = jfunc->value.member_cst.pfn;
1430 return make_edge_direct_to_target (ie, target);
1433 /* Try to find a destination for indirect edge IE that corresponds to a
1434 virtuall call based on a formal parameter which is described by jump
1435 function JFUNC and if it can be determined, make it direct and return the
1436 direct edge. Otherwise, return NULL. */
1438 static struct cgraph_edge *
1439 try_make_edge_direct_virtual_call (struct cgraph_edge *ie,
1440 struct ipa_jump_func *jfunc)
1442 tree binfo, type, target;
1443 HOST_WIDE_INT token;
1445 if (jfunc->type == IPA_JF_KNOWN_TYPE)
1446 binfo = jfunc->value.base_binfo;
1447 else if (jfunc->type == IPA_JF_CONST)
1449 tree cst = jfunc->value.constant;
1450 if (TREE_CODE (cst) == ADDR_EXPR)
1451 binfo = gimple_get_relevant_ref_binfo (TREE_OPERAND (cst, 0),
1462 token = ie->indirect_info->otr_token;
1463 type = ie->indirect_info->otr_type;
1464 binfo = get_binfo_at_offset (binfo, ie->indirect_info->anc_offset, type);
1466 target = gimple_fold_obj_type_ref_known_binfo (token, binfo);
1471 return make_edge_direct_to_target (ie, target);
1476 /* Update the param called notes associated with NODE when CS is being inlined,
1477 assuming NODE is (potentially indirectly) inlined into CS->callee.
1478 Moreover, if the callee is discovered to be constant, create a new cgraph
1479 edge for it. Newly discovered indirect edges will be added to *NEW_EDGES,
1480 unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
1483 update_indirect_edges_after_inlining (struct cgraph_edge *cs,
1484 struct cgraph_node *node,
1485 VEC (cgraph_edge_p, heap) **new_edges)
1487 struct ipa_edge_args *top = IPA_EDGE_REF (cs);
1488 struct cgraph_edge *ie, *next_ie, *new_direct_edge;
1491 ipa_check_create_edge_args ();
1493 for (ie = node->indirect_calls; ie; ie = next_ie)
1495 struct cgraph_indirect_call_info *ici = ie->indirect_info;
1496 struct ipa_jump_func *jfunc;
1498 next_ie = ie->next_callee;
1499 if (bitmap_bit_p (iinlining_processed_edges, ie->uid))
1502 /* If we ever use indirect edges for anything other than indirect
1503 inlining, we will need to skip those with negative param_indices. */
1504 if (ici->param_index == -1)
1507 /* We must check range due to calls with variable number of arguments: */
1508 if (ici->param_index >= ipa_get_cs_argument_count (top))
1510 bitmap_set_bit (iinlining_processed_edges, ie->uid);
1514 jfunc = ipa_get_ith_jump_func (top, ici->param_index);
1515 if (jfunc->type == IPA_JF_PASS_THROUGH
1516 && jfunc->value.pass_through.operation == NOP_EXPR)
1517 ici->param_index = jfunc->value.pass_through.formal_id;
1518 else if (jfunc->type == IPA_JF_ANCESTOR)
1520 ici->param_index = jfunc->value.ancestor.formal_id;
1521 ici->anc_offset += jfunc->value.ancestor.offset;
1524 /* Either we can find a destination for this edge now or never. */
1525 bitmap_set_bit (iinlining_processed_edges, ie->uid);
1527 if (ici->polymorphic)
1528 new_direct_edge = try_make_edge_direct_virtual_call (ie, jfunc);
1530 new_direct_edge = try_make_edge_direct_simple_call (ie, jfunc);
1532 if (new_direct_edge)
1534 new_direct_edge->indirect_inlining_edge = 1;
1537 VEC_safe_push (cgraph_edge_p, heap, *new_edges,
1539 top = IPA_EDGE_REF (cs);
1548 /* Recursively traverse subtree of NODE (including node) made of inlined
1549 cgraph_edges when CS has been inlined and invoke
1550 update_indirect_edges_after_inlining on all nodes and
1551 update_jump_functions_after_inlining on all non-inlined edges that lead out
1552 of this subtree. Newly discovered indirect edges will be added to
1553 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were
1557 propagate_info_to_inlined_callees (struct cgraph_edge *cs,
1558 struct cgraph_node *node,
1559 VEC (cgraph_edge_p, heap) **new_edges)
1561 struct cgraph_edge *e;
1564 res = update_indirect_edges_after_inlining (cs, node, new_edges);
1566 for (e = node->callees; e; e = e->next_callee)
1567 if (!e->inline_failed)
1568 res |= propagate_info_to_inlined_callees (cs, e->callee, new_edges);
1570 update_jump_functions_after_inlining (cs, e);
1575 /* Update jump functions and call note functions on inlining the call site CS.
1576 CS is expected to lead to a node already cloned by
1577 cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to
1578 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were +
1582 ipa_propagate_indirect_call_infos (struct cgraph_edge *cs,
1583 VEC (cgraph_edge_p, heap) **new_edges)
1585 /* FIXME lto: We do not stream out indirect call information. */
1589 /* Do nothing if the preparation phase has not been carried out yet
1590 (i.e. during early inlining). */
1591 if (!ipa_node_params_vector)
1593 gcc_assert (ipa_edge_args_vector);
1595 return propagate_info_to_inlined_callees (cs, cs->callee, new_edges);
1598 /* Frees all dynamically allocated structures that the argument info points
1602 ipa_free_edge_args_substructures (struct ipa_edge_args *args)
1604 if (args->jump_functions)
1605 ggc_free (args->jump_functions);
1607 memset (args, 0, sizeof (*args));
1610 /* Free all ipa_edge structures. */
1613 ipa_free_all_edge_args (void)
1616 struct ipa_edge_args *args;
1619 VEC_iterate (ipa_edge_args_t, ipa_edge_args_vector, i, args);
1621 ipa_free_edge_args_substructures (args);
1623 VEC_free (ipa_edge_args_t, gc, ipa_edge_args_vector);
1624 ipa_edge_args_vector = NULL;
1627 /* Frees all dynamically allocated structures that the param info points
1631 ipa_free_node_params_substructures (struct ipa_node_params *info)
1634 free (info->params);
1636 memset (info, 0, sizeof (*info));
1639 /* Free all ipa_node_params structures. */
1642 ipa_free_all_node_params (void)
1645 struct ipa_node_params *info;
1648 VEC_iterate (ipa_node_params_t, ipa_node_params_vector, i, info);
1650 ipa_free_node_params_substructures (info);
1652 VEC_free (ipa_node_params_t, heap, ipa_node_params_vector);
1653 ipa_node_params_vector = NULL;
1656 /* Hook that is called by cgraph.c when an edge is removed. */
1659 ipa_edge_removal_hook (struct cgraph_edge *cs, void *data ATTRIBUTE_UNUSED)
1661 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1662 if (VEC_length (ipa_edge_args_t, ipa_edge_args_vector)
1663 <= (unsigned)cs->uid)
1665 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs));
1668 /* Hook that is called by cgraph.c when a node is removed. */
1671 ipa_node_removal_hook (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
1673 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1674 if (VEC_length (ipa_node_params_t, ipa_node_params_vector)
1675 <= (unsigned)node->uid)
1677 ipa_free_node_params_substructures (IPA_NODE_REF (node));
1680 /* Helper function to duplicate an array of size N that is at SRC and store a
1681 pointer to it to DST. Nothing is done if SRC is NULL. */
1684 duplicate_array (void *src, size_t n)
1696 /* Like duplicate_array byt in GGC memory. */
1699 duplicate_ggc_array (void *src, size_t n)
1711 /* Hook that is called by cgraph.c when a node is duplicated. */
1714 ipa_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst,
1715 __attribute__((unused)) void *data)
1717 struct ipa_edge_args *old_args, *new_args;
1720 ipa_check_create_edge_args ();
1722 old_args = IPA_EDGE_REF (src);
1723 new_args = IPA_EDGE_REF (dst);
1725 arg_count = ipa_get_cs_argument_count (old_args);
1726 ipa_set_cs_argument_count (new_args, arg_count);
1727 new_args->jump_functions = (struct ipa_jump_func *)
1728 duplicate_ggc_array (old_args->jump_functions,
1729 sizeof (struct ipa_jump_func) * arg_count);
1731 if (iinlining_processed_edges
1732 && bitmap_bit_p (iinlining_processed_edges, src->uid))
1733 bitmap_set_bit (iinlining_processed_edges, dst->uid);
1736 /* Hook that is called by cgraph.c when a node is duplicated. */
1739 ipa_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst,
1740 __attribute__((unused)) void *data)
1742 struct ipa_node_params *old_info, *new_info;
1745 ipa_check_create_node_params ();
1746 old_info = IPA_NODE_REF (src);
1747 new_info = IPA_NODE_REF (dst);
1748 param_count = ipa_get_param_count (old_info);
1750 ipa_set_param_count (new_info, param_count);
1751 new_info->params = (struct ipa_param_descriptor *)
1752 duplicate_array (old_info->params,
1753 sizeof (struct ipa_param_descriptor) * param_count);
1754 new_info->ipcp_orig_node = old_info->ipcp_orig_node;
1755 new_info->count_scale = old_info->count_scale;
1758 /* Register our cgraph hooks if they are not already there. */
1761 ipa_register_cgraph_hooks (void)
1763 if (!edge_removal_hook_holder)
1764 edge_removal_hook_holder =
1765 cgraph_add_edge_removal_hook (&ipa_edge_removal_hook, NULL);
1766 if (!node_removal_hook_holder)
1767 node_removal_hook_holder =
1768 cgraph_add_node_removal_hook (&ipa_node_removal_hook, NULL);
1769 if (!edge_duplication_hook_holder)
1770 edge_duplication_hook_holder =
1771 cgraph_add_edge_duplication_hook (&ipa_edge_duplication_hook, NULL);
1772 if (!node_duplication_hook_holder)
1773 node_duplication_hook_holder =
1774 cgraph_add_node_duplication_hook (&ipa_node_duplication_hook, NULL);
1777 /* Unregister our cgraph hooks if they are not already there. */
1780 ipa_unregister_cgraph_hooks (void)
1782 cgraph_remove_edge_removal_hook (edge_removal_hook_holder);
1783 edge_removal_hook_holder = NULL;
1784 cgraph_remove_node_removal_hook (node_removal_hook_holder);
1785 node_removal_hook_holder = NULL;
1786 cgraph_remove_edge_duplication_hook (edge_duplication_hook_holder);
1787 edge_duplication_hook_holder = NULL;
1788 cgraph_remove_node_duplication_hook (node_duplication_hook_holder);
1789 node_duplication_hook_holder = NULL;
1792 /* Allocate all necessary data strucutures necessary for indirect inlining. */
1795 ipa_create_all_structures_for_iinln (void)
1797 iinlining_processed_edges = BITMAP_ALLOC (NULL);
1800 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
1801 longer needed after ipa-cp. */
1804 ipa_free_all_structures_after_ipa_cp (void)
1806 if (!flag_indirect_inlining)
1808 ipa_free_all_edge_args ();
1809 ipa_free_all_node_params ();
1810 ipa_unregister_cgraph_hooks ();
1814 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
1815 longer needed after indirect inlining. */
1818 ipa_free_all_structures_after_iinln (void)
1820 BITMAP_FREE (iinlining_processed_edges);
1822 ipa_free_all_edge_args ();
1823 ipa_free_all_node_params ();
1824 ipa_unregister_cgraph_hooks ();
1827 /* Print ipa_tree_map data structures of all functions in the
1831 ipa_print_node_params (FILE * f, struct cgraph_node *node)
1835 struct ipa_node_params *info;
1837 if (!node->analyzed)
1839 info = IPA_NODE_REF (node);
1840 fprintf (f, " function %s parameter descriptors:\n",
1841 cgraph_node_name (node));
1842 count = ipa_get_param_count (info);
1843 for (i = 0; i < count; i++)
1845 temp = ipa_get_param (info, i);
1846 if (TREE_CODE (temp) == PARM_DECL)
1847 fprintf (f, " param %d : %s", i,
1849 ? (*lang_hooks.decl_printable_name) (temp, 2)
1851 if (ipa_is_param_modified (info, i))
1852 fprintf (f, " modified");
1853 if (ipa_is_param_used (info, i))
1854 fprintf (f, " used");
1859 /* Print ipa_tree_map data structures of all functions in the
1863 ipa_print_all_params (FILE * f)
1865 struct cgraph_node *node;
1867 fprintf (f, "\nFunction parameters:\n");
1868 for (node = cgraph_nodes; node; node = node->next)
1869 ipa_print_node_params (f, node);
1872 /* Return a heap allocated vector containing formal parameters of FNDECL. */
1875 ipa_get_vector_of_formal_parms (tree fndecl)
1877 VEC(tree, heap) *args;
1881 count = count_formal_params_1 (fndecl);
1882 args = VEC_alloc (tree, heap, count);
1883 for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
1884 VEC_quick_push (tree, args, parm);
1889 /* Return a heap allocated vector containing types of formal parameters of
1890 function type FNTYPE. */
1892 static inline VEC(tree, heap) *
1893 get_vector_of_formal_parm_types (tree fntype)
1895 VEC(tree, heap) *types;
1899 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
1902 types = VEC_alloc (tree, heap, count);
1903 for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
1904 VEC_quick_push (tree, types, TREE_VALUE (t));
1909 /* Modify the function declaration FNDECL and its type according to the plan in
1910 ADJUSTMENTS. It also sets base fields of individual adjustments structures
1911 to reflect the actual parameters being modified which are determined by the
1912 base_index field. */
1915 ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec adjustments,
1916 const char *synth_parm_prefix)
1918 VEC(tree, heap) *oparms, *otypes;
1919 tree orig_type, new_type = NULL;
1920 tree old_arg_types, t, new_arg_types = NULL;
1921 tree parm, *link = &DECL_ARGUMENTS (fndecl);
1922 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
1923 tree new_reversed = NULL;
1924 bool care_for_types, last_parm_void;
1926 if (!synth_parm_prefix)
1927 synth_parm_prefix = "SYNTH";
1929 oparms = ipa_get_vector_of_formal_parms (fndecl);
1930 orig_type = TREE_TYPE (fndecl);
1931 old_arg_types = TYPE_ARG_TYPES (orig_type);
1933 /* The following test is an ugly hack, some functions simply don't have any
1934 arguments in their type. This is probably a bug but well... */
1935 care_for_types = (old_arg_types != NULL_TREE);
1938 last_parm_void = (TREE_VALUE (tree_last (old_arg_types))
1940 otypes = get_vector_of_formal_parm_types (orig_type);
1942 gcc_assert (VEC_length (tree, oparms) + 1 == VEC_length (tree, otypes));
1944 gcc_assert (VEC_length (tree, oparms) == VEC_length (tree, otypes));
1948 last_parm_void = false;
1952 for (i = 0; i < len; i++)
1954 struct ipa_parm_adjustment *adj;
1957 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
1958 parm = VEC_index (tree, oparms, adj->base_index);
1961 if (adj->copy_param)
1964 new_arg_types = tree_cons (NULL_TREE, VEC_index (tree, otypes,
1968 link = &TREE_CHAIN (parm);
1970 else if (!adj->remove_param)
1976 ptype = build_pointer_type (adj->type);
1981 new_arg_types = tree_cons (NULL_TREE, ptype, new_arg_types);
1983 new_parm = build_decl (UNKNOWN_LOCATION, PARM_DECL, NULL_TREE,
1985 DECL_NAME (new_parm) = create_tmp_var_name (synth_parm_prefix);
1987 DECL_ARTIFICIAL (new_parm) = 1;
1988 DECL_ARG_TYPE (new_parm) = ptype;
1989 DECL_CONTEXT (new_parm) = fndecl;
1990 TREE_USED (new_parm) = 1;
1991 DECL_IGNORED_P (new_parm) = 1;
1992 layout_decl (new_parm, 0);
1994 add_referenced_var (new_parm);
1995 mark_sym_for_renaming (new_parm);
1997 adj->reduction = new_parm;
2001 link = &TREE_CHAIN (new_parm);
2009 new_reversed = nreverse (new_arg_types);
2013 TREE_CHAIN (new_arg_types) = void_list_node;
2015 new_reversed = void_list_node;
2019 /* Use copy_node to preserve as much as possible from original type
2020 (debug info, attribute lists etc.)
2021 Exception is METHOD_TYPEs must have THIS argument.
2022 When we are asked to remove it, we need to build new FUNCTION_TYPE
2024 if (TREE_CODE (orig_type) != METHOD_TYPE
2025 || (VEC_index (ipa_parm_adjustment_t, adjustments, 0)->copy_param
2026 && VEC_index (ipa_parm_adjustment_t, adjustments, 0)->base_index == 0))
2028 new_type = copy_node (orig_type);
2029 TYPE_ARG_TYPES (new_type) = new_reversed;
2034 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type),
2036 TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type);
2037 DECL_VINDEX (fndecl) = NULL_TREE;
2040 /* This is a new type, not a copy of an old type. Need to reassociate
2041 variants. We can handle everything except the main variant lazily. */
2042 t = TYPE_MAIN_VARIANT (orig_type);
2045 TYPE_MAIN_VARIANT (new_type) = t;
2046 TYPE_NEXT_VARIANT (new_type) = TYPE_NEXT_VARIANT (t);
2047 TYPE_NEXT_VARIANT (t) = new_type;
2051 TYPE_MAIN_VARIANT (new_type) = new_type;
2052 TYPE_NEXT_VARIANT (new_type) = NULL;
2055 TREE_TYPE (fndecl) = new_type;
2057 VEC_free (tree, heap, otypes);
2058 VEC_free (tree, heap, oparms);
2061 /* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS.
2062 If this is a directly recursive call, CS must be NULL. Otherwise it must
2063 contain the corresponding call graph edge. */
2066 ipa_modify_call_arguments (struct cgraph_edge *cs, gimple stmt,
2067 ipa_parm_adjustment_vec adjustments)
2069 VEC(tree, heap) *vargs;
2071 gimple_stmt_iterator gsi;
2075 len = VEC_length (ipa_parm_adjustment_t, adjustments);
2076 vargs = VEC_alloc (tree, heap, len);
2078 gsi = gsi_for_stmt (stmt);
2079 for (i = 0; i < len; i++)
2081 struct ipa_parm_adjustment *adj;
2083 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2085 if (adj->copy_param)
2087 tree arg = gimple_call_arg (stmt, adj->base_index);
2089 VEC_quick_push (tree, vargs, arg);
2091 else if (!adj->remove_param)
2093 tree expr, orig_expr;
2094 bool allow_ptr, repl_found;
2096 orig_expr = expr = gimple_call_arg (stmt, adj->base_index);
2097 if (TREE_CODE (expr) == ADDR_EXPR)
2100 expr = TREE_OPERAND (expr, 0);
2105 repl_found = build_ref_for_offset (&expr, TREE_TYPE (expr),
2106 adj->offset, adj->type,
2111 expr = build_fold_addr_expr (expr);
2115 tree ptrtype = build_pointer_type (adj->type);
2117 if (!POINTER_TYPE_P (TREE_TYPE (expr)))
2118 expr = build_fold_addr_expr (expr);
2119 if (!useless_type_conversion_p (ptrtype, TREE_TYPE (expr)))
2120 expr = fold_convert (ptrtype, expr);
2121 expr = fold_build2 (POINTER_PLUS_EXPR, ptrtype, expr,
2122 build_int_cst (sizetype,
2123 adj->offset / BITS_PER_UNIT));
2125 expr = fold_build1 (INDIRECT_REF, adj->type, expr);
2127 expr = force_gimple_operand_gsi (&gsi, expr,
2129 || is_gimple_reg_type (adj->type),
2130 NULL, true, GSI_SAME_STMT);
2131 VEC_quick_push (tree, vargs, expr);
2135 if (dump_file && (dump_flags & TDF_DETAILS))
2137 fprintf (dump_file, "replacing stmt:");
2138 print_gimple_stmt (dump_file, gsi_stmt (gsi), 0, 0);
2141 callee_decl = !cs ? gimple_call_fndecl (stmt) : cs->callee->decl;
2142 new_stmt = gimple_build_call_vec (callee_decl, vargs);
2143 VEC_free (tree, heap, vargs);
2144 if (gimple_call_lhs (stmt))
2145 gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
2147 gimple_set_block (new_stmt, gimple_block (stmt));
2148 if (gimple_has_location (stmt))
2149 gimple_set_location (new_stmt, gimple_location (stmt));
2150 gimple_call_copy_flags (new_stmt, stmt);
2151 gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
2153 if (dump_file && (dump_flags & TDF_DETAILS))
2155 fprintf (dump_file, "with stmt:");
2156 print_gimple_stmt (dump_file, new_stmt, 0, 0);
2157 fprintf (dump_file, "\n");
2159 gsi_replace (&gsi, new_stmt, true);
2161 cgraph_set_call_stmt (cs, new_stmt);
2162 update_ssa (TODO_update_ssa);
2163 free_dominance_info (CDI_DOMINATORS);
2166 /* Return true iff BASE_INDEX is in ADJUSTMENTS more than once. */
2169 index_in_adjustments_multiple_times_p (int base_index,
2170 ipa_parm_adjustment_vec adjustments)
2172 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
2175 for (i = 0; i < len; i++)
2177 struct ipa_parm_adjustment *adj;
2178 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2180 if (adj->base_index == base_index)
2192 /* Return adjustments that should have the same effect on function parameters
2193 and call arguments as if they were first changed according to adjustments in
2194 INNER and then by adjustments in OUTER. */
2196 ipa_parm_adjustment_vec
2197 ipa_combine_adjustments (ipa_parm_adjustment_vec inner,
2198 ipa_parm_adjustment_vec outer)
2200 int i, outlen = VEC_length (ipa_parm_adjustment_t, outer);
2201 int inlen = VEC_length (ipa_parm_adjustment_t, inner);
2203 ipa_parm_adjustment_vec adjustments, tmp;
2205 tmp = VEC_alloc (ipa_parm_adjustment_t, heap, inlen);
2206 for (i = 0; i < inlen; i++)
2208 struct ipa_parm_adjustment *n;
2209 n = VEC_index (ipa_parm_adjustment_t, inner, i);
2211 if (n->remove_param)
2214 VEC_quick_push (ipa_parm_adjustment_t, tmp, n);
2217 adjustments = VEC_alloc (ipa_parm_adjustment_t, heap, outlen + removals);
2218 for (i = 0; i < outlen; i++)
2220 struct ipa_parm_adjustment *r;
2221 struct ipa_parm_adjustment *out = VEC_index (ipa_parm_adjustment_t,
2223 struct ipa_parm_adjustment *in = VEC_index (ipa_parm_adjustment_t, tmp,
2226 gcc_assert (!in->remove_param);
2227 if (out->remove_param)
2229 if (!index_in_adjustments_multiple_times_p (in->base_index, tmp))
2231 r = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
2232 memset (r, 0, sizeof (*r));
2233 r->remove_param = true;
2238 r = VEC_quick_push (ipa_parm_adjustment_t, adjustments, NULL);
2239 memset (r, 0, sizeof (*r));
2240 r->base_index = in->base_index;
2241 r->type = out->type;
2243 /* FIXME: Create nonlocal value too. */
2245 if (in->copy_param && out->copy_param)
2246 r->copy_param = true;
2247 else if (in->copy_param)
2248 r->offset = out->offset;
2249 else if (out->copy_param)
2250 r->offset = in->offset;
2252 r->offset = in->offset + out->offset;
2255 for (i = 0; i < inlen; i++)
2257 struct ipa_parm_adjustment *n = VEC_index (ipa_parm_adjustment_t,
2260 if (n->remove_param)
2261 VEC_quick_push (ipa_parm_adjustment_t, adjustments, n);
2264 VEC_free (ipa_parm_adjustment_t, heap, tmp);
2268 /* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human
2269 friendly way, assuming they are meant to be applied to FNDECL. */
2272 ipa_dump_param_adjustments (FILE *file, ipa_parm_adjustment_vec adjustments,
2275 int i, len = VEC_length (ipa_parm_adjustment_t, adjustments);
2277 VEC(tree, heap) *parms = ipa_get_vector_of_formal_parms (fndecl);
2279 fprintf (file, "IPA param adjustments: ");
2280 for (i = 0; i < len; i++)
2282 struct ipa_parm_adjustment *adj;
2283 adj = VEC_index (ipa_parm_adjustment_t, adjustments, i);
2286 fprintf (file, " ");
2290 fprintf (file, "%i. base_index: %i - ", i, adj->base_index);
2291 print_generic_expr (file, VEC_index (tree, parms, adj->base_index), 0);
2294 fprintf (file, ", base: ");
2295 print_generic_expr (file, adj->base, 0);
2299 fprintf (file, ", reduction: ");
2300 print_generic_expr (file, adj->reduction, 0);
2302 if (adj->new_ssa_base)
2304 fprintf (file, ", new_ssa_base: ");
2305 print_generic_expr (file, adj->new_ssa_base, 0);
2308 if (adj->copy_param)
2309 fprintf (file, ", copy_param");
2310 else if (adj->remove_param)
2311 fprintf (file, ", remove_param");
2313 fprintf (file, ", offset %li", (long) adj->offset);
2315 fprintf (file, ", by_ref");
2316 print_node_brief (file, ", type: ", adj->type, 0);
2317 fprintf (file, "\n");
2319 VEC_free (tree, heap, parms);
2322 /* Stream out jump function JUMP_FUNC to OB. */
2325 ipa_write_jump_function (struct output_block *ob,
2326 struct ipa_jump_func *jump_func)
2328 lto_output_uleb128_stream (ob->main_stream,
2331 switch (jump_func->type)
2333 case IPA_JF_UNKNOWN:
2335 case IPA_JF_KNOWN_TYPE:
2336 lto_output_tree (ob, jump_func->value.base_binfo, true);
2339 lto_output_tree (ob, jump_func->value.constant, true);
2341 case IPA_JF_PASS_THROUGH:
2342 lto_output_tree (ob, jump_func->value.pass_through.operand, true);
2343 lto_output_uleb128_stream (ob->main_stream,
2344 jump_func->value.pass_through.formal_id);
2345 lto_output_uleb128_stream (ob->main_stream,
2346 jump_func->value.pass_through.operation);
2348 case IPA_JF_ANCESTOR:
2349 lto_output_uleb128_stream (ob->main_stream,
2350 jump_func->value.ancestor.offset);
2351 lto_output_tree (ob, jump_func->value.ancestor.type, true);
2352 lto_output_uleb128_stream (ob->main_stream,
2353 jump_func->value.ancestor.formal_id);
2355 case IPA_JF_CONST_MEMBER_PTR:
2356 lto_output_tree (ob, jump_func->value.member_cst.pfn, true);
2357 lto_output_tree (ob, jump_func->value.member_cst.delta, false);
2362 /* Read in jump function JUMP_FUNC from IB. */
2365 ipa_read_jump_function (struct lto_input_block *ib,
2366 struct ipa_jump_func *jump_func,
2367 struct data_in *data_in)
2369 jump_func->type = (enum jump_func_type) lto_input_uleb128 (ib);
2371 switch (jump_func->type)
2373 case IPA_JF_UNKNOWN:
2375 case IPA_JF_KNOWN_TYPE:
2376 jump_func->value.base_binfo = lto_input_tree (ib, data_in);
2379 jump_func->value.constant = lto_input_tree (ib, data_in);
2381 case IPA_JF_PASS_THROUGH:
2382 jump_func->value.pass_through.operand = lto_input_tree (ib, data_in);
2383 jump_func->value.pass_through.formal_id = lto_input_uleb128 (ib);
2384 jump_func->value.pass_through.operation = (enum tree_code) lto_input_uleb128 (ib);
2386 case IPA_JF_ANCESTOR:
2387 jump_func->value.ancestor.offset = lto_input_uleb128 (ib);
2388 jump_func->value.ancestor.type = lto_input_tree (ib, data_in);
2389 jump_func->value.ancestor.formal_id = lto_input_uleb128 (ib);
2391 case IPA_JF_CONST_MEMBER_PTR:
2392 jump_func->value.member_cst.pfn = lto_input_tree (ib, data_in);
2393 jump_func->value.member_cst.delta = lto_input_tree (ib, data_in);
2398 /* Stream out parts of cgraph_indirect_call_info corresponding to CS that are
2399 relevant to indirect inlining to OB. */
2402 ipa_write_indirect_edge_info (struct output_block *ob,
2403 struct cgraph_edge *cs)
2405 struct cgraph_indirect_call_info *ii = cs->indirect_info;
2406 struct bitpack_d *bp;
2408 lto_output_sleb128_stream (ob->main_stream, ii->param_index);
2409 lto_output_sleb128_stream (ob->main_stream, ii->anc_offset);
2410 bp = bitpack_create ();
2411 bp_pack_value (bp, ii->polymorphic, 1);
2412 lto_output_bitpack (ob->main_stream, bp);
2413 bitpack_delete (bp);
2415 if (ii->polymorphic)
2417 lto_output_sleb128_stream (ob->main_stream, ii->otr_token);
2418 lto_output_tree (ob, ii->otr_type, true);
2422 /* Read in parts of cgraph_indirect_call_info corresponding to CS that are
2423 relevant to indirect inlining from IB. */
2426 ipa_read_indirect_edge_info (struct lto_input_block *ib,
2427 struct data_in *data_in ATTRIBUTE_UNUSED,
2428 struct cgraph_edge *cs)
2430 struct cgraph_indirect_call_info *ii = cs->indirect_info;
2431 struct bitpack_d *bp;
2433 ii->param_index = (int) lto_input_sleb128 (ib);
2434 ii->anc_offset = (HOST_WIDE_INT) lto_input_sleb128 (ib);
2435 bp = lto_input_bitpack (ib);
2436 ii->polymorphic = bp_unpack_value (bp, 1);
2437 bitpack_delete (bp);
2438 if (ii->polymorphic)
2440 ii->otr_token = (HOST_WIDE_INT) lto_input_sleb128 (ib);
2441 ii->otr_type = lto_input_tree (ib, data_in);
2445 /* Stream out NODE info to OB. */
2448 ipa_write_node_info (struct output_block *ob, struct cgraph_node *node)
2451 lto_cgraph_encoder_t encoder;
2452 struct ipa_node_params *info = IPA_NODE_REF (node);
2454 struct cgraph_edge *e;
2455 struct bitpack_d *bp;
2457 encoder = ob->decl_state->cgraph_node_encoder;
2458 node_ref = lto_cgraph_encoder_encode (encoder, node);
2459 lto_output_uleb128_stream (ob->main_stream, node_ref);
2461 bp = bitpack_create ();
2462 bp_pack_value (bp, info->called_with_var_arguments, 1);
2463 bp_pack_value (bp, info->uses_analysis_done, 1);
2464 gcc_assert (info->modification_analysis_done
2465 || ipa_get_param_count (info) == 0);
2466 gcc_assert (!info->node_enqueued);
2467 gcc_assert (!info->ipcp_orig_node);
2468 for (j = 0; j < ipa_get_param_count (info); j++)
2470 bp_pack_value (bp, info->params[j].modified, 1);
2471 bp_pack_value (bp, info->params[j].used, 1);
2473 lto_output_bitpack (ob->main_stream, bp);
2474 bitpack_delete (bp);
2475 for (e = node->callees; e; e = e->next_callee)
2477 struct ipa_edge_args *args = IPA_EDGE_REF (e);
2479 lto_output_uleb128_stream (ob->main_stream,
2480 ipa_get_cs_argument_count (args));
2481 for (j = 0; j < ipa_get_cs_argument_count (args); j++)
2482 ipa_write_jump_function (ob, ipa_get_ith_jump_func (args, j));
2484 for (e = node->indirect_calls; e; e = e->next_callee)
2485 ipa_write_indirect_edge_info (ob, e);
2488 /* Srtream in NODE info from IB. */
2491 ipa_read_node_info (struct lto_input_block *ib, struct cgraph_node *node,
2492 struct data_in *data_in)
2494 struct ipa_node_params *info = IPA_NODE_REF (node);
2496 struct cgraph_edge *e;
2497 struct bitpack_d *bp;
2499 ipa_initialize_node_params (node);
2501 bp = lto_input_bitpack (ib);
2502 info->called_with_var_arguments = bp_unpack_value (bp, 1);
2503 info->uses_analysis_done = bp_unpack_value (bp, 1);
2504 if (ipa_get_param_count (info) != 0)
2506 info->modification_analysis_done = true;
2507 info->uses_analysis_done = true;
2509 info->node_enqueued = false;
2510 for (k = 0; k < ipa_get_param_count (info); k++)
2512 info->params[k].modified = bp_unpack_value (bp, 1);
2513 info->params[k].used = bp_unpack_value (bp, 1);
2515 bitpack_delete (bp);
2516 for (e = node->callees; e; e = e->next_callee)
2518 struct ipa_edge_args *args = IPA_EDGE_REF (e);
2519 int count = lto_input_uleb128 (ib);
2521 ipa_set_cs_argument_count (args, count);
2525 args->jump_functions = GGC_CNEWVEC (struct ipa_jump_func,
2526 ipa_get_cs_argument_count (args));
2527 for (k = 0; k < ipa_get_cs_argument_count (args); k++)
2528 ipa_read_jump_function (ib, ipa_get_ith_jump_func (args, k), data_in);
2530 for (e = node->indirect_calls; e; e = e->next_callee)
2531 ipa_read_indirect_edge_info (ib, data_in, e);
2534 /* Write jump functions for nodes in SET. */
2537 ipa_prop_write_jump_functions (cgraph_node_set set)
2539 struct cgraph_node *node;
2540 struct output_block *ob = create_output_block (LTO_section_jump_functions);
2541 unsigned int count = 0;
2542 cgraph_node_set_iterator csi;
2544 ob->cgraph_node = NULL;
2546 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2548 node = csi_node (csi);
2549 if (node->analyzed && IPA_NODE_REF (node) != NULL)
2553 lto_output_uleb128_stream (ob->main_stream, count);
2555 /* Process all of the functions. */
2556 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2558 node = csi_node (csi);
2559 if (node->analyzed && IPA_NODE_REF (node) != NULL)
2560 ipa_write_node_info (ob, node);
2562 lto_output_1_stream (ob->main_stream, 0);
2563 produce_asm (ob, NULL);
2564 destroy_output_block (ob);
2567 /* Read section in file FILE_DATA of length LEN with data DATA. */
2570 ipa_prop_read_section (struct lto_file_decl_data *file_data, const char *data,
2573 const struct lto_function_header *header =
2574 (const struct lto_function_header *) data;
2575 const int32_t cfg_offset = sizeof (struct lto_function_header);
2576 const int32_t main_offset = cfg_offset + header->cfg_size;
2577 const int32_t string_offset = main_offset + header->main_size;
2578 struct data_in *data_in;
2579 struct lto_input_block ib_main;
2583 LTO_INIT_INPUT_BLOCK (ib_main, (const char *) data + main_offset, 0,
2587 lto_data_in_create (file_data, (const char *) data + string_offset,
2588 header->string_size, NULL);
2589 count = lto_input_uleb128 (&ib_main);
2591 for (i = 0; i < count; i++)
2594 struct cgraph_node *node;
2595 lto_cgraph_encoder_t encoder;
2597 index = lto_input_uleb128 (&ib_main);
2598 encoder = file_data->cgraph_node_encoder;
2599 node = lto_cgraph_encoder_deref (encoder, index);
2600 gcc_assert (node->analyzed);
2601 ipa_read_node_info (&ib_main, node, data_in);
2603 lto_free_section_data (file_data, LTO_section_jump_functions, NULL, data,
2605 lto_data_in_delete (data_in);
2608 /* Read ipcp jump functions. */
2611 ipa_prop_read_jump_functions (void)
2613 struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
2614 struct lto_file_decl_data *file_data;
2617 ipa_check_create_node_params ();
2618 ipa_check_create_edge_args ();
2619 ipa_register_cgraph_hooks ();
2621 while ((file_data = file_data_vec[j++]))
2624 const char *data = lto_get_section_data (file_data, LTO_section_jump_functions, NULL, &len);
2627 ipa_prop_read_section (file_data, data, len);
2631 /* After merging units, we can get mismatch in argument counts.
2632 Also decl merging might've rendered parameter lists obsolette.
2633 Also compute called_with_variable_arg info. */
2636 ipa_update_after_lto_read (void)
2638 struct cgraph_node *node;
2639 struct cgraph_edge *cs;
2641 ipa_check_create_node_params ();
2642 ipa_check_create_edge_args ();
2644 for (node = cgraph_nodes; node; node = node->next)
2646 ipa_initialize_node_params (node);
2648 for (node = cgraph_nodes; node; node = node->next)
2650 for (cs = node->callees; cs; cs = cs->next_callee)
2652 if (ipa_get_cs_argument_count (IPA_EDGE_REF (cs))
2653 != ipa_get_param_count (IPA_NODE_REF (cs->callee)))
2654 ipa_set_called_with_variable_arg (IPA_NODE_REF (cs->callee));