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 (!gimple_assign_single_p (stmt
))
812 lhs
= gimple_assign_lhs (stmt
);
813 rhs
= gimple_assign_rhs1 (stmt
);
815 if (TREE_CODE (lhs
) != COMPONENT_REF
816 || TREE_OPERAND (lhs
, 0) != arg
)
819 fld
= TREE_OPERAND (lhs
, 1);
820 if (!method
&& fld
== method_field
)
822 rhs
= get_ssa_def_if_simple_copy (rhs
);
823 if (TREE_CODE (rhs
) == ADDR_EXPR
824 && TREE_CODE (TREE_OPERAND (rhs
, 0)) == FUNCTION_DECL
825 && TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs
, 0))) == METHOD_TYPE
)
827 method
= TREE_OPERAND (rhs
, 0);
830 fill_member_ptr_cst_jump_function (jfunc
, rhs
, delta
);
838 if (!delta
&& fld
== delta_field
)
840 rhs
= get_ssa_def_if_simple_copy (rhs
);
841 if (TREE_CODE (rhs
) == INTEGER_CST
)
846 fill_member_ptr_cst_jump_function (jfunc
, rhs
, delta
);
858 /* Go through the arguments of the CALL and for every member pointer within
859 tries determine whether it is a constant. If it is, create a corresponding
860 constant jump function in FUNCTIONS which is an array of jump functions
861 associated with the call. */
864 compute_cst_member_ptr_arguments (struct ipa_jump_func
*functions
,
868 tree arg
, method_field
, delta_field
;
870 for (num
= 0; num
< gimple_call_num_args (call
); num
++)
872 arg
= gimple_call_arg (call
, num
);
874 if (functions
[num
].type
== IPA_JF_UNKNOWN
875 && type_like_member_ptr_p (TREE_TYPE (arg
), &method_field
,
877 determine_cst_member_ptr (call
, arg
, method_field
, delta_field
,
882 /* Compute jump function for all arguments of callsite CS and insert the
883 information in the jump_functions array in the ipa_edge_args corresponding
887 ipa_compute_jump_functions_for_edge (struct cgraph_edge
*cs
)
889 struct ipa_node_params
*info
= IPA_NODE_REF (cs
->caller
);
890 struct ipa_edge_args
*arguments
= IPA_EDGE_REF (cs
);
893 if (ipa_get_cs_argument_count (arguments
) == 0 || arguments
->jump_functions
)
895 arguments
->jump_functions
= ggc_alloc_cleared_vec_ipa_jump_func
896 (ipa_get_cs_argument_count (arguments
));
898 call
= cs
->call_stmt
;
899 gcc_assert (is_gimple_call (call
));
901 /* We will deal with constants and SSA scalars first: */
902 compute_scalar_jump_functions (info
, arguments
->jump_functions
, call
);
904 /* Let's check whether there are any potential member pointers and if so,
905 whether we can determine their functions as pass_through. */
906 if (!compute_pass_through_member_ptrs (info
, arguments
->jump_functions
, call
))
909 /* Finally, let's check whether we actually pass a new constant member
911 compute_cst_member_ptr_arguments (arguments
->jump_functions
, call
);
914 /* Compute jump functions for all edges - both direct and indirect - outgoing
915 from NODE. Also count the actual arguments in the process. */
918 ipa_compute_jump_functions (struct cgraph_node
*node
)
920 struct cgraph_edge
*cs
;
922 for (cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
924 /* We do not need to bother analyzing calls to unknown
925 functions unless they may become known during lto/whopr. */
926 if (!cs
->callee
->analyzed
&& !flag_lto
&& !flag_whopr
)
928 ipa_count_arguments (cs
);
929 if (ipa_get_cs_argument_count (IPA_EDGE_REF (cs
))
930 != ipa_get_param_count (IPA_NODE_REF (cs
->callee
)))
931 ipa_set_called_with_variable_arg (IPA_NODE_REF (cs
->callee
));
932 ipa_compute_jump_functions_for_edge (cs
);
935 for (cs
= node
->indirect_calls
; cs
; cs
= cs
->next_callee
)
937 ipa_count_arguments (cs
);
938 ipa_compute_jump_functions_for_edge (cs
);
942 /* If RHS looks like a rhs of a statement loading pfn from a member
943 pointer formal parameter, return the parameter, otherwise return
944 NULL. If USE_DELTA, then we look for a use of the delta field
945 rather than the pfn. */
948 ipa_get_member_ptr_load_param (tree rhs
, bool use_delta
)
954 if (TREE_CODE (rhs
) != COMPONENT_REF
)
957 rec
= TREE_OPERAND (rhs
, 0);
958 if (TREE_CODE (rec
) != PARM_DECL
959 || !type_like_member_ptr_p (TREE_TYPE (rec
), &ptr_field
, &delta_field
))
962 fld
= TREE_OPERAND (rhs
, 1);
963 if (use_delta
? (fld
== delta_field
) : (fld
== ptr_field
))
969 /* If STMT looks like a statement loading a value from a member pointer formal
970 parameter, this function returns that parameter. */
973 ipa_get_stmt_member_ptr_load_param (gimple stmt
, bool use_delta
)
977 if (!gimple_assign_single_p (stmt
))
980 rhs
= gimple_assign_rhs1 (stmt
);
981 return ipa_get_member_ptr_load_param (rhs
, use_delta
);
984 /* Returns true iff T is an SSA_NAME defined by a statement. */
987 ipa_is_ssa_with_stmt_def (tree t
)
989 if (TREE_CODE (t
) == SSA_NAME
990 && !SSA_NAME_IS_DEFAULT_DEF (t
))
996 /* Find the indirect call graph edge corresponding to STMT and add to it all
997 information necessary to describe a call to a parameter number PARAM_INDEX.
998 NODE is the caller. POLYMORPHIC should be set to true iff the call is a
1002 ipa_note_param_call (struct cgraph_node
*node
, int param_index
, gimple stmt
,
1005 struct cgraph_edge
*cs
;
1007 cs
= cgraph_edge (node
, stmt
);
1008 cs
->indirect_info
->param_index
= param_index
;
1009 cs
->indirect_info
->anc_offset
= 0;
1010 cs
->indirect_info
->polymorphic
= polymorphic
;
1013 tree otr
= gimple_call_fn (stmt
);
1014 tree type
, token
= OBJ_TYPE_REF_TOKEN (otr
);
1015 cs
->indirect_info
->otr_token
= tree_low_cst (token
, 1);
1016 type
= TREE_TYPE (TREE_TYPE (OBJ_TYPE_REF_OBJECT (otr
)));
1017 cs
->indirect_info
->otr_type
= type
;
1021 /* Analyze the CALL and examine uses of formal parameters of the caller NODE
1022 (described by INFO). Currently it checks whether the call calls a pointer
1023 that is a formal parameter and if so, the parameter is marked with the
1024 called flag and an indirect call graph edge describing the call is created.
1025 This is very simple for ordinary pointers represented in SSA but not-so-nice
1026 when it comes to member pointers. The ugly part of this function does
1027 nothing more than trying to match the pattern of such a call. An example of
1028 such a pattern is the gimple dump below, the call is on the last line:
1031 f$__delta_5 = f.__delta;
1032 f$__pfn_24 = f.__pfn;
1033 D.2496_3 = (int) f$__pfn_24;
1034 D.2497_4 = D.2496_3 & 1;
1041 D.2500_7 = (unsigned int) f$__delta_5;
1042 D.2501_8 = &S + D.2500_7;
1043 D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8;
1044 D.2503_10 = *D.2502_9;
1045 D.2504_12 = f$__pfn_24 + -1;
1046 D.2505_13 = (unsigned int) D.2504_12;
1047 D.2506_14 = D.2503_10 + D.2505_13;
1048 D.2507_15 = *D.2506_14;
1049 iftmp.11_16 = (String:: *) D.2507_15;
1052 # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)>
1053 D.2500_19 = (unsigned int) f$__delta_5;
1054 D.2508_20 = &S + D.2500_19;
1055 D.2493_21 = iftmp.11_1 (D.2508_20, 4);
1057 Such patterns are results of simple calls to a member pointer:
1059 int doprinting (int (MyString::* f)(int) const)
1061 MyString S ("somestring");
1068 ipa_analyze_indirect_call_uses (struct cgraph_node
*node
,
1069 struct ipa_node_params
*info
,
1070 gimple call
, tree target
)
1075 tree rec
, rec2
, cond
;
1078 basic_block bb
, virt_bb
, join
;
1080 if (SSA_NAME_IS_DEFAULT_DEF (target
))
1082 tree var
= SSA_NAME_VAR (target
);
1083 index
= ipa_get_param_decl_index (info
, var
);
1085 ipa_note_param_call (node
, index
, call
, false);
1089 /* Now we need to try to match the complex pattern of calling a member
1092 if (!POINTER_TYPE_P (TREE_TYPE (target
))
1093 || TREE_CODE (TREE_TYPE (TREE_TYPE (target
))) != METHOD_TYPE
)
1096 def
= SSA_NAME_DEF_STMT (target
);
1097 if (gimple_code (def
) != GIMPLE_PHI
)
1100 if (gimple_phi_num_args (def
) != 2)
1103 /* First, we need to check whether one of these is a load from a member
1104 pointer that is a parameter to this function. */
1105 n1
= PHI_ARG_DEF (def
, 0);
1106 n2
= PHI_ARG_DEF (def
, 1);
1107 if (!ipa_is_ssa_with_stmt_def (n1
) || !ipa_is_ssa_with_stmt_def (n2
))
1109 d1
= SSA_NAME_DEF_STMT (n1
);
1110 d2
= SSA_NAME_DEF_STMT (n2
);
1112 if ((rec
= ipa_get_stmt_member_ptr_load_param (d1
, false)))
1114 if (ipa_get_stmt_member_ptr_load_param (d2
, false))
1117 bb
= gimple_bb (d1
);
1118 virt_bb
= gimple_bb (d2
);
1120 else if ((rec
= ipa_get_stmt_member_ptr_load_param (d2
, false)))
1122 bb
= gimple_bb (d2
);
1123 virt_bb
= gimple_bb (d1
);
1128 /* Second, we need to check that the basic blocks are laid out in the way
1129 corresponding to the pattern. */
1131 join
= gimple_bb (def
);
1132 if (!single_pred_p (virt_bb
) || !single_succ_p (virt_bb
)
1133 || single_pred (virt_bb
) != bb
1134 || single_succ (virt_bb
) != join
)
1137 /* Third, let's see that the branching is done depending on the least
1138 significant bit of the pfn. */
1140 branch
= last_stmt (bb
);
1141 if (gimple_code (branch
) != GIMPLE_COND
)
1144 if (gimple_cond_code (branch
) != NE_EXPR
1145 || !integer_zerop (gimple_cond_rhs (branch
)))
1148 cond
= gimple_cond_lhs (branch
);
1149 if (!ipa_is_ssa_with_stmt_def (cond
))
1152 def
= SSA_NAME_DEF_STMT (cond
);
1153 if (!is_gimple_assign (def
)
1154 || gimple_assign_rhs_code (def
) != BIT_AND_EXPR
1155 || !integer_onep (gimple_assign_rhs2 (def
)))
1158 cond
= gimple_assign_rhs1 (def
);
1159 if (!ipa_is_ssa_with_stmt_def (cond
))
1162 def
= SSA_NAME_DEF_STMT (cond
);
1164 if (is_gimple_assign (def
)
1165 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def
)))
1167 cond
= gimple_assign_rhs1 (def
);
1168 if (!ipa_is_ssa_with_stmt_def (cond
))
1170 def
= SSA_NAME_DEF_STMT (cond
);
1173 rec2
= ipa_get_stmt_member_ptr_load_param (def
,
1174 (TARGET_PTRMEMFUNC_VBIT_LOCATION
1175 == ptrmemfunc_vbit_in_delta
));
1180 index
= ipa_get_param_decl_index (info
, rec
);
1181 if (index
>= 0 && !ipa_is_param_modified (info
, index
))
1182 ipa_note_param_call (node
, index
, call
, false);
1187 /* Analyze a CALL to an OBJ_TYPE_REF which is passed in TARGET and if the
1188 object referenced in the expression is a formal parameter of the caller
1189 (described by INFO), create a call note for the statement. */
1192 ipa_analyze_virtual_call_uses (struct cgraph_node
*node
,
1193 struct ipa_node_params
*info
, gimple call
,
1196 tree obj
= OBJ_TYPE_REF_OBJECT (target
);
1200 if (TREE_CODE (obj
) == ADDR_EXPR
)
1204 obj
= TREE_OPERAND (obj
, 0);
1206 while (TREE_CODE (obj
) == COMPONENT_REF
);
1207 if (TREE_CODE (obj
) != INDIRECT_REF
)
1209 obj
= TREE_OPERAND (obj
, 0);
1212 if (TREE_CODE (obj
) != SSA_NAME
1213 || !SSA_NAME_IS_DEFAULT_DEF (obj
))
1216 var
= SSA_NAME_VAR (obj
);
1217 index
= ipa_get_param_decl_index (info
, var
);
1220 ipa_note_param_call (node
, index
, call
, true);
1223 /* Analyze a call statement CALL whether and how it utilizes formal parameters
1224 of the caller (described by INFO). */
1227 ipa_analyze_call_uses (struct cgraph_node
*node
,
1228 struct ipa_node_params
*info
, gimple call
)
1230 tree target
= gimple_call_fn (call
);
1232 if (TREE_CODE (target
) == SSA_NAME
)
1233 ipa_analyze_indirect_call_uses (node
, info
, call
, target
);
1234 else if (TREE_CODE (target
) == OBJ_TYPE_REF
)
1235 ipa_analyze_virtual_call_uses (node
, info
, call
, target
);
1239 /* Analyze the call statement STMT with respect to formal parameters (described
1240 in INFO) of caller given by NODE. Currently it only checks whether formal
1241 parameters are called. */
1244 ipa_analyze_stmt_uses (struct cgraph_node
*node
, struct ipa_node_params
*info
,
1247 if (is_gimple_call (stmt
))
1248 ipa_analyze_call_uses (node
, info
, stmt
);
1251 /* Scan the function body of NODE and inspect the uses of formal parameters.
1252 Store the findings in various structures of the associated ipa_node_params
1253 structure, such as parameter flags, notes etc. */
1256 ipa_analyze_params_uses (struct cgraph_node
*node
)
1258 tree decl
= node
->decl
;
1260 struct function
*func
;
1261 gimple_stmt_iterator gsi
;
1262 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
1264 if (ipa_get_param_count (info
) == 0 || info
->uses_analysis_done
)
1267 func
= DECL_STRUCT_FUNCTION (decl
);
1268 FOR_EACH_BB_FN (bb
, func
)
1270 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1272 gimple stmt
= gsi_stmt (gsi
);
1273 ipa_analyze_stmt_uses (node
, info
, stmt
);
1277 info
->uses_analysis_done
= 1;
1280 /* Update the jump function DST when the call graph edge correspondng to SRC is
1281 is being inlined, knowing that DST is of type ancestor and src of known
1285 combine_known_type_and_ancestor_jfs (struct ipa_jump_func
*src
,
1286 struct ipa_jump_func
*dst
)
1290 new_binfo
= get_binfo_at_offset (src
->value
.base_binfo
,
1291 dst
->value
.ancestor
.offset
,
1292 dst
->value
.ancestor
.type
);
1295 dst
->type
= IPA_JF_KNOWN_TYPE
;
1296 dst
->value
.base_binfo
= new_binfo
;
1299 dst
->type
= IPA_JF_UNKNOWN
;
1302 /* Update the jump functions associated with call graph edge E when the call
1303 graph edge CS is being inlined, assuming that E->caller is already (possibly
1304 indirectly) inlined into CS->callee and that E has not been inlined. */
1307 update_jump_functions_after_inlining (struct cgraph_edge
*cs
,
1308 struct cgraph_edge
*e
)
1310 struct ipa_edge_args
*top
= IPA_EDGE_REF (cs
);
1311 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
1312 int count
= ipa_get_cs_argument_count (args
);
1315 for (i
= 0; i
< count
; i
++)
1317 struct ipa_jump_func
*dst
= ipa_get_ith_jump_func (args
, i
);
1319 if (dst
->type
== IPA_JF_ANCESTOR
)
1321 struct ipa_jump_func
*src
;
1323 /* Variable number of arguments can cause havoc if we try to access
1324 one that does not exist in the inlined edge. So make sure we
1326 if (dst
->value
.ancestor
.formal_id
>= ipa_get_cs_argument_count (top
))
1328 dst
->type
= IPA_JF_UNKNOWN
;
1332 src
= ipa_get_ith_jump_func (top
, dst
->value
.ancestor
.formal_id
);
1333 if (src
->type
== IPA_JF_KNOWN_TYPE
)
1334 combine_known_type_and_ancestor_jfs (src
, dst
);
1335 else if (src
->type
== IPA_JF_CONST
)
1337 struct ipa_jump_func kt_func
;
1339 kt_func
.type
= IPA_JF_UNKNOWN
;
1340 compute_known_type_jump_func (src
->value
.constant
, &kt_func
);
1341 if (kt_func
.type
== IPA_JF_KNOWN_TYPE
)
1342 combine_known_type_and_ancestor_jfs (&kt_func
, dst
);
1344 dst
->type
= IPA_JF_UNKNOWN
;
1346 else if (src
->type
== IPA_JF_PASS_THROUGH
1347 && src
->value
.pass_through
.operation
== NOP_EXPR
)
1348 dst
->value
.ancestor
.formal_id
= src
->value
.pass_through
.formal_id
;
1349 else if (src
->type
== IPA_JF_ANCESTOR
)
1351 dst
->value
.ancestor
.formal_id
= src
->value
.ancestor
.formal_id
;
1352 dst
->value
.ancestor
.offset
+= src
->value
.ancestor
.offset
;
1355 dst
->type
= IPA_JF_UNKNOWN
;
1357 else if (dst
->type
== IPA_JF_PASS_THROUGH
)
1359 struct ipa_jump_func
*src
;
1360 /* We must check range due to calls with variable number of arguments
1361 and we cannot combine jump functions with operations. */
1362 if (dst
->value
.pass_through
.operation
== NOP_EXPR
1363 && (dst
->value
.pass_through
.formal_id
1364 < ipa_get_cs_argument_count (top
)))
1366 src
= ipa_get_ith_jump_func (top
,
1367 dst
->value
.pass_through
.formal_id
);
1371 dst
->type
= IPA_JF_UNKNOWN
;
1376 /* If TARGET is an addr_expr of a function declaration, make it the destination
1377 of an indirect edge IE and return the edge. Otherwise, return NULL. */
1379 static struct cgraph_edge
*
1380 make_edge_direct_to_target (struct cgraph_edge
*ie
, tree target
)
1382 struct cgraph_node
*callee
;
1384 if (TREE_CODE (target
) != ADDR_EXPR
)
1386 target
= TREE_OPERAND (target
, 0);
1387 if (TREE_CODE (target
) != FUNCTION_DECL
)
1389 callee
= cgraph_node (target
);
1393 cgraph_make_edge_direct (ie
, callee
);
1396 fprintf (dump_file
, "ipa-prop: Discovered %s call to a known target "
1397 "(%s/%i -> %s/%i) for stmt ",
1398 ie
->indirect_info
->polymorphic
? "a virtual" : "an indirect",
1399 cgraph_node_name (ie
->caller
), ie
->caller
->uid
,
1400 cgraph_node_name (ie
->callee
), ie
->callee
->uid
);
1403 print_gimple_stmt (dump_file
, ie
->call_stmt
, 2, TDF_SLIM
);
1405 fprintf (dump_file
, "with uid %i\n", ie
->lto_stmt_uid
);
1408 if (ipa_get_cs_argument_count (IPA_EDGE_REF (ie
))
1409 != ipa_get_param_count (IPA_NODE_REF (callee
)))
1410 ipa_set_called_with_variable_arg (IPA_NODE_REF (callee
));
1415 /* Try to find a destination for indirect edge IE that corresponds to a simple
1416 call or a call of a member function pointer and where the destination is a
1417 pointer formal parameter described by jump function JFUNC. If it can be
1418 determined, return the newly direct edge, otherwise return NULL. */
1420 static struct cgraph_edge
*
1421 try_make_edge_direct_simple_call (struct cgraph_edge
*ie
,
1422 struct ipa_jump_func
*jfunc
)
1426 if (jfunc
->type
== IPA_JF_CONST
)
1427 target
= jfunc
->value
.constant
;
1428 else if (jfunc
->type
== IPA_JF_CONST_MEMBER_PTR
)
1429 target
= jfunc
->value
.member_cst
.pfn
;
1433 return make_edge_direct_to_target (ie
, target
);
1436 /* Try to find a destination for indirect edge IE that corresponds to a
1437 virtuall call based on a formal parameter which is described by jump
1438 function JFUNC and if it can be determined, make it direct and return the
1439 direct edge. Otherwise, return NULL. */
1441 static struct cgraph_edge
*
1442 try_make_edge_direct_virtual_call (struct cgraph_edge
*ie
,
1443 struct ipa_jump_func
*jfunc
)
1445 tree binfo
, type
, target
;
1446 HOST_WIDE_INT token
;
1448 if (jfunc
->type
== IPA_JF_KNOWN_TYPE
)
1449 binfo
= jfunc
->value
.base_binfo
;
1450 else if (jfunc
->type
== IPA_JF_CONST
)
1452 tree cst
= jfunc
->value
.constant
;
1453 if (TREE_CODE (cst
) == ADDR_EXPR
)
1454 binfo
= gimple_get_relevant_ref_binfo (TREE_OPERAND (cst
, 0),
1465 token
= ie
->indirect_info
->otr_token
;
1466 type
= ie
->indirect_info
->otr_type
;
1467 binfo
= get_binfo_at_offset (binfo
, ie
->indirect_info
->anc_offset
, type
);
1469 target
= gimple_fold_obj_type_ref_known_binfo (token
, binfo
);
1474 return make_edge_direct_to_target (ie
, target
);
1479 /* Update the param called notes associated with NODE when CS is being inlined,
1480 assuming NODE is (potentially indirectly) inlined into CS->callee.
1481 Moreover, if the callee is discovered to be constant, create a new cgraph
1482 edge for it. Newly discovered indirect edges will be added to *NEW_EDGES,
1483 unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
1486 update_indirect_edges_after_inlining (struct cgraph_edge
*cs
,
1487 struct cgraph_node
*node
,
1488 VEC (cgraph_edge_p
, heap
) **new_edges
)
1490 struct ipa_edge_args
*top
= IPA_EDGE_REF (cs
);
1491 struct cgraph_edge
*ie
, *next_ie
, *new_direct_edge
;
1494 ipa_check_create_edge_args ();
1496 for (ie
= node
->indirect_calls
; ie
; ie
= next_ie
)
1498 struct cgraph_indirect_call_info
*ici
= ie
->indirect_info
;
1499 struct ipa_jump_func
*jfunc
;
1501 next_ie
= ie
->next_callee
;
1502 if (bitmap_bit_p (iinlining_processed_edges
, ie
->uid
))
1505 /* If we ever use indirect edges for anything other than indirect
1506 inlining, we will need to skip those with negative param_indices. */
1507 if (ici
->param_index
== -1)
1510 /* We must check range due to calls with variable number of arguments: */
1511 if (ici
->param_index
>= ipa_get_cs_argument_count (top
))
1513 bitmap_set_bit (iinlining_processed_edges
, ie
->uid
);
1517 jfunc
= ipa_get_ith_jump_func (top
, ici
->param_index
);
1518 if (jfunc
->type
== IPA_JF_PASS_THROUGH
1519 && jfunc
->value
.pass_through
.operation
== NOP_EXPR
)
1520 ici
->param_index
= jfunc
->value
.pass_through
.formal_id
;
1521 else if (jfunc
->type
== IPA_JF_ANCESTOR
)
1523 ici
->param_index
= jfunc
->value
.ancestor
.formal_id
;
1524 ici
->anc_offset
+= jfunc
->value
.ancestor
.offset
;
1527 /* Either we can find a destination for this edge now or never. */
1528 bitmap_set_bit (iinlining_processed_edges
, ie
->uid
);
1530 if (ici
->polymorphic
)
1531 new_direct_edge
= try_make_edge_direct_virtual_call (ie
, jfunc
);
1533 new_direct_edge
= try_make_edge_direct_simple_call (ie
, jfunc
);
1535 if (new_direct_edge
)
1537 new_direct_edge
->indirect_inlining_edge
= 1;
1540 VEC_safe_push (cgraph_edge_p
, heap
, *new_edges
,
1542 top
= IPA_EDGE_REF (cs
);
1551 /* Recursively traverse subtree of NODE (including node) made of inlined
1552 cgraph_edges when CS has been inlined and invoke
1553 update_indirect_edges_after_inlining on all nodes and
1554 update_jump_functions_after_inlining on all non-inlined edges that lead out
1555 of this subtree. Newly discovered indirect edges will be added to
1556 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were
1560 propagate_info_to_inlined_callees (struct cgraph_edge
*cs
,
1561 struct cgraph_node
*node
,
1562 VEC (cgraph_edge_p
, heap
) **new_edges
)
1564 struct cgraph_edge
*e
;
1567 res
= update_indirect_edges_after_inlining (cs
, node
, new_edges
);
1569 for (e
= node
->callees
; e
; e
= e
->next_callee
)
1570 if (!e
->inline_failed
)
1571 res
|= propagate_info_to_inlined_callees (cs
, e
->callee
, new_edges
);
1573 update_jump_functions_after_inlining (cs
, e
);
1578 /* Update jump functions and call note functions on inlining the call site CS.
1579 CS is expected to lead to a node already cloned by
1580 cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to
1581 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were +
1585 ipa_propagate_indirect_call_infos (struct cgraph_edge
*cs
,
1586 VEC (cgraph_edge_p
, heap
) **new_edges
)
1588 /* FIXME lto: We do not stream out indirect call information. */
1592 /* Do nothing if the preparation phase has not been carried out yet
1593 (i.e. during early inlining). */
1594 if (!ipa_node_params_vector
)
1596 gcc_assert (ipa_edge_args_vector
);
1598 return propagate_info_to_inlined_callees (cs
, cs
->callee
, new_edges
);
1601 /* Frees all dynamically allocated structures that the argument info points
1605 ipa_free_edge_args_substructures (struct ipa_edge_args
*args
)
1607 if (args
->jump_functions
)
1608 ggc_free (args
->jump_functions
);
1610 memset (args
, 0, sizeof (*args
));
1613 /* Free all ipa_edge structures. */
1616 ipa_free_all_edge_args (void)
1619 struct ipa_edge_args
*args
;
1622 VEC_iterate (ipa_edge_args_t
, ipa_edge_args_vector
, i
, args
);
1624 ipa_free_edge_args_substructures (args
);
1626 VEC_free (ipa_edge_args_t
, gc
, ipa_edge_args_vector
);
1627 ipa_edge_args_vector
= NULL
;
1630 /* Frees all dynamically allocated structures that the param info points
1634 ipa_free_node_params_substructures (struct ipa_node_params
*info
)
1637 free (info
->params
);
1639 memset (info
, 0, sizeof (*info
));
1642 /* Free all ipa_node_params structures. */
1645 ipa_free_all_node_params (void)
1648 struct ipa_node_params
*info
;
1651 VEC_iterate (ipa_node_params_t
, ipa_node_params_vector
, i
, info
);
1653 ipa_free_node_params_substructures (info
);
1655 VEC_free (ipa_node_params_t
, heap
, ipa_node_params_vector
);
1656 ipa_node_params_vector
= NULL
;
1659 /* Hook that is called by cgraph.c when an edge is removed. */
1662 ipa_edge_removal_hook (struct cgraph_edge
*cs
, void *data ATTRIBUTE_UNUSED
)
1664 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1665 if (VEC_length (ipa_edge_args_t
, ipa_edge_args_vector
)
1666 <= (unsigned)cs
->uid
)
1668 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs
));
1671 /* Hook that is called by cgraph.c when a node is removed. */
1674 ipa_node_removal_hook (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
1676 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1677 if (VEC_length (ipa_node_params_t
, ipa_node_params_vector
)
1678 <= (unsigned)node
->uid
)
1680 ipa_free_node_params_substructures (IPA_NODE_REF (node
));
1683 /* Helper function to duplicate an array of size N that is at SRC and store a
1684 pointer to it to DST. Nothing is done if SRC is NULL. */
1687 duplicate_array (void *src
, size_t n
)
1699 static struct ipa_jump_func
*
1700 duplicate_ipa_jump_func_array (const struct ipa_jump_func
* src
, size_t n
)
1702 struct ipa_jump_func
*p
;
1707 p
= ggc_alloc_vec_ipa_jump_func (n
);
1708 memcpy (p
, src
, n
* sizeof (struct ipa_jump_func
));
1712 /* Hook that is called by cgraph.c when a node is duplicated. */
1715 ipa_edge_duplication_hook (struct cgraph_edge
*src
, struct cgraph_edge
*dst
,
1716 __attribute__((unused
)) void *data
)
1718 struct ipa_edge_args
*old_args
, *new_args
;
1721 ipa_check_create_edge_args ();
1723 old_args
= IPA_EDGE_REF (src
);
1724 new_args
= IPA_EDGE_REF (dst
);
1726 arg_count
= ipa_get_cs_argument_count (old_args
);
1727 ipa_set_cs_argument_count (new_args
, arg_count
);
1728 new_args
->jump_functions
=
1729 duplicate_ipa_jump_func_array (old_args
->jump_functions
, 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 (ob
->main_stream
);
2411 bp_pack_value (&bp
, ii
->polymorphic
, 1);
2412 lto_output_bitpack (&bp
);
2414 if (ii
->polymorphic
)
2416 lto_output_sleb128_stream (ob
->main_stream
, ii
->otr_token
);
2417 lto_output_tree (ob
, ii
->otr_type
, true);
2421 /* Read in parts of cgraph_indirect_call_info corresponding to CS that are
2422 relevant to indirect inlining from IB. */
2425 ipa_read_indirect_edge_info (struct lto_input_block
*ib
,
2426 struct data_in
*data_in ATTRIBUTE_UNUSED
,
2427 struct cgraph_edge
*cs
)
2429 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
2430 struct bitpack_d bp
;
2432 ii
->param_index
= (int) lto_input_sleb128 (ib
);
2433 ii
->anc_offset
= (HOST_WIDE_INT
) lto_input_sleb128 (ib
);
2434 bp
= lto_input_bitpack (ib
);
2435 ii
->polymorphic
= bp_unpack_value (&bp
, 1);
2436 if (ii
->polymorphic
)
2438 ii
->otr_token
= (HOST_WIDE_INT
) lto_input_sleb128 (ib
);
2439 ii
->otr_type
= lto_input_tree (ib
, data_in
);
2443 /* Stream out NODE info to OB. */
2446 ipa_write_node_info (struct output_block
*ob
, struct cgraph_node
*node
)
2449 lto_cgraph_encoder_t encoder
;
2450 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
2452 struct cgraph_edge
*e
;
2453 struct bitpack_d bp
;
2455 encoder
= ob
->decl_state
->cgraph_node_encoder
;
2456 node_ref
= lto_cgraph_encoder_encode (encoder
, node
);
2457 lto_output_uleb128_stream (ob
->main_stream
, node_ref
);
2459 bp
= bitpack_create (ob
->main_stream
);
2460 bp_pack_value (&bp
, info
->called_with_var_arguments
, 1);
2461 bp_pack_value (&bp
, info
->uses_analysis_done
, 1);
2462 gcc_assert (info
->modification_analysis_done
2463 || ipa_get_param_count (info
) == 0);
2464 gcc_assert (!info
->node_enqueued
);
2465 gcc_assert (!info
->ipcp_orig_node
);
2466 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
2468 bp_pack_value (&bp
, info
->params
[j
].modified
, 1);
2469 bp_pack_value (&bp
, info
->params
[j
].used
, 1);
2471 lto_output_bitpack (&bp
);
2472 for (e
= node
->callees
; e
; e
= e
->next_callee
)
2474 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
2476 lto_output_uleb128_stream (ob
->main_stream
,
2477 ipa_get_cs_argument_count (args
));
2478 for (j
= 0; j
< ipa_get_cs_argument_count (args
); j
++)
2479 ipa_write_jump_function (ob
, ipa_get_ith_jump_func (args
, j
));
2481 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
2482 ipa_write_indirect_edge_info (ob
, e
);
2485 /* Srtream in NODE info from IB. */
2488 ipa_read_node_info (struct lto_input_block
*ib
, struct cgraph_node
*node
,
2489 struct data_in
*data_in
)
2491 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
2493 struct cgraph_edge
*e
;
2494 struct bitpack_d bp
;
2496 ipa_initialize_node_params (node
);
2498 bp
= lto_input_bitpack (ib
);
2499 info
->called_with_var_arguments
= bp_unpack_value (&bp
, 1);
2500 info
->uses_analysis_done
= bp_unpack_value (&bp
, 1);
2501 if (ipa_get_param_count (info
) != 0)
2503 info
->modification_analysis_done
= true;
2504 info
->uses_analysis_done
= true;
2506 info
->node_enqueued
= false;
2507 for (k
= 0; k
< ipa_get_param_count (info
); k
++)
2509 info
->params
[k
].modified
= bp_unpack_value (&bp
, 1);
2510 info
->params
[k
].used
= bp_unpack_value (&bp
, 1);
2512 for (e
= node
->callees
; e
; e
= e
->next_callee
)
2514 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
2515 int count
= lto_input_uleb128 (ib
);
2517 ipa_set_cs_argument_count (args
, count
);
2521 args
->jump_functions
= ggc_alloc_cleared_vec_ipa_jump_func
2522 (ipa_get_cs_argument_count (args
));
2523 for (k
= 0; k
< ipa_get_cs_argument_count (args
); k
++)
2524 ipa_read_jump_function (ib
, ipa_get_ith_jump_func (args
, k
), data_in
);
2526 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
2527 ipa_read_indirect_edge_info (ib
, data_in
, e
);
2530 /* Write jump functions for nodes in SET. */
2533 ipa_prop_write_jump_functions (cgraph_node_set set
)
2535 struct cgraph_node
*node
;
2536 struct output_block
*ob
= create_output_block (LTO_section_jump_functions
);
2537 unsigned int count
= 0;
2538 cgraph_node_set_iterator csi
;
2540 ob
->cgraph_node
= NULL
;
2542 for (csi
= csi_start (set
); !csi_end_p (csi
); csi_next (&csi
))
2544 node
= csi_node (csi
);
2545 if (node
->analyzed
&& IPA_NODE_REF (node
) != NULL
)
2549 lto_output_uleb128_stream (ob
->main_stream
, count
);
2551 /* Process all of the functions. */
2552 for (csi
= csi_start (set
); !csi_end_p (csi
); csi_next (&csi
))
2554 node
= csi_node (csi
);
2555 if (node
->analyzed
&& IPA_NODE_REF (node
) != NULL
)
2556 ipa_write_node_info (ob
, node
);
2558 lto_output_1_stream (ob
->main_stream
, 0);
2559 produce_asm (ob
, NULL
);
2560 destroy_output_block (ob
);
2563 /* Read section in file FILE_DATA of length LEN with data DATA. */
2566 ipa_prop_read_section (struct lto_file_decl_data
*file_data
, const char *data
,
2569 const struct lto_function_header
*header
=
2570 (const struct lto_function_header
*) data
;
2571 const int32_t cfg_offset
= sizeof (struct lto_function_header
);
2572 const int32_t main_offset
= cfg_offset
+ header
->cfg_size
;
2573 const int32_t string_offset
= main_offset
+ header
->main_size
;
2574 struct data_in
*data_in
;
2575 struct lto_input_block ib_main
;
2579 LTO_INIT_INPUT_BLOCK (ib_main
, (const char *) data
+ main_offset
, 0,
2583 lto_data_in_create (file_data
, (const char *) data
+ string_offset
,
2584 header
->string_size
, NULL
);
2585 count
= lto_input_uleb128 (&ib_main
);
2587 for (i
= 0; i
< count
; i
++)
2590 struct cgraph_node
*node
;
2591 lto_cgraph_encoder_t encoder
;
2593 index
= lto_input_uleb128 (&ib_main
);
2594 encoder
= file_data
->cgraph_node_encoder
;
2595 node
= lto_cgraph_encoder_deref (encoder
, index
);
2596 gcc_assert (node
->analyzed
);
2597 ipa_read_node_info (&ib_main
, node
, data_in
);
2599 lto_free_section_data (file_data
, LTO_section_jump_functions
, NULL
, data
,
2601 lto_data_in_delete (data_in
);
2604 /* Read ipcp jump functions. */
2607 ipa_prop_read_jump_functions (void)
2609 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
2610 struct lto_file_decl_data
*file_data
;
2613 ipa_check_create_node_params ();
2614 ipa_check_create_edge_args ();
2615 ipa_register_cgraph_hooks ();
2617 while ((file_data
= file_data_vec
[j
++]))
2620 const char *data
= lto_get_section_data (file_data
, LTO_section_jump_functions
, NULL
, &len
);
2623 ipa_prop_read_section (file_data
, data
, len
);
2627 /* After merging units, we can get mismatch in argument counts.
2628 Also decl merging might've rendered parameter lists obsolette.
2629 Also compute called_with_variable_arg info. */
2632 ipa_update_after_lto_read (void)
2634 struct cgraph_node
*node
;
2635 struct cgraph_edge
*cs
;
2637 ipa_check_create_node_params ();
2638 ipa_check_create_edge_args ();
2640 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2642 ipa_initialize_node_params (node
);
2644 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2646 for (cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
2648 if (ipa_get_cs_argument_count (IPA_EDGE_REF (cs
))
2649 != ipa_get_param_count (IPA_NODE_REF (cs
->callee
)))
2650 ipa_set_called_with_variable_arg (IPA_NODE_REF (cs
->callee
));