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"
43 /* Intermediate information about a parameter that is only useful during the
44 run of ipa_analyze_node and is not kept afterwards. */
46 struct param_analysis_info
49 bitmap visited_statements
;
52 /* Vector where the parameter infos are actually stored. */
53 VEC (ipa_node_params_t
, heap
) *ipa_node_params_vector
;
54 /* Vector where the parameter infos are actually stored. */
55 VEC (ipa_edge_args_t
, gc
) *ipa_edge_args_vector
;
57 /* Bitmap with all UIDs of call graph edges that have been already processed
58 by indirect inlining. */
59 static bitmap iinlining_processed_edges
;
61 /* Holders of ipa cgraph hooks: */
62 static struct cgraph_edge_hook_list
*edge_removal_hook_holder
;
63 static struct cgraph_node_hook_list
*node_removal_hook_holder
;
64 static struct cgraph_2edge_hook_list
*edge_duplication_hook_holder
;
65 static struct cgraph_2node_hook_list
*node_duplication_hook_holder
;
66 static struct cgraph_node_hook_list
*function_insertion_hook_holder
;
68 /* Add cgraph NODE described by INFO to the worklist WL regardless of whether
69 it is in one or not. It should almost never be used directly, as opposed to
70 ipa_push_func_to_list. */
73 ipa_push_func_to_list_1 (struct ipa_func_list
**wl
,
74 struct cgraph_node
*node
,
75 struct ipa_node_params
*info
)
77 struct ipa_func_list
*temp
;
79 info
->node_enqueued
= 1;
80 temp
= XCNEW (struct ipa_func_list
);
86 /* Initialize worklist to contain all functions. */
88 struct ipa_func_list
*
89 ipa_init_func_list (void)
91 struct cgraph_node
*node
;
92 struct ipa_func_list
* wl
;
95 for (node
= cgraph_nodes
; node
; node
= node
->next
)
96 if (node
->analyzed
&& !node
->alias
)
98 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
99 /* Unreachable nodes should have been eliminated before ipcp and
101 gcc_assert (node
->needed
|| node
->reachable
);
102 ipa_push_func_to_list_1 (&wl
, node
, info
);
108 /* Remove a function from the worklist WL and return it. */
111 ipa_pop_func_from_list (struct ipa_func_list
**wl
)
113 struct ipa_node_params
*info
;
114 struct ipa_func_list
*first
;
115 struct cgraph_node
*node
;
122 info
= IPA_NODE_REF (node
);
123 info
->node_enqueued
= 0;
127 /* Return index of the formal whose tree is PTREE in function which corresponds
131 ipa_get_param_decl_index (struct ipa_node_params
*info
, tree ptree
)
135 count
= ipa_get_param_count (info
);
136 for (i
= 0; i
< count
; i
++)
137 if (ipa_get_param(info
, i
) == ptree
)
143 /* Populate the param_decl field in parameter descriptors of INFO that
144 corresponds to NODE. */
147 ipa_populate_param_decls (struct cgraph_node
*node
,
148 struct ipa_node_params
*info
)
156 fnargs
= DECL_ARGUMENTS (fndecl
);
158 for (parm
= fnargs
; parm
; parm
= DECL_CHAIN (parm
))
160 info
->params
[param_num
].decl
= parm
;
165 /* Return how many formal parameters FNDECL has. */
168 count_formal_params_1 (tree fndecl
)
173 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
179 /* Count number of formal parameters in NOTE. Store the result to the
180 appropriate field of INFO. */
183 ipa_count_formal_params (struct cgraph_node
*node
,
184 struct ipa_node_params
*info
)
188 param_num
= count_formal_params_1 (node
->decl
);
189 ipa_set_param_count (info
, param_num
);
192 /* Initialize the ipa_node_params structure associated with NODE by counting
193 the function parameters, creating the descriptors and populating their
197 ipa_initialize_node_params (struct cgraph_node
*node
)
199 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
203 ipa_count_formal_params (node
, info
);
204 info
->params
= XCNEWVEC (struct ipa_param_descriptor
,
205 ipa_get_param_count (info
));
206 ipa_populate_param_decls (node
, info
);
210 /* Count number of arguments callsite CS has and store it in
211 ipa_edge_args structure corresponding to this callsite. */
214 ipa_count_arguments (struct cgraph_edge
*cs
)
219 stmt
= cs
->call_stmt
;
220 gcc_assert (is_gimple_call (stmt
));
221 arg_num
= gimple_call_num_args (stmt
);
222 if (VEC_length (ipa_edge_args_t
, ipa_edge_args_vector
)
223 <= (unsigned) cgraph_edge_max_uid
)
224 VEC_safe_grow_cleared (ipa_edge_args_t
, gc
,
225 ipa_edge_args_vector
, cgraph_edge_max_uid
+ 1);
226 ipa_set_cs_argument_count (IPA_EDGE_REF (cs
), arg_num
);
229 /* Print the jump functions associated with call graph edge CS to file F. */
232 ipa_print_node_jump_functions_for_edge (FILE *f
, struct cgraph_edge
*cs
)
236 count
= ipa_get_cs_argument_count (IPA_EDGE_REF (cs
));
237 for (i
= 0; i
< count
; i
++)
239 struct ipa_jump_func
*jump_func
;
240 enum jump_func_type type
;
242 jump_func
= ipa_get_ith_jump_func (IPA_EDGE_REF (cs
), i
);
243 type
= jump_func
->type
;
245 fprintf (f
, " param %d: ", i
);
246 if (type
== IPA_JF_UNKNOWN
)
247 fprintf (f
, "UNKNOWN\n");
248 else if (type
== IPA_JF_KNOWN_TYPE
)
250 tree binfo_type
= TREE_TYPE (jump_func
->value
.base_binfo
);
251 fprintf (f
, "KNOWN TYPE, type in binfo is: ");
252 print_generic_expr (f
, binfo_type
, 0);
253 fprintf (f
, " (%u)\n", TYPE_UID (binfo_type
));
255 else if (type
== IPA_JF_CONST
)
257 tree val
= jump_func
->value
.constant
;
258 fprintf (f
, "CONST: ");
259 print_generic_expr (f
, val
, 0);
260 if (TREE_CODE (val
) == ADDR_EXPR
261 && TREE_CODE (TREE_OPERAND (val
, 0)) == CONST_DECL
)
264 print_generic_expr (f
, DECL_INITIAL (TREE_OPERAND (val
, 0)),
269 else if (type
== IPA_JF_CONST_MEMBER_PTR
)
271 fprintf (f
, "CONST MEMBER PTR: ");
272 print_generic_expr (f
, jump_func
->value
.member_cst
.pfn
, 0);
274 print_generic_expr (f
, jump_func
->value
.member_cst
.delta
, 0);
277 else if (type
== IPA_JF_PASS_THROUGH
)
279 fprintf (f
, "PASS THROUGH: ");
280 fprintf (f
, "%d, op %s ",
281 jump_func
->value
.pass_through
.formal_id
,
283 jump_func
->value
.pass_through
.operation
]);
284 if (jump_func
->value
.pass_through
.operation
!= NOP_EXPR
)
285 print_generic_expr (dump_file
,
286 jump_func
->value
.pass_through
.operand
, 0);
287 fprintf (dump_file
, "\n");
289 else if (type
== IPA_JF_ANCESTOR
)
291 fprintf (f
, "ANCESTOR: ");
292 fprintf (f
, "%d, offset "HOST_WIDE_INT_PRINT_DEC
", ",
293 jump_func
->value
.ancestor
.formal_id
,
294 jump_func
->value
.ancestor
.offset
);
295 print_generic_expr (f
, jump_func
->value
.ancestor
.type
, 0);
296 fprintf (dump_file
, "\n");
302 /* Print the jump functions of all arguments on all call graph edges going from
306 ipa_print_node_jump_functions (FILE *f
, struct cgraph_node
*node
)
308 struct cgraph_edge
*cs
;
311 fprintf (f
, " Jump functions of caller %s:\n", cgraph_node_name (node
));
312 for (cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
314 if (!ipa_edge_args_info_available_for_edge_p (cs
))
317 fprintf (f
, " callsite %s/%i -> %s/%i : \n",
318 cgraph_node_name (node
), node
->uid
,
319 cgraph_node_name (cs
->callee
), cs
->callee
->uid
);
320 ipa_print_node_jump_functions_for_edge (f
, cs
);
323 for (cs
= node
->indirect_calls
, i
= 0; cs
; cs
= cs
->next_callee
, i
++)
325 if (!ipa_edge_args_info_available_for_edge_p (cs
))
330 fprintf (f
, " indirect callsite %d for stmt ", i
);
331 print_gimple_stmt (f
, cs
->call_stmt
, 0, TDF_SLIM
);
334 fprintf (f
, " indirect callsite %d :\n", i
);
335 ipa_print_node_jump_functions_for_edge (f
, cs
);
340 /* Print ipa_jump_func data structures of all nodes in the call graph to F. */
343 ipa_print_all_jump_functions (FILE *f
)
345 struct cgraph_node
*node
;
347 fprintf (f
, "\nJump functions:\n");
348 for (node
= cgraph_nodes
; node
; node
= node
->next
)
350 ipa_print_node_jump_functions (f
, node
);
354 /* Structure to be passed in between detect_type_change and
355 check_stmt_for_type_change. */
357 struct type_change_info
359 /* Set to true if dynamic type change has been detected. */
360 bool type_maybe_changed
;
363 /* Return true if STMT can modify a virtual method table pointer.
365 This function makes special assumptions about both constructors and
366 destructors which are all the functions that are allowed to alter the VMT
367 pointers. It assumes that destructors begin with assignment into all VMT
368 pointers and that constructors essentially look in the following way:
370 1) The very first thing they do is that they call constructors of ancestor
371 sub-objects that have them.
373 2) Then VMT pointers of this and all its ancestors is set to new values
374 corresponding to the type corresponding to the constructor.
376 3) Only afterwards, other stuff such as constructor of member sub-objects
377 and the code written by the user is run. Only this may include calling
378 virtual functions, directly or indirectly.
380 There is no way to call a constructor of an ancestor sub-object in any
383 This means that we do not have to care whether constructors get the correct
384 type information because they will always change it (in fact, if we define
385 the type to be given by the VMT pointer, it is undefined).
387 The most important fact to derive from the above is that if, for some
388 statement in the section 3, we try to detect whether the dynamic type has
389 changed, we can safely ignore all calls as we examine the function body
390 backwards until we reach statements in section 2 because these calls cannot
391 be ancestor constructors or destructors (if the input is not bogus) and so
392 do not change the dynamic type (this holds true only for automatically
393 allocated objects but at the moment we devirtualize only these). We then
394 must detect that statements in section 2 change the dynamic type and can try
395 to derive the new type. That is enough and we can stop, we will never see
396 the calls into constructors of sub-objects in this code. Therefore we can
397 safely ignore all call statements that we traverse.
401 stmt_may_be_vtbl_ptr_store (gimple stmt
)
403 if (is_gimple_call (stmt
))
405 else if (is_gimple_assign (stmt
))
407 tree lhs
= gimple_assign_lhs (stmt
);
409 if (!AGGREGATE_TYPE_P (TREE_TYPE (lhs
)))
411 if (flag_strict_aliasing
412 && !POINTER_TYPE_P (TREE_TYPE (lhs
)))
415 if (TREE_CODE (lhs
) == COMPONENT_REF
416 && !DECL_VIRTUAL_P (TREE_OPERAND (lhs
, 1)))
418 /* In the future we might want to use get_base_ref_and_offset to find
419 if there is a field corresponding to the offset and if so, proceed
420 almost like if it was a component ref. */
426 /* Callback of walk_aliased_vdefs and a helper function for
427 detect_type_change to check whether a particular statement may modify
428 the virtual table pointer, and if possible also determine the new type of
429 the (sub-)object. It stores its result into DATA, which points to a
430 type_change_info structure. */
433 check_stmt_for_type_change (ao_ref
*ao ATTRIBUTE_UNUSED
, tree vdef
, void *data
)
435 gimple stmt
= SSA_NAME_DEF_STMT (vdef
);
436 struct type_change_info
*tci
= (struct type_change_info
*) data
;
438 if (stmt_may_be_vtbl_ptr_store (stmt
))
440 tci
->type_maybe_changed
= true;
447 /* Detect whether the dynamic type of ARG has changed (before callsite CALL) by
448 looking for assignments to its virtual table pointer. If it is, return true
449 and fill in the jump function JFUNC with relevant type information or set it
450 to unknown. ARG is the object itself (not a pointer to it, unless
451 dereferenced). BASE is the base of the memory access as returned by
452 get_ref_base_and_extent, as is the offset. */
455 detect_type_change (tree arg
, tree base
, gimple call
,
456 struct ipa_jump_func
*jfunc
, HOST_WIDE_INT offset
)
458 struct type_change_info tci
;
461 gcc_checking_assert (DECL_P (arg
)
462 || TREE_CODE (arg
) == MEM_REF
463 || handled_component_p (arg
));
464 /* Const calls cannot call virtual methods through VMT and so type changes do
466 if (!flag_devirtualize
|| !gimple_vuse (call
))
469 tci
.type_maybe_changed
= false;
474 ao
.size
= POINTER_SIZE
;
475 ao
.max_size
= ao
.size
;
476 ao
.ref_alias_set
= -1;
477 ao
.base_alias_set
= -1;
479 walk_aliased_vdefs (&ao
, gimple_vuse (call
), check_stmt_for_type_change
,
481 if (!tci
.type_maybe_changed
)
484 jfunc
->type
= IPA_JF_UNKNOWN
;
488 /* Like detect_type_change but ARG is supposed to be a non-dereferenced pointer
489 SSA name (its dereference will become the base and the offset is assumed to
493 detect_type_change_ssa (tree arg
, gimple call
, struct ipa_jump_func
*jfunc
)
495 gcc_checking_assert (TREE_CODE (arg
) == SSA_NAME
);
496 if (!flag_devirtualize
497 || !POINTER_TYPE_P (TREE_TYPE (arg
))
498 || TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) != RECORD_TYPE
)
501 arg
= build2 (MEM_REF
, ptr_type_node
, arg
,
502 build_int_cst (ptr_type_node
, 0));
504 return detect_type_change (arg
, arg
, call
, jfunc
, 0);
508 /* Given that an actual argument is an SSA_NAME (given in NAME) and is a result
509 of an assignment statement STMT, try to find out whether NAME can be
510 described by a (possibly polynomial) pass-through jump-function or an
511 ancestor jump function and if so, write the appropriate function into
515 compute_complex_assign_jump_func (struct ipa_node_params
*info
,
516 struct ipa_jump_func
*jfunc
,
517 gimple call
, gimple stmt
, tree name
)
519 HOST_WIDE_INT offset
, size
, max_size
;
520 tree op1
, op2
, base
, ssa
;
523 op1
= gimple_assign_rhs1 (stmt
);
524 op2
= gimple_assign_rhs2 (stmt
);
526 if (TREE_CODE (op1
) == SSA_NAME
527 && SSA_NAME_IS_DEFAULT_DEF (op1
))
529 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (op1
));
535 if (!is_gimple_ip_invariant (op2
)
536 || (TREE_CODE_CLASS (gimple_expr_code (stmt
)) != tcc_comparison
537 && !useless_type_conversion_p (TREE_TYPE (name
),
541 jfunc
->type
= IPA_JF_PASS_THROUGH
;
542 jfunc
->value
.pass_through
.formal_id
= index
;
543 jfunc
->value
.pass_through
.operation
= gimple_assign_rhs_code (stmt
);
544 jfunc
->value
.pass_through
.operand
= op2
;
546 else if (gimple_assign_unary_nop_p (stmt
)
547 && !detect_type_change_ssa (op1
, call
, jfunc
))
549 jfunc
->type
= IPA_JF_PASS_THROUGH
;
550 jfunc
->value
.pass_through
.formal_id
= index
;
551 jfunc
->value
.pass_through
.operation
= NOP_EXPR
;
556 if (TREE_CODE (op1
) != ADDR_EXPR
)
558 op1
= TREE_OPERAND (op1
, 0);
559 if (TREE_CODE (TREE_TYPE (op1
)) != RECORD_TYPE
)
561 base
= get_ref_base_and_extent (op1
, &offset
, &size
, &max_size
);
562 if (TREE_CODE (base
) != MEM_REF
563 /* If this is a varying address, punt. */
567 offset
+= mem_ref_offset (base
).low
* BITS_PER_UNIT
;
568 ssa
= TREE_OPERAND (base
, 0);
569 if (TREE_CODE (ssa
) != SSA_NAME
570 || !SSA_NAME_IS_DEFAULT_DEF (ssa
)
574 /* Dynamic types are changed only in constructors and destructors and */
575 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (ssa
));
577 && !detect_type_change (op1
, base
, call
, jfunc
, offset
))
579 jfunc
->type
= IPA_JF_ANCESTOR
;
580 jfunc
->value
.ancestor
.formal_id
= index
;
581 jfunc
->value
.ancestor
.offset
= offset
;
582 jfunc
->value
.ancestor
.type
= TREE_TYPE (op1
);
586 /* Extract the base, offset and MEM_REF expression from a statement ASSIGN if
589 iftmp.1_3 = &obj_2(D)->D.1762;
591 The base of the MEM_REF must be a default definition SSA NAME of a
592 parameter. Return NULL_TREE if it looks otherwise. If case of success, the
593 whole MEM_REF expression is returned and the offset calculated from any
594 handled components and the MEM_REF itself is stored into *OFFSET. The whole
595 RHS stripped off the ADDR_EXPR is stored into *OBJ_P. */
598 get_ancestor_addr_info (gimple assign
, tree
*obj_p
, HOST_WIDE_INT
*offset
)
600 HOST_WIDE_INT size
, max_size
;
601 tree expr
, parm
, obj
;
603 if (!gimple_assign_single_p (assign
))
605 expr
= gimple_assign_rhs1 (assign
);
607 if (TREE_CODE (expr
) != ADDR_EXPR
)
609 expr
= TREE_OPERAND (expr
, 0);
611 expr
= get_ref_base_and_extent (expr
, offset
, &size
, &max_size
);
613 if (TREE_CODE (expr
) != MEM_REF
614 /* If this is a varying address, punt. */
619 parm
= TREE_OPERAND (expr
, 0);
620 if (TREE_CODE (parm
) != SSA_NAME
621 || !SSA_NAME_IS_DEFAULT_DEF (parm
)
622 || TREE_CODE (SSA_NAME_VAR (parm
)) != PARM_DECL
)
625 *offset
+= mem_ref_offset (expr
).low
* BITS_PER_UNIT
;
631 /* Given that an actual argument is an SSA_NAME that is a result of a phi
632 statement PHI, try to find out whether NAME is in fact a
633 multiple-inheritance typecast from a descendant into an ancestor of a formal
634 parameter and thus can be described by an ancestor jump function and if so,
635 write the appropriate function into JFUNC.
637 Essentially we want to match the following pattern:
645 iftmp.1_3 = &obj_2(D)->D.1762;
648 # iftmp.1_1 = PHI <iftmp.1_3(3), 0B(2)>
649 D.1879_6 = middleman_1 (iftmp.1_1, i_5(D));
653 compute_complex_ancestor_jump_func (struct ipa_node_params
*info
,
654 struct ipa_jump_func
*jfunc
,
655 gimple call
, gimple phi
)
657 HOST_WIDE_INT offset
;
659 basic_block phi_bb
, assign_bb
, cond_bb
;
660 tree tmp
, parm
, expr
, obj
;
663 if (gimple_phi_num_args (phi
) != 2)
666 if (integer_zerop (PHI_ARG_DEF (phi
, 1)))
667 tmp
= PHI_ARG_DEF (phi
, 0);
668 else if (integer_zerop (PHI_ARG_DEF (phi
, 0)))
669 tmp
= PHI_ARG_DEF (phi
, 1);
672 if (TREE_CODE (tmp
) != SSA_NAME
673 || SSA_NAME_IS_DEFAULT_DEF (tmp
)
674 || !POINTER_TYPE_P (TREE_TYPE (tmp
))
675 || TREE_CODE (TREE_TYPE (TREE_TYPE (tmp
))) != RECORD_TYPE
)
678 assign
= SSA_NAME_DEF_STMT (tmp
);
679 assign_bb
= gimple_bb (assign
);
680 if (!single_pred_p (assign_bb
))
682 expr
= get_ancestor_addr_info (assign
, &obj
, &offset
);
685 parm
= TREE_OPERAND (expr
, 0);
686 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (parm
));
687 gcc_assert (index
>= 0);
689 cond_bb
= single_pred (assign_bb
);
690 cond
= last_stmt (cond_bb
);
692 || gimple_code (cond
) != GIMPLE_COND
693 || gimple_cond_code (cond
) != NE_EXPR
694 || gimple_cond_lhs (cond
) != parm
695 || !integer_zerop (gimple_cond_rhs (cond
)))
698 phi_bb
= gimple_bb (phi
);
699 for (i
= 0; i
< 2; i
++)
701 basic_block pred
= EDGE_PRED (phi_bb
, i
)->src
;
702 if (pred
!= assign_bb
&& pred
!= cond_bb
)
706 if (!detect_type_change (obj
, expr
, call
, jfunc
, offset
))
708 jfunc
->type
= IPA_JF_ANCESTOR
;
709 jfunc
->value
.ancestor
.formal_id
= index
;
710 jfunc
->value
.ancestor
.offset
= offset
;
711 jfunc
->value
.ancestor
.type
= TREE_TYPE (obj
);
715 /* Given OP which is passed as an actual argument to a called function,
716 determine if it is possible to construct a KNOWN_TYPE jump function for it
717 and if so, create one and store it to JFUNC. */
720 compute_known_type_jump_func (tree op
, struct ipa_jump_func
*jfunc
,
723 HOST_WIDE_INT offset
, size
, max_size
;
726 if (!flag_devirtualize
727 || TREE_CODE (op
) != ADDR_EXPR
728 || TREE_CODE (TREE_TYPE (TREE_TYPE (op
))) != RECORD_TYPE
)
731 op
= TREE_OPERAND (op
, 0);
732 base
= get_ref_base_and_extent (op
, &offset
, &size
, &max_size
);
736 || TREE_CODE (TREE_TYPE (base
)) != RECORD_TYPE
737 || is_global_var (base
))
740 if (detect_type_change (op
, base
, call
, jfunc
, offset
))
743 binfo
= TYPE_BINFO (TREE_TYPE (base
));
746 binfo
= get_binfo_at_offset (binfo
, offset
, TREE_TYPE (op
));
749 jfunc
->type
= IPA_JF_KNOWN_TYPE
;
750 jfunc
->value
.base_binfo
= binfo
;
755 /* Determine the jump functions of scalar arguments. Scalar means SSA names
756 and constants of a number of selected types. INFO is the ipa_node_params
757 structure associated with the caller, FUNCTIONS is a pointer to an array of
758 jump function structures associated with CALL which is the call statement
762 compute_scalar_jump_functions (struct ipa_node_params
*info
,
763 struct ipa_jump_func
*functions
,
769 for (num
= 0; num
< gimple_call_num_args (call
); num
++)
771 arg
= gimple_call_arg (call
, num
);
773 if (is_gimple_ip_invariant (arg
))
775 functions
[num
].type
= IPA_JF_CONST
;
776 functions
[num
].value
.constant
= arg
;
778 else if (TREE_CODE (arg
) == SSA_NAME
)
780 if (SSA_NAME_IS_DEFAULT_DEF (arg
))
782 int index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (arg
));
785 && !detect_type_change_ssa (arg
, call
, &functions
[num
]))
787 functions
[num
].type
= IPA_JF_PASS_THROUGH
;
788 functions
[num
].value
.pass_through
.formal_id
= index
;
789 functions
[num
].value
.pass_through
.operation
= NOP_EXPR
;
794 gimple stmt
= SSA_NAME_DEF_STMT (arg
);
795 if (is_gimple_assign (stmt
))
796 compute_complex_assign_jump_func (info
, &functions
[num
],
798 else if (gimple_code (stmt
) == GIMPLE_PHI
)
799 compute_complex_ancestor_jump_func (info
, &functions
[num
],
804 compute_known_type_jump_func (arg
, &functions
[num
], call
);
808 /* Inspect the given TYPE and return true iff it has the same structure (the
809 same number of fields of the same types) as a C++ member pointer. If
810 METHOD_PTR and DELTA are non-NULL, store the trees representing the
811 corresponding fields there. */
814 type_like_member_ptr_p (tree type
, tree
*method_ptr
, tree
*delta
)
818 if (TREE_CODE (type
) != RECORD_TYPE
)
821 fld
= TYPE_FIELDS (type
);
822 if (!fld
|| !POINTER_TYPE_P (TREE_TYPE (fld
))
823 || TREE_CODE (TREE_TYPE (TREE_TYPE (fld
))) != METHOD_TYPE
)
829 fld
= DECL_CHAIN (fld
);
830 if (!fld
|| INTEGRAL_TYPE_P (fld
))
835 if (DECL_CHAIN (fld
))
841 /* Callback of walk_aliased_vdefs. Flags that it has been invoked to the
842 boolean variable pointed to by DATA. */
845 mark_modified (ao_ref
*ao ATTRIBUTE_UNUSED
, tree vdef ATTRIBUTE_UNUSED
,
848 bool *b
= (bool *) data
;
853 /* Return true if the formal parameter PARM might have been modified in this
854 function before reaching the statement CALL. PARM_INFO is a pointer to a
855 structure containing intermediate information about PARM. */
858 is_parm_modified_before_call (struct param_analysis_info
*parm_info
,
859 gimple call
, tree parm
)
861 bool modified
= false;
864 if (parm_info
->modified
)
867 ao_ref_init (&refd
, parm
);
868 walk_aliased_vdefs (&refd
, gimple_vuse (call
), mark_modified
,
869 &modified
, &parm_info
->visited_statements
);
872 parm_info
->modified
= true;
878 /* Go through arguments of the CALL and for every one that looks like a member
879 pointer, check whether it can be safely declared pass-through and if so,
880 mark that to the corresponding item of jump FUNCTIONS. Return true iff
881 there are non-pass-through member pointers within the arguments. INFO
882 describes formal parameters of the caller. PARMS_INFO is a pointer to a
883 vector containing intermediate information about each formal parameter. */
886 compute_pass_through_member_ptrs (struct ipa_node_params
*info
,
887 struct param_analysis_info
*parms_info
,
888 struct ipa_jump_func
*functions
,
891 bool undecided_members
= false;
895 for (num
= 0; num
< gimple_call_num_args (call
); num
++)
897 arg
= gimple_call_arg (call
, num
);
899 if (type_like_member_ptr_p (TREE_TYPE (arg
), NULL
, NULL
))
901 if (TREE_CODE (arg
) == PARM_DECL
)
903 int index
= ipa_get_param_decl_index (info
, arg
);
905 gcc_assert (index
>=0);
906 if (!is_parm_modified_before_call (&parms_info
[index
], call
, arg
))
908 functions
[num
].type
= IPA_JF_PASS_THROUGH
;
909 functions
[num
].value
.pass_through
.formal_id
= index
;
910 functions
[num
].value
.pass_through
.operation
= NOP_EXPR
;
913 undecided_members
= true;
916 undecided_members
= true;
920 return undecided_members
;
923 /* Simple function filling in a member pointer constant jump function (with PFN
924 and DELTA as the constant value) into JFUNC. */
927 fill_member_ptr_cst_jump_function (struct ipa_jump_func
*jfunc
,
928 tree pfn
, tree delta
)
930 jfunc
->type
= IPA_JF_CONST_MEMBER_PTR
;
931 jfunc
->value
.member_cst
.pfn
= pfn
;
932 jfunc
->value
.member_cst
.delta
= delta
;
935 /* If RHS is an SSA_NAME and it is defined by a simple copy assign statement,
936 return the rhs of its defining statement. */
939 get_ssa_def_if_simple_copy (tree rhs
)
941 while (TREE_CODE (rhs
) == SSA_NAME
&& !SSA_NAME_IS_DEFAULT_DEF (rhs
))
943 gimple def_stmt
= SSA_NAME_DEF_STMT (rhs
);
945 if (gimple_assign_single_p (def_stmt
))
946 rhs
= gimple_assign_rhs1 (def_stmt
);
953 /* Traverse statements from CALL backwards, scanning whether the argument ARG
954 which is a member pointer is filled in with constant values. If it is, fill
955 the jump function JFUNC in appropriately. METHOD_FIELD and DELTA_FIELD are
956 fields of the record type of the member pointer. To give an example, we
957 look for a pattern looking like the following:
959 D.2515.__pfn ={v} printStuff;
960 D.2515.__delta ={v} 0;
961 i_1 = doprinting (D.2515); */
964 determine_cst_member_ptr (gimple call
, tree arg
, tree method_field
,
965 tree delta_field
, struct ipa_jump_func
*jfunc
)
967 gimple_stmt_iterator gsi
;
968 tree method
= NULL_TREE
;
969 tree delta
= NULL_TREE
;
971 gsi
= gsi_for_stmt (call
);
974 for (; !gsi_end_p (gsi
); gsi_prev (&gsi
))
976 gimple stmt
= gsi_stmt (gsi
);
979 if (!stmt_may_clobber_ref_p (stmt
, arg
))
981 if (!gimple_assign_single_p (stmt
))
984 lhs
= gimple_assign_lhs (stmt
);
985 rhs
= gimple_assign_rhs1 (stmt
);
987 if (TREE_CODE (lhs
) != COMPONENT_REF
988 || TREE_OPERAND (lhs
, 0) != arg
)
991 fld
= TREE_OPERAND (lhs
, 1);
992 if (!method
&& fld
== method_field
)
994 rhs
= get_ssa_def_if_simple_copy (rhs
);
995 if (TREE_CODE (rhs
) == ADDR_EXPR
996 && TREE_CODE (TREE_OPERAND (rhs
, 0)) == FUNCTION_DECL
997 && TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs
, 0))) == METHOD_TYPE
)
999 method
= TREE_OPERAND (rhs
, 0);
1002 fill_member_ptr_cst_jump_function (jfunc
, rhs
, delta
);
1010 if (!delta
&& fld
== delta_field
)
1012 rhs
= get_ssa_def_if_simple_copy (rhs
);
1013 if (TREE_CODE (rhs
) == INTEGER_CST
)
1018 fill_member_ptr_cst_jump_function (jfunc
, rhs
, delta
);
1030 /* Go through the arguments of the CALL and for every member pointer within
1031 tries determine whether it is a constant. If it is, create a corresponding
1032 constant jump function in FUNCTIONS which is an array of jump functions
1033 associated with the call. */
1036 compute_cst_member_ptr_arguments (struct ipa_jump_func
*functions
,
1040 tree arg
, method_field
, delta_field
;
1042 for (num
= 0; num
< gimple_call_num_args (call
); num
++)
1044 arg
= gimple_call_arg (call
, num
);
1046 if (functions
[num
].type
== IPA_JF_UNKNOWN
1047 && type_like_member_ptr_p (TREE_TYPE (arg
), &method_field
,
1049 determine_cst_member_ptr (call
, arg
, method_field
, delta_field
,
1054 /* Compute jump function for all arguments of callsite CS and insert the
1055 information in the jump_functions array in the ipa_edge_args corresponding
1056 to this callsite. */
1059 ipa_compute_jump_functions_for_edge (struct param_analysis_info
*parms_info
,
1060 struct cgraph_edge
*cs
)
1062 struct ipa_node_params
*info
= IPA_NODE_REF (cs
->caller
);
1063 struct ipa_edge_args
*arguments
= IPA_EDGE_REF (cs
);
1066 if (ipa_get_cs_argument_count (arguments
) == 0 || arguments
->jump_functions
)
1068 arguments
->jump_functions
= ggc_alloc_cleared_vec_ipa_jump_func
1069 (ipa_get_cs_argument_count (arguments
));
1071 call
= cs
->call_stmt
;
1072 gcc_assert (is_gimple_call (call
));
1074 /* We will deal with constants and SSA scalars first: */
1075 compute_scalar_jump_functions (info
, arguments
->jump_functions
, call
);
1077 /* Let's check whether there are any potential member pointers and if so,
1078 whether we can determine their functions as pass_through. */
1079 if (!compute_pass_through_member_ptrs (info
, parms_info
,
1080 arguments
->jump_functions
, call
))
1083 /* Finally, let's check whether we actually pass a new constant member
1085 compute_cst_member_ptr_arguments (arguments
->jump_functions
, call
);
1088 /* Compute jump functions for all edges - both direct and indirect - outgoing
1089 from NODE. Also count the actual arguments in the process. */
1092 ipa_compute_jump_functions (struct cgraph_node
*node
,
1093 struct param_analysis_info
*parms_info
)
1095 struct cgraph_edge
*cs
;
1097 for (cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
1099 struct cgraph_node
*callee
= cgraph_function_or_thunk_node (cs
->callee
, NULL
);
1100 /* We do not need to bother analyzing calls to unknown
1101 functions unless they may become known during lto/whopr. */
1102 if (!cs
->callee
->analyzed
&& !flag_lto
)
1104 ipa_count_arguments (cs
);
1105 /* If the descriptor of the callee is not initialized yet, we have to do
1107 if (callee
->analyzed
)
1108 ipa_initialize_node_params (callee
);
1109 if (ipa_get_cs_argument_count (IPA_EDGE_REF (cs
))
1110 != ipa_get_param_count (IPA_NODE_REF (callee
)))
1111 ipa_set_called_with_variable_arg (IPA_NODE_REF (callee
));
1112 ipa_compute_jump_functions_for_edge (parms_info
, cs
);
1115 for (cs
= node
->indirect_calls
; cs
; cs
= cs
->next_callee
)
1117 ipa_count_arguments (cs
);
1118 ipa_compute_jump_functions_for_edge (parms_info
, cs
);
1122 /* If RHS looks like a rhs of a statement loading pfn from a member
1123 pointer formal parameter, return the parameter, otherwise return
1124 NULL. If USE_DELTA, then we look for a use of the delta field
1125 rather than the pfn. */
1128 ipa_get_member_ptr_load_param (tree rhs
, bool use_delta
)
1130 tree rec
, ref_field
, ref_offset
, fld
, fld_offset
, ptr_field
, delta_field
;
1132 if (TREE_CODE (rhs
) == COMPONENT_REF
)
1134 ref_field
= TREE_OPERAND (rhs
, 1);
1135 rhs
= TREE_OPERAND (rhs
, 0);
1138 ref_field
= NULL_TREE
;
1139 if (TREE_CODE (rhs
) != MEM_REF
)
1141 rec
= TREE_OPERAND (rhs
, 0);
1142 if (TREE_CODE (rec
) != ADDR_EXPR
)
1144 rec
= TREE_OPERAND (rec
, 0);
1145 if (TREE_CODE (rec
) != PARM_DECL
1146 || !type_like_member_ptr_p (TREE_TYPE (rec
), &ptr_field
, &delta_field
))
1149 ref_offset
= TREE_OPERAND (rhs
, 1);
1153 if (integer_nonzerop (ref_offset
))
1161 return ref_field
== fld
? rec
: NULL_TREE
;
1165 fld_offset
= byte_position (delta_field
);
1167 fld_offset
= byte_position (ptr_field
);
1169 return tree_int_cst_equal (ref_offset
, fld_offset
) ? rec
: NULL_TREE
;
1172 /* If STMT looks like a statement loading a value from a member pointer formal
1173 parameter, this function returns that parameter. */
1176 ipa_get_stmt_member_ptr_load_param (gimple stmt
, bool use_delta
)
1180 if (!gimple_assign_single_p (stmt
))
1183 rhs
= gimple_assign_rhs1 (stmt
);
1184 return ipa_get_member_ptr_load_param (rhs
, use_delta
);
1187 /* Returns true iff T is an SSA_NAME defined by a statement. */
1190 ipa_is_ssa_with_stmt_def (tree t
)
1192 if (TREE_CODE (t
) == SSA_NAME
1193 && !SSA_NAME_IS_DEFAULT_DEF (t
))
1199 /* Find the indirect call graph edge corresponding to STMT and mark it as a
1200 call to a parameter number PARAM_INDEX. NODE is the caller. Return the
1201 indirect call graph edge. */
1203 static struct cgraph_edge
*
1204 ipa_note_param_call (struct cgraph_node
*node
, int param_index
, gimple stmt
)
1206 struct cgraph_edge
*cs
;
1208 cs
= cgraph_edge (node
, stmt
);
1209 cs
->indirect_info
->param_index
= param_index
;
1210 cs
->indirect_info
->anc_offset
= 0;
1211 cs
->indirect_info
->polymorphic
= 0;
1215 /* Analyze the CALL and examine uses of formal parameters of the caller NODE
1216 (described by INFO). PARMS_INFO is a pointer to a vector containing
1217 intermediate information about each formal parameter. Currently it checks
1218 whether the call calls a pointer that is a formal parameter and if so, the
1219 parameter is marked with the called flag and an indirect call graph edge
1220 describing the call is created. This is very simple for ordinary pointers
1221 represented in SSA but not-so-nice when it comes to member pointers. The
1222 ugly part of this function does nothing more than trying to match the
1223 pattern of such a call. An example of such a pattern is the gimple dump
1224 below, the call is on the last line:
1227 f$__delta_5 = f.__delta;
1228 f$__pfn_24 = f.__pfn;
1232 f$__delta_5 = MEM[(struct *)&f];
1233 f$__pfn_24 = MEM[(struct *)&f + 4B];
1235 and a few lines below:
1238 D.2496_3 = (int) f$__pfn_24;
1239 D.2497_4 = D.2496_3 & 1;
1246 D.2500_7 = (unsigned int) f$__delta_5;
1247 D.2501_8 = &S + D.2500_7;
1248 D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8;
1249 D.2503_10 = *D.2502_9;
1250 D.2504_12 = f$__pfn_24 + -1;
1251 D.2505_13 = (unsigned int) D.2504_12;
1252 D.2506_14 = D.2503_10 + D.2505_13;
1253 D.2507_15 = *D.2506_14;
1254 iftmp.11_16 = (String:: *) D.2507_15;
1257 # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)>
1258 D.2500_19 = (unsigned int) f$__delta_5;
1259 D.2508_20 = &S + D.2500_19;
1260 D.2493_21 = iftmp.11_1 (D.2508_20, 4);
1262 Such patterns are results of simple calls to a member pointer:
1264 int doprinting (int (MyString::* f)(int) const)
1266 MyString S ("somestring");
1273 ipa_analyze_indirect_call_uses (struct cgraph_node
*node
,
1274 struct ipa_node_params
*info
,
1275 struct param_analysis_info
*parms_info
,
1276 gimple call
, tree target
)
1281 tree rec
, rec2
, cond
;
1284 basic_block bb
, virt_bb
, join
;
1286 if (SSA_NAME_IS_DEFAULT_DEF (target
))
1288 tree var
= SSA_NAME_VAR (target
);
1289 index
= ipa_get_param_decl_index (info
, var
);
1291 ipa_note_param_call (node
, index
, call
);
1295 /* Now we need to try to match the complex pattern of calling a member
1298 if (!POINTER_TYPE_P (TREE_TYPE (target
))
1299 || TREE_CODE (TREE_TYPE (TREE_TYPE (target
))) != METHOD_TYPE
)
1302 def
= SSA_NAME_DEF_STMT (target
);
1303 if (gimple_code (def
) != GIMPLE_PHI
)
1306 if (gimple_phi_num_args (def
) != 2)
1309 /* First, we need to check whether one of these is a load from a member
1310 pointer that is a parameter to this function. */
1311 n1
= PHI_ARG_DEF (def
, 0);
1312 n2
= PHI_ARG_DEF (def
, 1);
1313 if (!ipa_is_ssa_with_stmt_def (n1
) || !ipa_is_ssa_with_stmt_def (n2
))
1315 d1
= SSA_NAME_DEF_STMT (n1
);
1316 d2
= SSA_NAME_DEF_STMT (n2
);
1318 join
= gimple_bb (def
);
1319 if ((rec
= ipa_get_stmt_member_ptr_load_param (d1
, false)))
1321 if (ipa_get_stmt_member_ptr_load_param (d2
, false))
1324 bb
= EDGE_PRED (join
, 0)->src
;
1325 virt_bb
= gimple_bb (d2
);
1327 else if ((rec
= ipa_get_stmt_member_ptr_load_param (d2
, false)))
1329 bb
= EDGE_PRED (join
, 1)->src
;
1330 virt_bb
= gimple_bb (d1
);
1335 /* Second, we need to check that the basic blocks are laid out in the way
1336 corresponding to the pattern. */
1338 if (!single_pred_p (virt_bb
) || !single_succ_p (virt_bb
)
1339 || single_pred (virt_bb
) != bb
1340 || single_succ (virt_bb
) != join
)
1343 /* Third, let's see that the branching is done depending on the least
1344 significant bit of the pfn. */
1346 branch
= last_stmt (bb
);
1347 if (!branch
|| gimple_code (branch
) != GIMPLE_COND
)
1350 if ((gimple_cond_code (branch
) != NE_EXPR
1351 && gimple_cond_code (branch
) != EQ_EXPR
)
1352 || !integer_zerop (gimple_cond_rhs (branch
)))
1355 cond
= gimple_cond_lhs (branch
);
1356 if (!ipa_is_ssa_with_stmt_def (cond
))
1359 def
= SSA_NAME_DEF_STMT (cond
);
1360 if (!is_gimple_assign (def
)
1361 || gimple_assign_rhs_code (def
) != BIT_AND_EXPR
1362 || !integer_onep (gimple_assign_rhs2 (def
)))
1365 cond
= gimple_assign_rhs1 (def
);
1366 if (!ipa_is_ssa_with_stmt_def (cond
))
1369 def
= SSA_NAME_DEF_STMT (cond
);
1371 if (is_gimple_assign (def
)
1372 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def
)))
1374 cond
= gimple_assign_rhs1 (def
);
1375 if (!ipa_is_ssa_with_stmt_def (cond
))
1377 def
= SSA_NAME_DEF_STMT (cond
);
1380 rec2
= ipa_get_stmt_member_ptr_load_param (def
,
1381 (TARGET_PTRMEMFUNC_VBIT_LOCATION
1382 == ptrmemfunc_vbit_in_delta
));
1387 index
= ipa_get_param_decl_index (info
, rec
);
1388 if (index
>= 0 && !is_parm_modified_before_call (&parms_info
[index
],
1390 ipa_note_param_call (node
, index
, call
);
1395 /* Analyze a CALL to an OBJ_TYPE_REF which is passed in TARGET and if the
1396 object referenced in the expression is a formal parameter of the caller
1397 (described by INFO), create a call note for the statement. */
1400 ipa_analyze_virtual_call_uses (struct cgraph_node
*node
,
1401 struct ipa_node_params
*info
, gimple call
,
1404 struct cgraph_edge
*cs
;
1405 struct cgraph_indirect_call_info
*ii
;
1406 struct ipa_jump_func jfunc
;
1407 tree obj
= OBJ_TYPE_REF_OBJECT (target
);
1409 HOST_WIDE_INT anc_offset
;
1411 if (!flag_devirtualize
)
1414 if (TREE_CODE (obj
) != SSA_NAME
)
1417 if (SSA_NAME_IS_DEFAULT_DEF (obj
))
1419 if (TREE_CODE (SSA_NAME_VAR (obj
)) != PARM_DECL
)
1423 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (obj
));
1424 gcc_assert (index
>= 0);
1425 if (detect_type_change_ssa (obj
, call
, &jfunc
))
1430 gimple stmt
= SSA_NAME_DEF_STMT (obj
);
1433 expr
= get_ancestor_addr_info (stmt
, &obj
, &anc_offset
);
1436 index
= ipa_get_param_decl_index (info
,
1437 SSA_NAME_VAR (TREE_OPERAND (expr
, 0)));
1438 gcc_assert (index
>= 0);
1439 if (detect_type_change (obj
, expr
, call
, &jfunc
, anc_offset
))
1443 cs
= ipa_note_param_call (node
, index
, call
);
1444 ii
= cs
->indirect_info
;
1445 ii
->anc_offset
= anc_offset
;
1446 ii
->otr_token
= tree_low_cst (OBJ_TYPE_REF_TOKEN (target
), 1);
1447 ii
->otr_type
= TREE_TYPE (TREE_TYPE (OBJ_TYPE_REF_OBJECT (target
)));
1448 ii
->polymorphic
= 1;
1451 /* Analyze a call statement CALL whether and how it utilizes formal parameters
1452 of the caller (described by INFO). PARMS_INFO is a pointer to a vector
1453 containing intermediate information about each formal parameter. */
1456 ipa_analyze_call_uses (struct cgraph_node
*node
,
1457 struct ipa_node_params
*info
,
1458 struct param_analysis_info
*parms_info
, gimple call
)
1460 tree target
= gimple_call_fn (call
);
1464 if (TREE_CODE (target
) == SSA_NAME
)
1465 ipa_analyze_indirect_call_uses (node
, info
, parms_info
, call
, target
);
1466 else if (TREE_CODE (target
) == OBJ_TYPE_REF
)
1467 ipa_analyze_virtual_call_uses (node
, info
, call
, target
);
1471 /* Analyze the call statement STMT with respect to formal parameters (described
1472 in INFO) of caller given by NODE. Currently it only checks whether formal
1473 parameters are called. PARMS_INFO is a pointer to a vector containing
1474 intermediate information about each formal parameter. */
1477 ipa_analyze_stmt_uses (struct cgraph_node
*node
, struct ipa_node_params
*info
,
1478 struct param_analysis_info
*parms_info
, gimple stmt
)
1480 if (is_gimple_call (stmt
))
1481 ipa_analyze_call_uses (node
, info
, parms_info
, stmt
);
1484 /* Callback of walk_stmt_load_store_addr_ops for the visit_load.
1485 If OP is a parameter declaration, mark it as used in the info structure
1489 visit_ref_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED
,
1490 tree op
, void *data
)
1492 struct ipa_node_params
*info
= (struct ipa_node_params
*) data
;
1494 op
= get_base_address (op
);
1496 && TREE_CODE (op
) == PARM_DECL
)
1498 int index
= ipa_get_param_decl_index (info
, op
);
1499 gcc_assert (index
>= 0);
1500 info
->params
[index
].used
= true;
1506 /* Scan the function body of NODE and inspect the uses of formal parameters.
1507 Store the findings in various structures of the associated ipa_node_params
1508 structure, such as parameter flags, notes etc. PARMS_INFO is a pointer to a
1509 vector containing intermediate information about each formal parameter. */
1512 ipa_analyze_params_uses (struct cgraph_node
*node
,
1513 struct param_analysis_info
*parms_info
)
1515 tree decl
= node
->decl
;
1517 struct function
*func
;
1518 gimple_stmt_iterator gsi
;
1519 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
1522 if (ipa_get_param_count (info
) == 0 || info
->uses_analysis_done
)
1525 for (i
= 0; i
< ipa_get_param_count (info
); i
++)
1527 tree parm
= ipa_get_param (info
, i
);
1528 /* For SSA regs see if parameter is used. For non-SSA we compute
1529 the flag during modification analysis. */
1530 if (is_gimple_reg (parm
)
1531 && gimple_default_def (DECL_STRUCT_FUNCTION (node
->decl
), parm
))
1532 info
->params
[i
].used
= true;
1535 func
= DECL_STRUCT_FUNCTION (decl
);
1536 FOR_EACH_BB_FN (bb
, func
)
1538 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1540 gimple stmt
= gsi_stmt (gsi
);
1542 if (is_gimple_debug (stmt
))
1545 ipa_analyze_stmt_uses (node
, info
, parms_info
, stmt
);
1546 walk_stmt_load_store_addr_ops (stmt
, info
,
1547 visit_ref_for_mod_analysis
,
1548 visit_ref_for_mod_analysis
,
1549 visit_ref_for_mod_analysis
);
1551 for (gsi
= gsi_start (phi_nodes (bb
)); !gsi_end_p (gsi
); gsi_next (&gsi
))
1552 walk_stmt_load_store_addr_ops (gsi_stmt (gsi
), info
,
1553 visit_ref_for_mod_analysis
,
1554 visit_ref_for_mod_analysis
,
1555 visit_ref_for_mod_analysis
);
1558 info
->uses_analysis_done
= 1;
1561 /* Initialize the array describing properties of of formal parameters
1562 of NODE, analyze their uses and compute jump functions associated
1563 with actual arguments of calls from within NODE. */
1566 ipa_analyze_node (struct cgraph_node
*node
)
1568 struct ipa_node_params
*info
;
1569 struct param_analysis_info
*parms_info
;
1572 ipa_check_create_node_params ();
1573 ipa_check_create_edge_args ();
1574 info
= IPA_NODE_REF (node
);
1575 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
1576 current_function_decl
= node
->decl
;
1577 ipa_initialize_node_params (node
);
1579 param_count
= ipa_get_param_count (info
);
1580 parms_info
= XALLOCAVEC (struct param_analysis_info
, param_count
);
1581 memset (parms_info
, 0, sizeof (struct param_analysis_info
) * param_count
);
1583 ipa_analyze_params_uses (node
, parms_info
);
1584 ipa_compute_jump_functions (node
, parms_info
);
1586 for (i
= 0; i
< param_count
; i
++)
1587 if (parms_info
[i
].visited_statements
)
1588 BITMAP_FREE (parms_info
[i
].visited_statements
);
1590 current_function_decl
= NULL
;
1595 /* Update the jump function DST when the call graph edge corresponding to SRC is
1596 is being inlined, knowing that DST is of type ancestor and src of known
1600 combine_known_type_and_ancestor_jfs (struct ipa_jump_func
*src
,
1601 struct ipa_jump_func
*dst
)
1605 new_binfo
= get_binfo_at_offset (src
->value
.base_binfo
,
1606 dst
->value
.ancestor
.offset
,
1607 dst
->value
.ancestor
.type
);
1610 dst
->type
= IPA_JF_KNOWN_TYPE
;
1611 dst
->value
.base_binfo
= new_binfo
;
1614 dst
->type
= IPA_JF_UNKNOWN
;
1617 /* Update the jump functions associated with call graph edge E when the call
1618 graph edge CS is being inlined, assuming that E->caller is already (possibly
1619 indirectly) inlined into CS->callee and that E has not been inlined. */
1622 update_jump_functions_after_inlining (struct cgraph_edge
*cs
,
1623 struct cgraph_edge
*e
)
1625 struct ipa_edge_args
*top
= IPA_EDGE_REF (cs
);
1626 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
1627 int count
= ipa_get_cs_argument_count (args
);
1630 for (i
= 0; i
< count
; i
++)
1632 struct ipa_jump_func
*dst
= ipa_get_ith_jump_func (args
, i
);
1634 if (dst
->type
== IPA_JF_ANCESTOR
)
1636 struct ipa_jump_func
*src
;
1638 /* Variable number of arguments can cause havoc if we try to access
1639 one that does not exist in the inlined edge. So make sure we
1641 if (dst
->value
.ancestor
.formal_id
>= ipa_get_cs_argument_count (top
))
1643 dst
->type
= IPA_JF_UNKNOWN
;
1647 src
= ipa_get_ith_jump_func (top
, dst
->value
.ancestor
.formal_id
);
1648 if (src
->type
== IPA_JF_KNOWN_TYPE
)
1649 combine_known_type_and_ancestor_jfs (src
, dst
);
1650 else if (src
->type
== IPA_JF_PASS_THROUGH
1651 && src
->value
.pass_through
.operation
== NOP_EXPR
)
1652 dst
->value
.ancestor
.formal_id
= src
->value
.pass_through
.formal_id
;
1653 else if (src
->type
== IPA_JF_ANCESTOR
)
1655 dst
->value
.ancestor
.formal_id
= src
->value
.ancestor
.formal_id
;
1656 dst
->value
.ancestor
.offset
+= src
->value
.ancestor
.offset
;
1659 dst
->type
= IPA_JF_UNKNOWN
;
1661 else if (dst
->type
== IPA_JF_PASS_THROUGH
)
1663 struct ipa_jump_func
*src
;
1664 /* We must check range due to calls with variable number of arguments
1665 and we cannot combine jump functions with operations. */
1666 if (dst
->value
.pass_through
.operation
== NOP_EXPR
1667 && (dst
->value
.pass_through
.formal_id
1668 < ipa_get_cs_argument_count (top
)))
1670 src
= ipa_get_ith_jump_func (top
,
1671 dst
->value
.pass_through
.formal_id
);
1675 dst
->type
= IPA_JF_UNKNOWN
;
1680 /* If TARGET is an addr_expr of a function declaration, make it the destination
1681 of an indirect edge IE and return the edge. Otherwise, return NULL. Delta,
1682 if non-NULL, is an integer constant that must be added to this pointer
1683 (first parameter). */
1685 struct cgraph_edge
*
1686 ipa_make_edge_direct_to_target (struct cgraph_edge
*ie
, tree target
, tree delta
)
1688 struct cgraph_node
*callee
;
1690 if (TREE_CODE (target
) == ADDR_EXPR
)
1691 target
= TREE_OPERAND (target
, 0);
1692 if (TREE_CODE (target
) != FUNCTION_DECL
)
1694 callee
= cgraph_get_node (target
);
1697 ipa_check_create_node_params ();
1699 /* We can not make edges to inline clones. It is bug that someone removed the cgraph
1701 gcc_assert (!callee
->global
.inlined_to
);
1703 cgraph_make_edge_direct (ie
, callee
, delta
? tree_low_cst (delta
, 0) : 0);
1706 fprintf (dump_file
, "ipa-prop: Discovered %s call to a known target "
1707 "(%s/%i -> %s/%i), for stmt ",
1708 ie
->indirect_info
->polymorphic
? "a virtual" : "an indirect",
1709 cgraph_node_name (ie
->caller
), ie
->caller
->uid
,
1710 cgraph_node_name (ie
->callee
), ie
->callee
->uid
);
1712 print_gimple_stmt (dump_file
, ie
->call_stmt
, 2, TDF_SLIM
);
1714 fprintf (dump_file
, "with uid %i\n", ie
->lto_stmt_uid
);
1718 fprintf (dump_file
, " Thunk delta is ");
1719 print_generic_expr (dump_file
, delta
, 0);
1720 fprintf (dump_file
, "\n");
1723 callee
= cgraph_function_or_thunk_node (callee
, NULL
);
1725 if (ipa_get_cs_argument_count (IPA_EDGE_REF (ie
))
1726 != ipa_get_param_count (IPA_NODE_REF (callee
)))
1727 ipa_set_called_with_variable_arg (IPA_NODE_REF (callee
));
1732 /* Try to find a destination for indirect edge IE that corresponds to a simple
1733 call or a call of a member function pointer and where the destination is a
1734 pointer formal parameter described by jump function JFUNC. If it can be
1735 determined, return the newly direct edge, otherwise return NULL. */
1737 static struct cgraph_edge
*
1738 try_make_edge_direct_simple_call (struct cgraph_edge
*ie
,
1739 struct ipa_jump_func
*jfunc
)
1743 if (jfunc
->type
== IPA_JF_CONST
)
1744 target
= jfunc
->value
.constant
;
1745 else if (jfunc
->type
== IPA_JF_CONST_MEMBER_PTR
)
1746 target
= jfunc
->value
.member_cst
.pfn
;
1750 return ipa_make_edge_direct_to_target (ie
, target
, NULL_TREE
);
1753 /* Try to find a destination for indirect edge IE that corresponds to a
1754 virtual call based on a formal parameter which is described by jump
1755 function JFUNC and if it can be determined, make it direct and return the
1756 direct edge. Otherwise, return NULL. */
1758 static struct cgraph_edge
*
1759 try_make_edge_direct_virtual_call (struct cgraph_edge
*ie
,
1760 struct ipa_jump_func
*jfunc
)
1762 tree binfo
, type
, target
, delta
;
1763 HOST_WIDE_INT token
;
1765 if (jfunc
->type
== IPA_JF_KNOWN_TYPE
)
1766 binfo
= jfunc
->value
.base_binfo
;
1773 token
= ie
->indirect_info
->otr_token
;
1774 type
= ie
->indirect_info
->otr_type
;
1775 binfo
= get_binfo_at_offset (binfo
, ie
->indirect_info
->anc_offset
, type
);
1777 target
= gimple_get_virt_method_for_binfo (token
, binfo
, &delta
);
1782 return ipa_make_edge_direct_to_target (ie
, target
, delta
);
1787 /* Update the param called notes associated with NODE when CS is being inlined,
1788 assuming NODE is (potentially indirectly) inlined into CS->callee.
1789 Moreover, if the callee is discovered to be constant, create a new cgraph
1790 edge for it. Newly discovered indirect edges will be added to *NEW_EDGES,
1791 unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
1794 update_indirect_edges_after_inlining (struct cgraph_edge
*cs
,
1795 struct cgraph_node
*node
,
1796 VEC (cgraph_edge_p
, heap
) **new_edges
)
1798 struct ipa_edge_args
*top
;
1799 struct cgraph_edge
*ie
, *next_ie
, *new_direct_edge
;
1802 ipa_check_create_edge_args ();
1803 top
= IPA_EDGE_REF (cs
);
1805 for (ie
= node
->indirect_calls
; ie
; ie
= next_ie
)
1807 struct cgraph_indirect_call_info
*ici
= ie
->indirect_info
;
1808 struct ipa_jump_func
*jfunc
;
1810 next_ie
= ie
->next_callee
;
1811 if (bitmap_bit_p (iinlining_processed_edges
, ie
->uid
))
1814 /* If we ever use indirect edges for anything other than indirect
1815 inlining, we will need to skip those with negative param_indices. */
1816 if (ici
->param_index
== -1)
1819 /* We must check range due to calls with variable number of arguments: */
1820 if (ici
->param_index
>= ipa_get_cs_argument_count (top
))
1822 bitmap_set_bit (iinlining_processed_edges
, ie
->uid
);
1826 jfunc
= ipa_get_ith_jump_func (top
, ici
->param_index
);
1827 if (jfunc
->type
== IPA_JF_PASS_THROUGH
1828 && jfunc
->value
.pass_through
.operation
== NOP_EXPR
)
1829 ici
->param_index
= jfunc
->value
.pass_through
.formal_id
;
1830 else if (jfunc
->type
== IPA_JF_ANCESTOR
)
1832 ici
->param_index
= jfunc
->value
.ancestor
.formal_id
;
1833 ici
->anc_offset
+= jfunc
->value
.ancestor
.offset
;
1836 /* Either we can find a destination for this edge now or never. */
1837 bitmap_set_bit (iinlining_processed_edges
, ie
->uid
);
1839 if (ici
->polymorphic
)
1840 new_direct_edge
= try_make_edge_direct_virtual_call (ie
, jfunc
);
1842 new_direct_edge
= try_make_edge_direct_simple_call (ie
, jfunc
);
1844 if (new_direct_edge
)
1846 new_direct_edge
->indirect_inlining_edge
= 1;
1849 VEC_safe_push (cgraph_edge_p
, heap
, *new_edges
,
1851 top
= IPA_EDGE_REF (cs
);
1860 /* Recursively traverse subtree of NODE (including node) made of inlined
1861 cgraph_edges when CS has been inlined and invoke
1862 update_indirect_edges_after_inlining on all nodes and
1863 update_jump_functions_after_inlining on all non-inlined edges that lead out
1864 of this subtree. Newly discovered indirect edges will be added to
1865 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were
1869 propagate_info_to_inlined_callees (struct cgraph_edge
*cs
,
1870 struct cgraph_node
*node
,
1871 VEC (cgraph_edge_p
, heap
) **new_edges
)
1873 struct cgraph_edge
*e
;
1876 res
= update_indirect_edges_after_inlining (cs
, node
, new_edges
);
1878 for (e
= node
->callees
; e
; e
= e
->next_callee
)
1879 if (!e
->inline_failed
)
1880 res
|= propagate_info_to_inlined_callees (cs
, e
->callee
, new_edges
);
1882 update_jump_functions_after_inlining (cs
, e
);
1887 /* Update jump functions and call note functions on inlining the call site CS.
1888 CS is expected to lead to a node already cloned by
1889 cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to
1890 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were +
1894 ipa_propagate_indirect_call_infos (struct cgraph_edge
*cs
,
1895 VEC (cgraph_edge_p
, heap
) **new_edges
)
1897 /* Do nothing if the preparation phase has not been carried out yet
1898 (i.e. during early inlining). */
1899 if (!ipa_node_params_vector
)
1901 gcc_assert (ipa_edge_args_vector
);
1903 return propagate_info_to_inlined_callees (cs
, cs
->callee
, new_edges
);
1906 /* Frees all dynamically allocated structures that the argument info points
1910 ipa_free_edge_args_substructures (struct ipa_edge_args
*args
)
1912 if (args
->jump_functions
)
1913 ggc_free (args
->jump_functions
);
1915 memset (args
, 0, sizeof (*args
));
1918 /* Free all ipa_edge structures. */
1921 ipa_free_all_edge_args (void)
1924 struct ipa_edge_args
*args
;
1926 FOR_EACH_VEC_ELT (ipa_edge_args_t
, ipa_edge_args_vector
, i
, args
)
1927 ipa_free_edge_args_substructures (args
);
1929 VEC_free (ipa_edge_args_t
, gc
, ipa_edge_args_vector
);
1930 ipa_edge_args_vector
= NULL
;
1933 /* Frees all dynamically allocated structures that the param info points
1937 ipa_free_node_params_substructures (struct ipa_node_params
*info
)
1939 free (info
->params
);
1941 memset (info
, 0, sizeof (*info
));
1944 /* Free all ipa_node_params structures. */
1947 ipa_free_all_node_params (void)
1950 struct ipa_node_params
*info
;
1952 FOR_EACH_VEC_ELT (ipa_node_params_t
, ipa_node_params_vector
, i
, info
)
1953 ipa_free_node_params_substructures (info
);
1955 VEC_free (ipa_node_params_t
, heap
, ipa_node_params_vector
);
1956 ipa_node_params_vector
= NULL
;
1959 /* Hook that is called by cgraph.c when an edge is removed. */
1962 ipa_edge_removal_hook (struct cgraph_edge
*cs
, void *data ATTRIBUTE_UNUSED
)
1964 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1965 if (VEC_length (ipa_edge_args_t
, ipa_edge_args_vector
)
1966 <= (unsigned)cs
->uid
)
1968 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs
));
1971 /* Hook that is called by cgraph.c when a node is removed. */
1974 ipa_node_removal_hook (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
1976 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1977 if (VEC_length (ipa_node_params_t
, ipa_node_params_vector
)
1978 <= (unsigned)node
->uid
)
1980 ipa_free_node_params_substructures (IPA_NODE_REF (node
));
1983 /* Helper function to duplicate an array of size N that is at SRC and store a
1984 pointer to it to DST. Nothing is done if SRC is NULL. */
1987 duplicate_array (void *src
, size_t n
)
1999 static struct ipa_jump_func
*
2000 duplicate_ipa_jump_func_array (const struct ipa_jump_func
* src
, size_t n
)
2002 struct ipa_jump_func
*p
;
2007 p
= ggc_alloc_vec_ipa_jump_func (n
);
2008 memcpy (p
, src
, n
* sizeof (struct ipa_jump_func
));
2012 /* Hook that is called by cgraph.c when a node is duplicated. */
2015 ipa_edge_duplication_hook (struct cgraph_edge
*src
, struct cgraph_edge
*dst
,
2016 __attribute__((unused
)) void *data
)
2018 struct ipa_edge_args
*old_args
, *new_args
;
2021 ipa_check_create_edge_args ();
2023 old_args
= IPA_EDGE_REF (src
);
2024 new_args
= IPA_EDGE_REF (dst
);
2026 arg_count
= ipa_get_cs_argument_count (old_args
);
2027 ipa_set_cs_argument_count (new_args
, arg_count
);
2028 new_args
->jump_functions
=
2029 duplicate_ipa_jump_func_array (old_args
->jump_functions
, arg_count
);
2031 if (iinlining_processed_edges
2032 && bitmap_bit_p (iinlining_processed_edges
, src
->uid
))
2033 bitmap_set_bit (iinlining_processed_edges
, dst
->uid
);
2036 /* Hook that is called by cgraph.c when a node is duplicated. */
2039 ipa_node_duplication_hook (struct cgraph_node
*src
, struct cgraph_node
*dst
,
2040 ATTRIBUTE_UNUSED
void *data
)
2042 struct ipa_node_params
*old_info
, *new_info
;
2045 ipa_check_create_node_params ();
2046 old_info
= IPA_NODE_REF (src
);
2047 new_info
= IPA_NODE_REF (dst
);
2048 param_count
= ipa_get_param_count (old_info
);
2050 ipa_set_param_count (new_info
, param_count
);
2051 new_info
->params
= (struct ipa_param_descriptor
*)
2052 duplicate_array (old_info
->params
,
2053 sizeof (struct ipa_param_descriptor
) * param_count
);
2054 for (i
= 0; i
< param_count
; i
++)
2055 new_info
->params
[i
].types
= VEC_copy (tree
, heap
,
2056 old_info
->params
[i
].types
);
2057 new_info
->ipcp_orig_node
= old_info
->ipcp_orig_node
;
2058 new_info
->count_scale
= old_info
->count_scale
;
2060 new_info
->called_with_var_arguments
= old_info
->called_with_var_arguments
;
2061 new_info
->uses_analysis_done
= old_info
->uses_analysis_done
;
2062 new_info
->node_enqueued
= old_info
->node_enqueued
;
2066 /* Analyze newly added function into callgraph. */
2069 ipa_add_new_function (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
2071 ipa_analyze_node (node
);
2074 /* Register our cgraph hooks if they are not already there. */
2077 ipa_register_cgraph_hooks (void)
2079 if (!edge_removal_hook_holder
)
2080 edge_removal_hook_holder
=
2081 cgraph_add_edge_removal_hook (&ipa_edge_removal_hook
, NULL
);
2082 if (!node_removal_hook_holder
)
2083 node_removal_hook_holder
=
2084 cgraph_add_node_removal_hook (&ipa_node_removal_hook
, NULL
);
2085 if (!edge_duplication_hook_holder
)
2086 edge_duplication_hook_holder
=
2087 cgraph_add_edge_duplication_hook (&ipa_edge_duplication_hook
, NULL
);
2088 if (!node_duplication_hook_holder
)
2089 node_duplication_hook_holder
=
2090 cgraph_add_node_duplication_hook (&ipa_node_duplication_hook
, NULL
);
2091 function_insertion_hook_holder
=
2092 cgraph_add_function_insertion_hook (&ipa_add_new_function
, NULL
);
2095 /* Unregister our cgraph hooks if they are not already there. */
2098 ipa_unregister_cgraph_hooks (void)
2100 cgraph_remove_edge_removal_hook (edge_removal_hook_holder
);
2101 edge_removal_hook_holder
= NULL
;
2102 cgraph_remove_node_removal_hook (node_removal_hook_holder
);
2103 node_removal_hook_holder
= NULL
;
2104 cgraph_remove_edge_duplication_hook (edge_duplication_hook_holder
);
2105 edge_duplication_hook_holder
= NULL
;
2106 cgraph_remove_node_duplication_hook (node_duplication_hook_holder
);
2107 node_duplication_hook_holder
= NULL
;
2108 cgraph_remove_function_insertion_hook (function_insertion_hook_holder
);
2109 function_insertion_hook_holder
= NULL
;
2112 /* Allocate all necessary data structures necessary for indirect inlining. */
2115 ipa_create_all_structures_for_iinln (void)
2117 iinlining_processed_edges
= BITMAP_ALLOC (NULL
);
2120 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
2121 longer needed after ipa-cp. */
2124 ipa_free_all_structures_after_ipa_cp (void)
2126 if (!flag_indirect_inlining
)
2128 ipa_free_all_edge_args ();
2129 ipa_free_all_node_params ();
2130 ipa_unregister_cgraph_hooks ();
2134 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
2135 longer needed after indirect inlining. */
2138 ipa_free_all_structures_after_iinln (void)
2140 BITMAP_FREE (iinlining_processed_edges
);
2142 ipa_free_all_edge_args ();
2143 ipa_free_all_node_params ();
2144 ipa_unregister_cgraph_hooks ();
2147 /* Print ipa_tree_map data structures of all functions in the
2151 ipa_print_node_params (FILE * f
, struct cgraph_node
*node
)
2155 struct ipa_node_params
*info
;
2157 if (!node
->analyzed
)
2159 info
= IPA_NODE_REF (node
);
2160 fprintf (f
, " function %s parameter descriptors:\n",
2161 cgraph_node_name (node
));
2162 count
= ipa_get_param_count (info
);
2163 for (i
= 0; i
< count
; i
++)
2165 temp
= ipa_get_param (info
, i
);
2166 if (TREE_CODE (temp
) == PARM_DECL
)
2167 fprintf (f
, " param %d : %s", i
,
2169 ? (*lang_hooks
.decl_printable_name
) (temp
, 2)
2171 if (ipa_is_param_used (info
, i
))
2172 fprintf (f
, " used");
2177 /* Print ipa_tree_map data structures of all functions in the
2181 ipa_print_all_params (FILE * f
)
2183 struct cgraph_node
*node
;
2185 fprintf (f
, "\nFunction parameters:\n");
2186 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2187 ipa_print_node_params (f
, node
);
2190 /* Return a heap allocated vector containing formal parameters of FNDECL. */
2193 ipa_get_vector_of_formal_parms (tree fndecl
)
2195 VEC(tree
, heap
) *args
;
2199 count
= count_formal_params_1 (fndecl
);
2200 args
= VEC_alloc (tree
, heap
, count
);
2201 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
2202 VEC_quick_push (tree
, args
, parm
);
2207 /* Return a heap allocated vector containing types of formal parameters of
2208 function type FNTYPE. */
2210 static inline VEC(tree
, heap
) *
2211 get_vector_of_formal_parm_types (tree fntype
)
2213 VEC(tree
, heap
) *types
;
2217 for (t
= TYPE_ARG_TYPES (fntype
); t
; t
= TREE_CHAIN (t
))
2220 types
= VEC_alloc (tree
, heap
, count
);
2221 for (t
= TYPE_ARG_TYPES (fntype
); t
; t
= TREE_CHAIN (t
))
2222 VEC_quick_push (tree
, types
, TREE_VALUE (t
));
2227 /* Modify the function declaration FNDECL and its type according to the plan in
2228 ADJUSTMENTS. It also sets base fields of individual adjustments structures
2229 to reflect the actual parameters being modified which are determined by the
2230 base_index field. */
2233 ipa_modify_formal_parameters (tree fndecl
, ipa_parm_adjustment_vec adjustments
,
2234 const char *synth_parm_prefix
)
2236 VEC(tree
, heap
) *oparms
, *otypes
;
2237 tree orig_type
, new_type
= NULL
;
2238 tree old_arg_types
, t
, new_arg_types
= NULL
;
2239 tree parm
, *link
= &DECL_ARGUMENTS (fndecl
);
2240 int i
, len
= VEC_length (ipa_parm_adjustment_t
, adjustments
);
2241 tree new_reversed
= NULL
;
2242 bool care_for_types
, last_parm_void
;
2244 if (!synth_parm_prefix
)
2245 synth_parm_prefix
= "SYNTH";
2247 oparms
= ipa_get_vector_of_formal_parms (fndecl
);
2248 orig_type
= TREE_TYPE (fndecl
);
2249 old_arg_types
= TYPE_ARG_TYPES (orig_type
);
2251 /* The following test is an ugly hack, some functions simply don't have any
2252 arguments in their type. This is probably a bug but well... */
2253 care_for_types
= (old_arg_types
!= NULL_TREE
);
2256 last_parm_void
= (TREE_VALUE (tree_last (old_arg_types
))
2258 otypes
= get_vector_of_formal_parm_types (orig_type
);
2260 gcc_assert (VEC_length (tree
, oparms
) + 1 == VEC_length (tree
, otypes
));
2262 gcc_assert (VEC_length (tree
, oparms
) == VEC_length (tree
, otypes
));
2266 last_parm_void
= false;
2270 for (i
= 0; i
< len
; i
++)
2272 struct ipa_parm_adjustment
*adj
;
2275 adj
= VEC_index (ipa_parm_adjustment_t
, adjustments
, i
);
2276 parm
= VEC_index (tree
, oparms
, adj
->base_index
);
2279 if (adj
->copy_param
)
2282 new_arg_types
= tree_cons (NULL_TREE
, VEC_index (tree
, otypes
,
2286 link
= &DECL_CHAIN (parm
);
2288 else if (!adj
->remove_param
)
2294 ptype
= build_pointer_type (adj
->type
);
2299 new_arg_types
= tree_cons (NULL_TREE
, ptype
, new_arg_types
);
2301 new_parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
, NULL_TREE
,
2303 DECL_NAME (new_parm
) = create_tmp_var_name (synth_parm_prefix
);
2305 DECL_ARTIFICIAL (new_parm
) = 1;
2306 DECL_ARG_TYPE (new_parm
) = ptype
;
2307 DECL_CONTEXT (new_parm
) = fndecl
;
2308 TREE_USED (new_parm
) = 1;
2309 DECL_IGNORED_P (new_parm
) = 1;
2310 layout_decl (new_parm
, 0);
2312 add_referenced_var (new_parm
);
2313 mark_sym_for_renaming (new_parm
);
2315 adj
->reduction
= new_parm
;
2319 link
= &DECL_CHAIN (new_parm
);
2327 new_reversed
= nreverse (new_arg_types
);
2331 TREE_CHAIN (new_arg_types
) = void_list_node
;
2333 new_reversed
= void_list_node
;
2337 /* Use copy_node to preserve as much as possible from original type
2338 (debug info, attribute lists etc.)
2339 Exception is METHOD_TYPEs must have THIS argument.
2340 When we are asked to remove it, we need to build new FUNCTION_TYPE
2342 if (TREE_CODE (orig_type
) != METHOD_TYPE
2343 || (VEC_index (ipa_parm_adjustment_t
, adjustments
, 0)->copy_param
2344 && VEC_index (ipa_parm_adjustment_t
, adjustments
, 0)->base_index
== 0))
2346 new_type
= build_distinct_type_copy (orig_type
);
2347 TYPE_ARG_TYPES (new_type
) = new_reversed
;
2352 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type
),
2354 TYPE_CONTEXT (new_type
) = TYPE_CONTEXT (orig_type
);
2355 DECL_VINDEX (fndecl
) = NULL_TREE
;
2358 /* When signature changes, we need to clear builtin info. */
2359 if (DECL_BUILT_IN (fndecl
))
2361 DECL_BUILT_IN_CLASS (fndecl
) = NOT_BUILT_IN
;
2362 DECL_FUNCTION_CODE (fndecl
) = (enum built_in_function
) 0;
2365 /* This is a new type, not a copy of an old type. Need to reassociate
2366 variants. We can handle everything except the main variant lazily. */
2367 t
= TYPE_MAIN_VARIANT (orig_type
);
2370 TYPE_MAIN_VARIANT (new_type
) = t
;
2371 TYPE_NEXT_VARIANT (new_type
) = TYPE_NEXT_VARIANT (t
);
2372 TYPE_NEXT_VARIANT (t
) = new_type
;
2376 TYPE_MAIN_VARIANT (new_type
) = new_type
;
2377 TYPE_NEXT_VARIANT (new_type
) = NULL
;
2380 TREE_TYPE (fndecl
) = new_type
;
2381 DECL_VIRTUAL_P (fndecl
) = 0;
2383 VEC_free (tree
, heap
, otypes
);
2384 VEC_free (tree
, heap
, oparms
);
2387 /* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS.
2388 If this is a directly recursive call, CS must be NULL. Otherwise it must
2389 contain the corresponding call graph edge. */
2392 ipa_modify_call_arguments (struct cgraph_edge
*cs
, gimple stmt
,
2393 ipa_parm_adjustment_vec adjustments
)
2395 VEC(tree
, heap
) *vargs
;
2397 gimple_stmt_iterator gsi
;
2401 len
= VEC_length (ipa_parm_adjustment_t
, adjustments
);
2402 vargs
= VEC_alloc (tree
, heap
, len
);
2404 gsi
= gsi_for_stmt (stmt
);
2405 for (i
= 0; i
< len
; i
++)
2407 struct ipa_parm_adjustment
*adj
;
2409 adj
= VEC_index (ipa_parm_adjustment_t
, adjustments
, i
);
2411 if (adj
->copy_param
)
2413 tree arg
= gimple_call_arg (stmt
, adj
->base_index
);
2415 VEC_quick_push (tree
, vargs
, arg
);
2417 else if (!adj
->remove_param
)
2419 tree expr
, base
, off
;
2422 /* We create a new parameter out of the value of the old one, we can
2423 do the following kind of transformations:
2425 - A scalar passed by reference is converted to a scalar passed by
2426 value. (adj->by_ref is false and the type of the original
2427 actual argument is a pointer to a scalar).
2429 - A part of an aggregate is passed instead of the whole aggregate.
2430 The part can be passed either by value or by reference, this is
2431 determined by value of adj->by_ref. Moreover, the code below
2432 handles both situations when the original aggregate is passed by
2433 value (its type is not a pointer) and when it is passed by
2434 reference (it is a pointer to an aggregate).
2436 When the new argument is passed by reference (adj->by_ref is true)
2437 it must be a part of an aggregate and therefore we form it by
2438 simply taking the address of a reference inside the original
2441 gcc_checking_assert (adj
->offset
% BITS_PER_UNIT
== 0);
2442 base
= gimple_call_arg (stmt
, adj
->base_index
);
2443 loc
= EXPR_LOCATION (base
);
2445 if (TREE_CODE (base
) != ADDR_EXPR
2446 && POINTER_TYPE_P (TREE_TYPE (base
)))
2447 off
= build_int_cst (adj
->alias_ptr_type
,
2448 adj
->offset
/ BITS_PER_UNIT
);
2451 HOST_WIDE_INT base_offset
;
2454 if (TREE_CODE (base
) == ADDR_EXPR
)
2455 base
= TREE_OPERAND (base
, 0);
2457 base
= get_addr_base_and_unit_offset (base
, &base_offset
);
2458 /* Aggregate arguments can have non-invariant addresses. */
2461 base
= build_fold_addr_expr (prev_base
);
2462 off
= build_int_cst (adj
->alias_ptr_type
,
2463 adj
->offset
/ BITS_PER_UNIT
);
2465 else if (TREE_CODE (base
) == MEM_REF
)
2467 off
= build_int_cst (adj
->alias_ptr_type
,
2469 + adj
->offset
/ BITS_PER_UNIT
);
2470 off
= int_const_binop (PLUS_EXPR
, TREE_OPERAND (base
, 1),
2472 base
= TREE_OPERAND (base
, 0);
2476 off
= build_int_cst (adj
->alias_ptr_type
,
2478 + adj
->offset
/ BITS_PER_UNIT
);
2479 base
= build_fold_addr_expr (base
);
2483 expr
= fold_build2_loc (loc
, MEM_REF
, adj
->type
, base
, off
);
2485 expr
= build_fold_addr_expr (expr
);
2487 expr
= force_gimple_operand_gsi (&gsi
, expr
,
2489 || is_gimple_reg_type (adj
->type
),
2490 NULL
, true, GSI_SAME_STMT
);
2491 VEC_quick_push (tree
, vargs
, expr
);
2495 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2497 fprintf (dump_file
, "replacing stmt:");
2498 print_gimple_stmt (dump_file
, gsi_stmt (gsi
), 0, 0);
2501 callee_decl
= !cs
? gimple_call_fndecl (stmt
) : cs
->callee
->decl
;
2502 new_stmt
= gimple_build_call_vec (callee_decl
, vargs
);
2503 VEC_free (tree
, heap
, vargs
);
2504 if (gimple_call_lhs (stmt
))
2505 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
2507 gimple_set_block (new_stmt
, gimple_block (stmt
));
2508 if (gimple_has_location (stmt
))
2509 gimple_set_location (new_stmt
, gimple_location (stmt
));
2510 gimple_call_copy_flags (new_stmt
, stmt
);
2511 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
2513 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2515 fprintf (dump_file
, "with stmt:");
2516 print_gimple_stmt (dump_file
, new_stmt
, 0, 0);
2517 fprintf (dump_file
, "\n");
2519 gsi_replace (&gsi
, new_stmt
, true);
2521 cgraph_set_call_stmt (cs
, new_stmt
);
2522 update_ssa (TODO_update_ssa
);
2523 free_dominance_info (CDI_DOMINATORS
);
2526 /* Return true iff BASE_INDEX is in ADJUSTMENTS more than once. */
2529 index_in_adjustments_multiple_times_p (int base_index
,
2530 ipa_parm_adjustment_vec adjustments
)
2532 int i
, len
= VEC_length (ipa_parm_adjustment_t
, adjustments
);
2535 for (i
= 0; i
< len
; i
++)
2537 struct ipa_parm_adjustment
*adj
;
2538 adj
= VEC_index (ipa_parm_adjustment_t
, adjustments
, i
);
2540 if (adj
->base_index
== base_index
)
2552 /* Return adjustments that should have the same effect on function parameters
2553 and call arguments as if they were first changed according to adjustments in
2554 INNER and then by adjustments in OUTER. */
2556 ipa_parm_adjustment_vec
2557 ipa_combine_adjustments (ipa_parm_adjustment_vec inner
,
2558 ipa_parm_adjustment_vec outer
)
2560 int i
, outlen
= VEC_length (ipa_parm_adjustment_t
, outer
);
2561 int inlen
= VEC_length (ipa_parm_adjustment_t
, inner
);
2563 ipa_parm_adjustment_vec adjustments
, tmp
;
2565 tmp
= VEC_alloc (ipa_parm_adjustment_t
, heap
, inlen
);
2566 for (i
= 0; i
< inlen
; i
++)
2568 struct ipa_parm_adjustment
*n
;
2569 n
= VEC_index (ipa_parm_adjustment_t
, inner
, i
);
2571 if (n
->remove_param
)
2574 VEC_quick_push (ipa_parm_adjustment_t
, tmp
, n
);
2577 adjustments
= VEC_alloc (ipa_parm_adjustment_t
, heap
, outlen
+ removals
);
2578 for (i
= 0; i
< outlen
; i
++)
2580 struct ipa_parm_adjustment
*r
;
2581 struct ipa_parm_adjustment
*out
= VEC_index (ipa_parm_adjustment_t
,
2583 struct ipa_parm_adjustment
*in
= VEC_index (ipa_parm_adjustment_t
, tmp
,
2586 gcc_assert (!in
->remove_param
);
2587 if (out
->remove_param
)
2589 if (!index_in_adjustments_multiple_times_p (in
->base_index
, tmp
))
2591 r
= VEC_quick_push (ipa_parm_adjustment_t
, adjustments
, NULL
);
2592 memset (r
, 0, sizeof (*r
));
2593 r
->remove_param
= true;
2598 r
= VEC_quick_push (ipa_parm_adjustment_t
, adjustments
, NULL
);
2599 memset (r
, 0, sizeof (*r
));
2600 r
->base_index
= in
->base_index
;
2601 r
->type
= out
->type
;
2603 /* FIXME: Create nonlocal value too. */
2605 if (in
->copy_param
&& out
->copy_param
)
2606 r
->copy_param
= true;
2607 else if (in
->copy_param
)
2608 r
->offset
= out
->offset
;
2609 else if (out
->copy_param
)
2610 r
->offset
= in
->offset
;
2612 r
->offset
= in
->offset
+ out
->offset
;
2615 for (i
= 0; i
< inlen
; i
++)
2617 struct ipa_parm_adjustment
*n
= VEC_index (ipa_parm_adjustment_t
,
2620 if (n
->remove_param
)
2621 VEC_quick_push (ipa_parm_adjustment_t
, adjustments
, n
);
2624 VEC_free (ipa_parm_adjustment_t
, heap
, tmp
);
2628 /* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human
2629 friendly way, assuming they are meant to be applied to FNDECL. */
2632 ipa_dump_param_adjustments (FILE *file
, ipa_parm_adjustment_vec adjustments
,
2635 int i
, len
= VEC_length (ipa_parm_adjustment_t
, adjustments
);
2637 VEC(tree
, heap
) *parms
= ipa_get_vector_of_formal_parms (fndecl
);
2639 fprintf (file
, "IPA param adjustments: ");
2640 for (i
= 0; i
< len
; i
++)
2642 struct ipa_parm_adjustment
*adj
;
2643 adj
= VEC_index (ipa_parm_adjustment_t
, adjustments
, i
);
2646 fprintf (file
, " ");
2650 fprintf (file
, "%i. base_index: %i - ", i
, adj
->base_index
);
2651 print_generic_expr (file
, VEC_index (tree
, parms
, adj
->base_index
), 0);
2654 fprintf (file
, ", base: ");
2655 print_generic_expr (file
, adj
->base
, 0);
2659 fprintf (file
, ", reduction: ");
2660 print_generic_expr (file
, adj
->reduction
, 0);
2662 if (adj
->new_ssa_base
)
2664 fprintf (file
, ", new_ssa_base: ");
2665 print_generic_expr (file
, adj
->new_ssa_base
, 0);
2668 if (adj
->copy_param
)
2669 fprintf (file
, ", copy_param");
2670 else if (adj
->remove_param
)
2671 fprintf (file
, ", remove_param");
2673 fprintf (file
, ", offset %li", (long) adj
->offset
);
2675 fprintf (file
, ", by_ref");
2676 print_node_brief (file
, ", type: ", adj
->type
, 0);
2677 fprintf (file
, "\n");
2679 VEC_free (tree
, heap
, parms
);
2682 /* Stream out jump function JUMP_FUNC to OB. */
2685 ipa_write_jump_function (struct output_block
*ob
,
2686 struct ipa_jump_func
*jump_func
)
2688 lto_output_uleb128_stream (ob
->main_stream
,
2691 switch (jump_func
->type
)
2693 case IPA_JF_UNKNOWN
:
2695 case IPA_JF_KNOWN_TYPE
:
2696 lto_output_tree (ob
, jump_func
->value
.base_binfo
, true);
2699 lto_output_tree (ob
, jump_func
->value
.constant
, true);
2701 case IPA_JF_PASS_THROUGH
:
2702 lto_output_tree (ob
, jump_func
->value
.pass_through
.operand
, true);
2703 lto_output_uleb128_stream (ob
->main_stream
,
2704 jump_func
->value
.pass_through
.formal_id
);
2705 lto_output_uleb128_stream (ob
->main_stream
,
2706 jump_func
->value
.pass_through
.operation
);
2708 case IPA_JF_ANCESTOR
:
2709 lto_output_uleb128_stream (ob
->main_stream
,
2710 jump_func
->value
.ancestor
.offset
);
2711 lto_output_tree (ob
, jump_func
->value
.ancestor
.type
, true);
2712 lto_output_uleb128_stream (ob
->main_stream
,
2713 jump_func
->value
.ancestor
.formal_id
);
2715 case IPA_JF_CONST_MEMBER_PTR
:
2716 lto_output_tree (ob
, jump_func
->value
.member_cst
.pfn
, true);
2717 lto_output_tree (ob
, jump_func
->value
.member_cst
.delta
, false);
2722 /* Read in jump function JUMP_FUNC from IB. */
2725 ipa_read_jump_function (struct lto_input_block
*ib
,
2726 struct ipa_jump_func
*jump_func
,
2727 struct data_in
*data_in
)
2729 jump_func
->type
= (enum jump_func_type
) lto_input_uleb128 (ib
);
2731 switch (jump_func
->type
)
2733 case IPA_JF_UNKNOWN
:
2735 case IPA_JF_KNOWN_TYPE
:
2736 jump_func
->value
.base_binfo
= lto_input_tree (ib
, data_in
);
2739 jump_func
->value
.constant
= lto_input_tree (ib
, data_in
);
2741 case IPA_JF_PASS_THROUGH
:
2742 jump_func
->value
.pass_through
.operand
= lto_input_tree (ib
, data_in
);
2743 jump_func
->value
.pass_through
.formal_id
= lto_input_uleb128 (ib
);
2744 jump_func
->value
.pass_through
.operation
= (enum tree_code
) lto_input_uleb128 (ib
);
2746 case IPA_JF_ANCESTOR
:
2747 jump_func
->value
.ancestor
.offset
= lto_input_uleb128 (ib
);
2748 jump_func
->value
.ancestor
.type
= lto_input_tree (ib
, data_in
);
2749 jump_func
->value
.ancestor
.formal_id
= lto_input_uleb128 (ib
);
2751 case IPA_JF_CONST_MEMBER_PTR
:
2752 jump_func
->value
.member_cst
.pfn
= lto_input_tree (ib
, data_in
);
2753 jump_func
->value
.member_cst
.delta
= lto_input_tree (ib
, data_in
);
2758 /* Stream out parts of cgraph_indirect_call_info corresponding to CS that are
2759 relevant to indirect inlining to OB. */
2762 ipa_write_indirect_edge_info (struct output_block
*ob
,
2763 struct cgraph_edge
*cs
)
2765 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
2766 struct bitpack_d bp
;
2768 lto_output_sleb128_stream (ob
->main_stream
, ii
->param_index
);
2769 lto_output_sleb128_stream (ob
->main_stream
, ii
->anc_offset
);
2770 bp
= bitpack_create (ob
->main_stream
);
2771 bp_pack_value (&bp
, ii
->polymorphic
, 1);
2772 lto_output_bitpack (&bp
);
2774 if (ii
->polymorphic
)
2776 lto_output_sleb128_stream (ob
->main_stream
, ii
->otr_token
);
2777 lto_output_tree (ob
, ii
->otr_type
, true);
2781 /* Read in parts of cgraph_indirect_call_info corresponding to CS that are
2782 relevant to indirect inlining from IB. */
2785 ipa_read_indirect_edge_info (struct lto_input_block
*ib
,
2786 struct data_in
*data_in ATTRIBUTE_UNUSED
,
2787 struct cgraph_edge
*cs
)
2789 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
2790 struct bitpack_d bp
;
2792 ii
->param_index
= (int) lto_input_sleb128 (ib
);
2793 ii
->anc_offset
= (HOST_WIDE_INT
) lto_input_sleb128 (ib
);
2794 bp
= lto_input_bitpack (ib
);
2795 ii
->polymorphic
= bp_unpack_value (&bp
, 1);
2796 if (ii
->polymorphic
)
2798 ii
->otr_token
= (HOST_WIDE_INT
) lto_input_sleb128 (ib
);
2799 ii
->otr_type
= lto_input_tree (ib
, data_in
);
2803 /* Stream out NODE info to OB. */
2806 ipa_write_node_info (struct output_block
*ob
, struct cgraph_node
*node
)
2809 lto_cgraph_encoder_t encoder
;
2810 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
2812 struct cgraph_edge
*e
;
2813 struct bitpack_d bp
;
2815 encoder
= ob
->decl_state
->cgraph_node_encoder
;
2816 node_ref
= lto_cgraph_encoder_encode (encoder
, node
);
2817 lto_output_uleb128_stream (ob
->main_stream
, node_ref
);
2819 bp
= bitpack_create (ob
->main_stream
);
2820 gcc_assert (info
->uses_analysis_done
2821 || ipa_get_param_count (info
) == 0);
2822 gcc_assert (!info
->node_enqueued
);
2823 gcc_assert (!info
->ipcp_orig_node
);
2824 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
2825 bp_pack_value (&bp
, info
->params
[j
].used
, 1);
2826 lto_output_bitpack (&bp
);
2827 for (e
= node
->callees
; e
; e
= e
->next_callee
)
2829 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
2831 lto_output_uleb128_stream (ob
->main_stream
,
2832 ipa_get_cs_argument_count (args
));
2833 for (j
= 0; j
< ipa_get_cs_argument_count (args
); j
++)
2834 ipa_write_jump_function (ob
, ipa_get_ith_jump_func (args
, j
));
2836 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
2838 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
2840 lto_output_uleb128_stream (ob
->main_stream
,
2841 ipa_get_cs_argument_count (args
));
2842 for (j
= 0; j
< ipa_get_cs_argument_count (args
); j
++)
2843 ipa_write_jump_function (ob
, ipa_get_ith_jump_func (args
, j
));
2844 ipa_write_indirect_edge_info (ob
, e
);
2848 /* Stream in NODE info from IB. */
2851 ipa_read_node_info (struct lto_input_block
*ib
, struct cgraph_node
*node
,
2852 struct data_in
*data_in
)
2854 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
2856 struct cgraph_edge
*e
;
2857 struct bitpack_d bp
;
2859 ipa_initialize_node_params (node
);
2861 bp
= lto_input_bitpack (ib
);
2862 if (ipa_get_param_count (info
) != 0)
2863 info
->uses_analysis_done
= true;
2864 info
->node_enqueued
= false;
2865 for (k
= 0; k
< ipa_get_param_count (info
); k
++)
2866 info
->params
[k
].used
= bp_unpack_value (&bp
, 1);
2867 for (e
= node
->callees
; e
; e
= e
->next_callee
)
2869 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
2870 int count
= lto_input_uleb128 (ib
);
2872 ipa_set_cs_argument_count (args
, count
);
2876 args
->jump_functions
= ggc_alloc_cleared_vec_ipa_jump_func
2877 (ipa_get_cs_argument_count (args
));
2878 for (k
= 0; k
< ipa_get_cs_argument_count (args
); k
++)
2879 ipa_read_jump_function (ib
, ipa_get_ith_jump_func (args
, k
), data_in
);
2881 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
2883 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
2884 int count
= lto_input_uleb128 (ib
);
2886 ipa_set_cs_argument_count (args
, count
);
2889 args
->jump_functions
= ggc_alloc_cleared_vec_ipa_jump_func
2890 (ipa_get_cs_argument_count (args
));
2891 for (k
= 0; k
< ipa_get_cs_argument_count (args
); k
++)
2892 ipa_read_jump_function (ib
, ipa_get_ith_jump_func (args
, k
), data_in
);
2894 ipa_read_indirect_edge_info (ib
, data_in
, e
);
2898 /* Write jump functions for nodes in SET. */
2901 ipa_prop_write_jump_functions (cgraph_node_set set
)
2903 struct cgraph_node
*node
;
2904 struct output_block
*ob
;
2905 unsigned int count
= 0;
2906 cgraph_node_set_iterator csi
;
2908 if (!ipa_node_params_vector
)
2911 ob
= create_output_block (LTO_section_jump_functions
);
2912 ob
->cgraph_node
= NULL
;
2913 for (csi
= csi_start (set
); !csi_end_p (csi
); csi_next (&csi
))
2915 node
= csi_node (csi
);
2916 if (cgraph_function_with_gimple_body_p (node
)
2917 && IPA_NODE_REF (node
) != NULL
)
2921 lto_output_uleb128_stream (ob
->main_stream
, count
);
2923 /* Process all of the functions. */
2924 for (csi
= csi_start (set
); !csi_end_p (csi
); csi_next (&csi
))
2926 node
= csi_node (csi
);
2927 if (cgraph_function_with_gimple_body_p (node
)
2928 && IPA_NODE_REF (node
) != NULL
)
2929 ipa_write_node_info (ob
, node
);
2931 lto_output_1_stream (ob
->main_stream
, 0);
2932 produce_asm (ob
, NULL
);
2933 destroy_output_block (ob
);
2936 /* Read section in file FILE_DATA of length LEN with data DATA. */
2939 ipa_prop_read_section (struct lto_file_decl_data
*file_data
, const char *data
,
2942 const struct lto_function_header
*header
=
2943 (const struct lto_function_header
*) data
;
2944 const int32_t cfg_offset
= sizeof (struct lto_function_header
);
2945 const int32_t main_offset
= cfg_offset
+ header
->cfg_size
;
2946 const int32_t string_offset
= main_offset
+ header
->main_size
;
2947 struct data_in
*data_in
;
2948 struct lto_input_block ib_main
;
2952 LTO_INIT_INPUT_BLOCK (ib_main
, (const char *) data
+ main_offset
, 0,
2956 lto_data_in_create (file_data
, (const char *) data
+ string_offset
,
2957 header
->string_size
, NULL
);
2958 count
= lto_input_uleb128 (&ib_main
);
2960 for (i
= 0; i
< count
; i
++)
2963 struct cgraph_node
*node
;
2964 lto_cgraph_encoder_t encoder
;
2966 index
= lto_input_uleb128 (&ib_main
);
2967 encoder
= file_data
->cgraph_node_encoder
;
2968 node
= lto_cgraph_encoder_deref (encoder
, index
);
2969 gcc_assert (node
->analyzed
);
2970 ipa_read_node_info (&ib_main
, node
, data_in
);
2972 lto_free_section_data (file_data
, LTO_section_jump_functions
, NULL
, data
,
2974 lto_data_in_delete (data_in
);
2977 /* Read ipcp jump functions. */
2980 ipa_prop_read_jump_functions (void)
2982 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
2983 struct lto_file_decl_data
*file_data
;
2986 ipa_check_create_node_params ();
2987 ipa_check_create_edge_args ();
2988 ipa_register_cgraph_hooks ();
2990 while ((file_data
= file_data_vec
[j
++]))
2993 const char *data
= lto_get_section_data (file_data
, LTO_section_jump_functions
, NULL
, &len
);
2996 ipa_prop_read_section (file_data
, data
, len
);
3000 /* After merging units, we can get mismatch in argument counts.
3001 Also decl merging might've rendered parameter lists obsolete.
3002 Also compute called_with_variable_arg info. */
3005 ipa_update_after_lto_read (void)
3007 struct cgraph_node
*node
;
3008 struct cgraph_edge
*cs
;
3010 ipa_check_create_node_params ();
3011 ipa_check_create_edge_args ();
3013 for (node
= cgraph_nodes
; node
; node
= node
->next
)
3015 ipa_initialize_node_params (node
);
3017 for (node
= cgraph_nodes
; node
; node
= node
->next
)
3019 for (cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
3021 struct cgraph_node
*callee
;
3023 callee
= cgraph_function_or_thunk_node (cs
->callee
, NULL
);
3024 if (ipa_get_cs_argument_count (IPA_EDGE_REF (cs
))
3025 != ipa_get_param_count (IPA_NODE_REF (callee
)))
3026 ipa_set_called_with_variable_arg (IPA_NODE_REF (callee
));
3030 /* Given the jump function JFUNC, compute the lattice LAT that describes the
3031 value coming down the callsite. INFO describes the caller node so that
3032 pass-through jump functions can be evaluated. */
3035 ipa_lattice_from_jfunc (struct ipa_node_params
*info
, struct ipcp_lattice
*lat
,
3036 struct ipa_jump_func
*jfunc
)
3038 if (jfunc
->type
== IPA_JF_CONST
)
3040 lat
->type
= IPA_CONST_VALUE
;
3041 lat
->constant
= jfunc
->value
.constant
;
3043 else if (jfunc
->type
== IPA_JF_PASS_THROUGH
)
3045 struct ipcp_lattice
*caller_lat
;
3048 caller_lat
= ipa_get_lattice (info
, jfunc
->value
.pass_through
.formal_id
);
3049 lat
->type
= caller_lat
->type
;
3050 if (caller_lat
->type
!= IPA_CONST_VALUE
)
3052 cst
= caller_lat
->constant
;
3054 if (jfunc
->value
.pass_through
.operation
!= NOP_EXPR
)
3057 if (TREE_CODE_CLASS (jfunc
->value
.pass_through
.operation
)
3059 restype
= boolean_type_node
;
3061 restype
= TREE_TYPE (cst
);
3062 cst
= fold_binary (jfunc
->value
.pass_through
.operation
,
3063 restype
, cst
, jfunc
->value
.pass_through
.operand
);
3065 if (!cst
|| !is_gimple_ip_invariant (cst
))
3066 lat
->type
= IPA_BOTTOM
;
3067 lat
->constant
= cst
;
3069 else if (jfunc
->type
== IPA_JF_ANCESTOR
)
3071 struct ipcp_lattice
*caller_lat
;
3074 caller_lat
= ipa_get_lattice (info
, jfunc
->value
.ancestor
.formal_id
);
3075 lat
->type
= caller_lat
->type
;
3076 if (caller_lat
->type
!= IPA_CONST_VALUE
)
3078 if (TREE_CODE (caller_lat
->constant
) != ADDR_EXPR
)
3080 /* This can happen when the constant is a NULL pointer. */
3081 lat
->type
= IPA_BOTTOM
;
3084 t
= TREE_OPERAND (caller_lat
->constant
, 0);
3085 t
= build_ref_for_offset (EXPR_LOCATION (t
), t
,
3086 jfunc
->value
.ancestor
.offset
,
3087 jfunc
->value
.ancestor
.type
, NULL
, false);
3088 lat
->constant
= build_fold_addr_expr (t
);
3091 lat
->type
= IPA_BOTTOM
;
3094 /* Determine whether JFUNC evaluates to a constant and if so, return it.
3095 Otherwise return NULL. INFO describes the caller node so that pass-through
3096 jump functions can be evaluated. */
3099 ipa_cst_from_jfunc (struct ipa_node_params
*info
, struct ipa_jump_func
*jfunc
)
3101 struct ipcp_lattice lat
;
3103 ipa_lattice_from_jfunc (info
, &lat
, jfunc
);
3104 if (lat
.type
== IPA_CONST_VALUE
)
3105 return lat
.constant
;