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 || !integer_zerop (gimple_cond_rhs (branch
)))
1354 cond
= gimple_cond_lhs (branch
);
1355 if (!ipa_is_ssa_with_stmt_def (cond
))
1358 def
= SSA_NAME_DEF_STMT (cond
);
1359 if (!is_gimple_assign (def
)
1360 || gimple_assign_rhs_code (def
) != BIT_AND_EXPR
1361 || !integer_onep (gimple_assign_rhs2 (def
)))
1364 cond
= gimple_assign_rhs1 (def
);
1365 if (!ipa_is_ssa_with_stmt_def (cond
))
1368 def
= SSA_NAME_DEF_STMT (cond
);
1370 if (is_gimple_assign (def
)
1371 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def
)))
1373 cond
= gimple_assign_rhs1 (def
);
1374 if (!ipa_is_ssa_with_stmt_def (cond
))
1376 def
= SSA_NAME_DEF_STMT (cond
);
1379 rec2
= ipa_get_stmt_member_ptr_load_param (def
,
1380 (TARGET_PTRMEMFUNC_VBIT_LOCATION
1381 == ptrmemfunc_vbit_in_delta
));
1386 index
= ipa_get_param_decl_index (info
, rec
);
1387 if (index
>= 0 && !is_parm_modified_before_call (&parms_info
[index
],
1389 ipa_note_param_call (node
, index
, call
);
1394 /* Analyze a CALL to an OBJ_TYPE_REF which is passed in TARGET and if the
1395 object referenced in the expression is a formal parameter of the caller
1396 (described by INFO), create a call note for the statement. */
1399 ipa_analyze_virtual_call_uses (struct cgraph_node
*node
,
1400 struct ipa_node_params
*info
, gimple call
,
1403 struct cgraph_edge
*cs
;
1404 struct cgraph_indirect_call_info
*ii
;
1405 struct ipa_jump_func jfunc
;
1406 tree obj
= OBJ_TYPE_REF_OBJECT (target
);
1408 HOST_WIDE_INT anc_offset
;
1410 if (!flag_devirtualize
)
1413 if (TREE_CODE (obj
) != SSA_NAME
)
1416 if (SSA_NAME_IS_DEFAULT_DEF (obj
))
1418 if (TREE_CODE (SSA_NAME_VAR (obj
)) != PARM_DECL
)
1422 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (obj
));
1423 gcc_assert (index
>= 0);
1424 if (detect_type_change_ssa (obj
, call
, &jfunc
))
1429 gimple stmt
= SSA_NAME_DEF_STMT (obj
);
1432 expr
= get_ancestor_addr_info (stmt
, &obj
, &anc_offset
);
1435 index
= ipa_get_param_decl_index (info
,
1436 SSA_NAME_VAR (TREE_OPERAND (expr
, 0)));
1437 gcc_assert (index
>= 0);
1438 if (detect_type_change (obj
, expr
, call
, &jfunc
, anc_offset
))
1442 cs
= ipa_note_param_call (node
, index
, call
);
1443 ii
= cs
->indirect_info
;
1444 ii
->anc_offset
= anc_offset
;
1445 ii
->otr_token
= tree_low_cst (OBJ_TYPE_REF_TOKEN (target
), 1);
1446 ii
->otr_type
= TREE_TYPE (TREE_TYPE (OBJ_TYPE_REF_OBJECT (target
)));
1447 ii
->polymorphic
= 1;
1450 /* Analyze a call statement CALL whether and how it utilizes formal parameters
1451 of the caller (described by INFO). PARMS_INFO is a pointer to a vector
1452 containing intermediate information about each formal parameter. */
1455 ipa_analyze_call_uses (struct cgraph_node
*node
,
1456 struct ipa_node_params
*info
,
1457 struct param_analysis_info
*parms_info
, gimple call
)
1459 tree target
= gimple_call_fn (call
);
1463 if (TREE_CODE (target
) == SSA_NAME
)
1464 ipa_analyze_indirect_call_uses (node
, info
, parms_info
, call
, target
);
1465 else if (TREE_CODE (target
) == OBJ_TYPE_REF
)
1466 ipa_analyze_virtual_call_uses (node
, info
, call
, target
);
1470 /* Analyze the call statement STMT with respect to formal parameters (described
1471 in INFO) of caller given by NODE. Currently it only checks whether formal
1472 parameters are called. PARMS_INFO is a pointer to a vector containing
1473 intermediate information about each formal parameter. */
1476 ipa_analyze_stmt_uses (struct cgraph_node
*node
, struct ipa_node_params
*info
,
1477 struct param_analysis_info
*parms_info
, gimple stmt
)
1479 if (is_gimple_call (stmt
))
1480 ipa_analyze_call_uses (node
, info
, parms_info
, stmt
);
1483 /* Callback of walk_stmt_load_store_addr_ops for the visit_load.
1484 If OP is a parameter declaration, mark it as used in the info structure
1488 visit_ref_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED
,
1489 tree op
, void *data
)
1491 struct ipa_node_params
*info
= (struct ipa_node_params
*) data
;
1493 op
= get_base_address (op
);
1495 && TREE_CODE (op
) == PARM_DECL
)
1497 int index
= ipa_get_param_decl_index (info
, op
);
1498 gcc_assert (index
>= 0);
1499 info
->params
[index
].used
= true;
1505 /* Scan the function body of NODE and inspect the uses of formal parameters.
1506 Store the findings in various structures of the associated ipa_node_params
1507 structure, such as parameter flags, notes etc. PARMS_INFO is a pointer to a
1508 vector containing intermediate information about each formal parameter. */
1511 ipa_analyze_params_uses (struct cgraph_node
*node
,
1512 struct param_analysis_info
*parms_info
)
1514 tree decl
= node
->decl
;
1516 struct function
*func
;
1517 gimple_stmt_iterator gsi
;
1518 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
1521 if (ipa_get_param_count (info
) == 0 || info
->uses_analysis_done
)
1524 for (i
= 0; i
< ipa_get_param_count (info
); i
++)
1526 tree parm
= ipa_get_param (info
, i
);
1527 /* For SSA regs see if parameter is used. For non-SSA we compute
1528 the flag during modification analysis. */
1529 if (is_gimple_reg (parm
)
1530 && gimple_default_def (DECL_STRUCT_FUNCTION (node
->decl
), parm
))
1531 info
->params
[i
].used
= true;
1534 func
= DECL_STRUCT_FUNCTION (decl
);
1535 FOR_EACH_BB_FN (bb
, func
)
1537 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1539 gimple stmt
= gsi_stmt (gsi
);
1541 if (is_gimple_debug (stmt
))
1544 ipa_analyze_stmt_uses (node
, info
, parms_info
, stmt
);
1545 walk_stmt_load_store_addr_ops (stmt
, info
,
1546 visit_ref_for_mod_analysis
,
1547 visit_ref_for_mod_analysis
,
1548 visit_ref_for_mod_analysis
);
1550 for (gsi
= gsi_start (phi_nodes (bb
)); !gsi_end_p (gsi
); gsi_next (&gsi
))
1551 walk_stmt_load_store_addr_ops (gsi_stmt (gsi
), info
,
1552 visit_ref_for_mod_analysis
,
1553 visit_ref_for_mod_analysis
,
1554 visit_ref_for_mod_analysis
);
1557 info
->uses_analysis_done
= 1;
1560 /* Initialize the array describing properties of of formal parameters
1561 of NODE, analyze their uses and compute jump functions associated
1562 with actual arguments of calls from within NODE. */
1565 ipa_analyze_node (struct cgraph_node
*node
)
1567 struct ipa_node_params
*info
;
1568 struct param_analysis_info
*parms_info
;
1571 ipa_check_create_node_params ();
1572 ipa_check_create_edge_args ();
1573 info
= IPA_NODE_REF (node
);
1574 push_cfun (DECL_STRUCT_FUNCTION (node
->decl
));
1575 current_function_decl
= node
->decl
;
1576 ipa_initialize_node_params (node
);
1578 param_count
= ipa_get_param_count (info
);
1579 parms_info
= XALLOCAVEC (struct param_analysis_info
, param_count
);
1580 memset (parms_info
, 0, sizeof (struct param_analysis_info
) * param_count
);
1582 ipa_analyze_params_uses (node
, parms_info
);
1583 ipa_compute_jump_functions (node
, parms_info
);
1585 for (i
= 0; i
< param_count
; i
++)
1586 if (parms_info
[i
].visited_statements
)
1587 BITMAP_FREE (parms_info
[i
].visited_statements
);
1589 current_function_decl
= NULL
;
1594 /* Update the jump function DST when the call graph edge corresponding to SRC is
1595 is being inlined, knowing that DST is of type ancestor and src of known
1599 combine_known_type_and_ancestor_jfs (struct ipa_jump_func
*src
,
1600 struct ipa_jump_func
*dst
)
1604 new_binfo
= get_binfo_at_offset (src
->value
.base_binfo
,
1605 dst
->value
.ancestor
.offset
,
1606 dst
->value
.ancestor
.type
);
1609 dst
->type
= IPA_JF_KNOWN_TYPE
;
1610 dst
->value
.base_binfo
= new_binfo
;
1613 dst
->type
= IPA_JF_UNKNOWN
;
1616 /* Update the jump functions associated with call graph edge E when the call
1617 graph edge CS is being inlined, assuming that E->caller is already (possibly
1618 indirectly) inlined into CS->callee and that E has not been inlined. */
1621 update_jump_functions_after_inlining (struct cgraph_edge
*cs
,
1622 struct cgraph_edge
*e
)
1624 struct ipa_edge_args
*top
= IPA_EDGE_REF (cs
);
1625 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
1626 int count
= ipa_get_cs_argument_count (args
);
1629 for (i
= 0; i
< count
; i
++)
1631 struct ipa_jump_func
*dst
= ipa_get_ith_jump_func (args
, i
);
1633 if (dst
->type
== IPA_JF_ANCESTOR
)
1635 struct ipa_jump_func
*src
;
1637 /* Variable number of arguments can cause havoc if we try to access
1638 one that does not exist in the inlined edge. So make sure we
1640 if (dst
->value
.ancestor
.formal_id
>= ipa_get_cs_argument_count (top
))
1642 dst
->type
= IPA_JF_UNKNOWN
;
1646 src
= ipa_get_ith_jump_func (top
, dst
->value
.ancestor
.formal_id
);
1647 if (src
->type
== IPA_JF_KNOWN_TYPE
)
1648 combine_known_type_and_ancestor_jfs (src
, dst
);
1649 else if (src
->type
== IPA_JF_PASS_THROUGH
1650 && src
->value
.pass_through
.operation
== NOP_EXPR
)
1651 dst
->value
.ancestor
.formal_id
= src
->value
.pass_through
.formal_id
;
1652 else if (src
->type
== IPA_JF_ANCESTOR
)
1654 dst
->value
.ancestor
.formal_id
= src
->value
.ancestor
.formal_id
;
1655 dst
->value
.ancestor
.offset
+= src
->value
.ancestor
.offset
;
1658 dst
->type
= IPA_JF_UNKNOWN
;
1660 else if (dst
->type
== IPA_JF_PASS_THROUGH
)
1662 struct ipa_jump_func
*src
;
1663 /* We must check range due to calls with variable number of arguments
1664 and we cannot combine jump functions with operations. */
1665 if (dst
->value
.pass_through
.operation
== NOP_EXPR
1666 && (dst
->value
.pass_through
.formal_id
1667 < ipa_get_cs_argument_count (top
)))
1669 src
= ipa_get_ith_jump_func (top
,
1670 dst
->value
.pass_through
.formal_id
);
1674 dst
->type
= IPA_JF_UNKNOWN
;
1679 /* If TARGET is an addr_expr of a function declaration, make it the destination
1680 of an indirect edge IE and return the edge. Otherwise, return NULL. Delta,
1681 if non-NULL, is an integer constant that must be added to this pointer
1682 (first parameter). */
1684 struct cgraph_edge
*
1685 ipa_make_edge_direct_to_target (struct cgraph_edge
*ie
, tree target
, tree delta
)
1687 struct cgraph_node
*callee
;
1689 if (TREE_CODE (target
) == ADDR_EXPR
)
1690 target
= TREE_OPERAND (target
, 0);
1691 if (TREE_CODE (target
) != FUNCTION_DECL
)
1693 callee
= cgraph_get_node (target
);
1696 ipa_check_create_node_params ();
1698 /* We can not make edges to inline clones. It is bug that someone removed the cgraph
1700 gcc_assert (!callee
->global
.inlined_to
);
1702 cgraph_make_edge_direct (ie
, callee
, delta
? tree_low_cst (delta
, 0) : 0);
1705 fprintf (dump_file
, "ipa-prop: Discovered %s call to a known target "
1706 "(%s/%i -> %s/%i), for stmt ",
1707 ie
->indirect_info
->polymorphic
? "a virtual" : "an indirect",
1708 cgraph_node_name (ie
->caller
), ie
->caller
->uid
,
1709 cgraph_node_name (ie
->callee
), ie
->callee
->uid
);
1711 print_gimple_stmt (dump_file
, ie
->call_stmt
, 2, TDF_SLIM
);
1713 fprintf (dump_file
, "with uid %i\n", ie
->lto_stmt_uid
);
1717 fprintf (dump_file
, " Thunk delta is ");
1718 print_generic_expr (dump_file
, delta
, 0);
1719 fprintf (dump_file
, "\n");
1723 if (ipa_get_cs_argument_count (IPA_EDGE_REF (ie
))
1724 != ipa_get_param_count (IPA_NODE_REF (callee
)))
1725 ipa_set_called_with_variable_arg (IPA_NODE_REF (callee
));
1730 /* Try to find a destination for indirect edge IE that corresponds to a simple
1731 call or a call of a member function pointer and where the destination is a
1732 pointer formal parameter described by jump function JFUNC. If it can be
1733 determined, return the newly direct edge, otherwise return NULL. */
1735 static struct cgraph_edge
*
1736 try_make_edge_direct_simple_call (struct cgraph_edge
*ie
,
1737 struct ipa_jump_func
*jfunc
)
1741 if (jfunc
->type
== IPA_JF_CONST
)
1742 target
= jfunc
->value
.constant
;
1743 else if (jfunc
->type
== IPA_JF_CONST_MEMBER_PTR
)
1744 target
= jfunc
->value
.member_cst
.pfn
;
1748 return ipa_make_edge_direct_to_target (ie
, target
, NULL_TREE
);
1751 /* Try to find a destination for indirect edge IE that corresponds to a
1752 virtual call based on a formal parameter which is described by jump
1753 function JFUNC and if it can be determined, make it direct and return the
1754 direct edge. Otherwise, return NULL. */
1756 static struct cgraph_edge
*
1757 try_make_edge_direct_virtual_call (struct cgraph_edge
*ie
,
1758 struct ipa_jump_func
*jfunc
)
1760 tree binfo
, type
, target
, delta
;
1761 HOST_WIDE_INT token
;
1763 if (jfunc
->type
== IPA_JF_KNOWN_TYPE
)
1764 binfo
= jfunc
->value
.base_binfo
;
1771 token
= ie
->indirect_info
->otr_token
;
1772 type
= ie
->indirect_info
->otr_type
;
1773 binfo
= get_binfo_at_offset (binfo
, ie
->indirect_info
->anc_offset
, type
);
1775 target
= gimple_get_virt_method_for_binfo (token
, binfo
, &delta
);
1780 return ipa_make_edge_direct_to_target (ie
, target
, delta
);
1785 /* Update the param called notes associated with NODE when CS is being inlined,
1786 assuming NODE is (potentially indirectly) inlined into CS->callee.
1787 Moreover, if the callee is discovered to be constant, create a new cgraph
1788 edge for it. Newly discovered indirect edges will be added to *NEW_EDGES,
1789 unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
1792 update_indirect_edges_after_inlining (struct cgraph_edge
*cs
,
1793 struct cgraph_node
*node
,
1794 VEC (cgraph_edge_p
, heap
) **new_edges
)
1796 struct ipa_edge_args
*top
;
1797 struct cgraph_edge
*ie
, *next_ie
, *new_direct_edge
;
1800 ipa_check_create_edge_args ();
1801 top
= IPA_EDGE_REF (cs
);
1803 for (ie
= node
->indirect_calls
; ie
; ie
= next_ie
)
1805 struct cgraph_indirect_call_info
*ici
= ie
->indirect_info
;
1806 struct ipa_jump_func
*jfunc
;
1808 next_ie
= ie
->next_callee
;
1809 if (bitmap_bit_p (iinlining_processed_edges
, ie
->uid
))
1812 /* If we ever use indirect edges for anything other than indirect
1813 inlining, we will need to skip those with negative param_indices. */
1814 if (ici
->param_index
== -1)
1817 /* We must check range due to calls with variable number of arguments: */
1818 if (ici
->param_index
>= ipa_get_cs_argument_count (top
))
1820 bitmap_set_bit (iinlining_processed_edges
, ie
->uid
);
1824 jfunc
= ipa_get_ith_jump_func (top
, ici
->param_index
);
1825 if (jfunc
->type
== IPA_JF_PASS_THROUGH
1826 && jfunc
->value
.pass_through
.operation
== NOP_EXPR
)
1827 ici
->param_index
= jfunc
->value
.pass_through
.formal_id
;
1828 else if (jfunc
->type
== IPA_JF_ANCESTOR
)
1830 ici
->param_index
= jfunc
->value
.ancestor
.formal_id
;
1831 ici
->anc_offset
+= jfunc
->value
.ancestor
.offset
;
1834 /* Either we can find a destination for this edge now or never. */
1835 bitmap_set_bit (iinlining_processed_edges
, ie
->uid
);
1837 if (ici
->polymorphic
)
1838 new_direct_edge
= try_make_edge_direct_virtual_call (ie
, jfunc
);
1840 new_direct_edge
= try_make_edge_direct_simple_call (ie
, jfunc
);
1842 if (new_direct_edge
)
1844 new_direct_edge
->indirect_inlining_edge
= 1;
1847 VEC_safe_push (cgraph_edge_p
, heap
, *new_edges
,
1849 top
= IPA_EDGE_REF (cs
);
1858 /* Recursively traverse subtree of NODE (including node) made of inlined
1859 cgraph_edges when CS has been inlined and invoke
1860 update_indirect_edges_after_inlining on all nodes and
1861 update_jump_functions_after_inlining on all non-inlined edges that lead out
1862 of this subtree. Newly discovered indirect edges will be added to
1863 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were
1867 propagate_info_to_inlined_callees (struct cgraph_edge
*cs
,
1868 struct cgraph_node
*node
,
1869 VEC (cgraph_edge_p
, heap
) **new_edges
)
1871 struct cgraph_edge
*e
;
1874 res
= update_indirect_edges_after_inlining (cs
, node
, new_edges
);
1876 for (e
= node
->callees
; e
; e
= e
->next_callee
)
1877 if (!e
->inline_failed
)
1878 res
|= propagate_info_to_inlined_callees (cs
, e
->callee
, new_edges
);
1880 update_jump_functions_after_inlining (cs
, e
);
1885 /* Update jump functions and call note functions on inlining the call site CS.
1886 CS is expected to lead to a node already cloned by
1887 cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to
1888 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were +
1892 ipa_propagate_indirect_call_infos (struct cgraph_edge
*cs
,
1893 VEC (cgraph_edge_p
, heap
) **new_edges
)
1895 /* Do nothing if the preparation phase has not been carried out yet
1896 (i.e. during early inlining). */
1897 if (!ipa_node_params_vector
)
1899 gcc_assert (ipa_edge_args_vector
);
1901 return propagate_info_to_inlined_callees (cs
, cs
->callee
, new_edges
);
1904 /* Frees all dynamically allocated structures that the argument info points
1908 ipa_free_edge_args_substructures (struct ipa_edge_args
*args
)
1910 if (args
->jump_functions
)
1911 ggc_free (args
->jump_functions
);
1913 memset (args
, 0, sizeof (*args
));
1916 /* Free all ipa_edge structures. */
1919 ipa_free_all_edge_args (void)
1922 struct ipa_edge_args
*args
;
1924 FOR_EACH_VEC_ELT (ipa_edge_args_t
, ipa_edge_args_vector
, i
, args
)
1925 ipa_free_edge_args_substructures (args
);
1927 VEC_free (ipa_edge_args_t
, gc
, ipa_edge_args_vector
);
1928 ipa_edge_args_vector
= NULL
;
1931 /* Frees all dynamically allocated structures that the param info points
1935 ipa_free_node_params_substructures (struct ipa_node_params
*info
)
1937 free (info
->params
);
1939 memset (info
, 0, sizeof (*info
));
1942 /* Free all ipa_node_params structures. */
1945 ipa_free_all_node_params (void)
1948 struct ipa_node_params
*info
;
1950 FOR_EACH_VEC_ELT (ipa_node_params_t
, ipa_node_params_vector
, i
, info
)
1951 ipa_free_node_params_substructures (info
);
1953 VEC_free (ipa_node_params_t
, heap
, ipa_node_params_vector
);
1954 ipa_node_params_vector
= NULL
;
1957 /* Hook that is called by cgraph.c when an edge is removed. */
1960 ipa_edge_removal_hook (struct cgraph_edge
*cs
, void *data ATTRIBUTE_UNUSED
)
1962 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1963 if (VEC_length (ipa_edge_args_t
, ipa_edge_args_vector
)
1964 <= (unsigned)cs
->uid
)
1966 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs
));
1969 /* Hook that is called by cgraph.c when a node is removed. */
1972 ipa_node_removal_hook (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
1974 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1975 if (VEC_length (ipa_node_params_t
, ipa_node_params_vector
)
1976 <= (unsigned)node
->uid
)
1978 ipa_free_node_params_substructures (IPA_NODE_REF (node
));
1981 /* Helper function to duplicate an array of size N that is at SRC and store a
1982 pointer to it to DST. Nothing is done if SRC is NULL. */
1985 duplicate_array (void *src
, size_t n
)
1997 static struct ipa_jump_func
*
1998 duplicate_ipa_jump_func_array (const struct ipa_jump_func
* src
, size_t n
)
2000 struct ipa_jump_func
*p
;
2005 p
= ggc_alloc_vec_ipa_jump_func (n
);
2006 memcpy (p
, src
, n
* sizeof (struct ipa_jump_func
));
2010 /* Hook that is called by cgraph.c when a node is duplicated. */
2013 ipa_edge_duplication_hook (struct cgraph_edge
*src
, struct cgraph_edge
*dst
,
2014 __attribute__((unused
)) void *data
)
2016 struct ipa_edge_args
*old_args
, *new_args
;
2019 ipa_check_create_edge_args ();
2021 old_args
= IPA_EDGE_REF (src
);
2022 new_args
= IPA_EDGE_REF (dst
);
2024 arg_count
= ipa_get_cs_argument_count (old_args
);
2025 ipa_set_cs_argument_count (new_args
, arg_count
);
2026 new_args
->jump_functions
=
2027 duplicate_ipa_jump_func_array (old_args
->jump_functions
, arg_count
);
2029 if (iinlining_processed_edges
2030 && bitmap_bit_p (iinlining_processed_edges
, src
->uid
))
2031 bitmap_set_bit (iinlining_processed_edges
, dst
->uid
);
2034 /* Hook that is called by cgraph.c when a node is duplicated. */
2037 ipa_node_duplication_hook (struct cgraph_node
*src
, struct cgraph_node
*dst
,
2038 ATTRIBUTE_UNUSED
void *data
)
2040 struct ipa_node_params
*old_info
, *new_info
;
2043 ipa_check_create_node_params ();
2044 old_info
= IPA_NODE_REF (src
);
2045 new_info
= IPA_NODE_REF (dst
);
2046 param_count
= ipa_get_param_count (old_info
);
2048 ipa_set_param_count (new_info
, param_count
);
2049 new_info
->params
= (struct ipa_param_descriptor
*)
2050 duplicate_array (old_info
->params
,
2051 sizeof (struct ipa_param_descriptor
) * param_count
);
2052 for (i
= 0; i
< param_count
; i
++)
2053 new_info
->params
[i
].types
= VEC_copy (tree
, heap
,
2054 old_info
->params
[i
].types
);
2055 new_info
->ipcp_orig_node
= old_info
->ipcp_orig_node
;
2056 new_info
->count_scale
= old_info
->count_scale
;
2058 new_info
->called_with_var_arguments
= old_info
->called_with_var_arguments
;
2059 new_info
->uses_analysis_done
= old_info
->uses_analysis_done
;
2060 new_info
->node_enqueued
= old_info
->node_enqueued
;
2064 /* Analyze newly added function into callgraph. */
2067 ipa_add_new_function (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
2069 ipa_analyze_node (node
);
2072 /* Register our cgraph hooks if they are not already there. */
2075 ipa_register_cgraph_hooks (void)
2077 if (!edge_removal_hook_holder
)
2078 edge_removal_hook_holder
=
2079 cgraph_add_edge_removal_hook (&ipa_edge_removal_hook
, NULL
);
2080 if (!node_removal_hook_holder
)
2081 node_removal_hook_holder
=
2082 cgraph_add_node_removal_hook (&ipa_node_removal_hook
, NULL
);
2083 if (!edge_duplication_hook_holder
)
2084 edge_duplication_hook_holder
=
2085 cgraph_add_edge_duplication_hook (&ipa_edge_duplication_hook
, NULL
);
2086 if (!node_duplication_hook_holder
)
2087 node_duplication_hook_holder
=
2088 cgraph_add_node_duplication_hook (&ipa_node_duplication_hook
, NULL
);
2089 function_insertion_hook_holder
=
2090 cgraph_add_function_insertion_hook (&ipa_add_new_function
, NULL
);
2093 /* Unregister our cgraph hooks if they are not already there. */
2096 ipa_unregister_cgraph_hooks (void)
2098 cgraph_remove_edge_removal_hook (edge_removal_hook_holder
);
2099 edge_removal_hook_holder
= NULL
;
2100 cgraph_remove_node_removal_hook (node_removal_hook_holder
);
2101 node_removal_hook_holder
= NULL
;
2102 cgraph_remove_edge_duplication_hook (edge_duplication_hook_holder
);
2103 edge_duplication_hook_holder
= NULL
;
2104 cgraph_remove_node_duplication_hook (node_duplication_hook_holder
);
2105 node_duplication_hook_holder
= NULL
;
2106 cgraph_remove_function_insertion_hook (function_insertion_hook_holder
);
2107 function_insertion_hook_holder
= NULL
;
2110 /* Allocate all necessary data structures necessary for indirect inlining. */
2113 ipa_create_all_structures_for_iinln (void)
2115 iinlining_processed_edges
= BITMAP_ALLOC (NULL
);
2118 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
2119 longer needed after ipa-cp. */
2122 ipa_free_all_structures_after_ipa_cp (void)
2124 if (!flag_indirect_inlining
)
2126 ipa_free_all_edge_args ();
2127 ipa_free_all_node_params ();
2128 ipa_unregister_cgraph_hooks ();
2132 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
2133 longer needed after indirect inlining. */
2136 ipa_free_all_structures_after_iinln (void)
2138 BITMAP_FREE (iinlining_processed_edges
);
2140 ipa_free_all_edge_args ();
2141 ipa_free_all_node_params ();
2142 ipa_unregister_cgraph_hooks ();
2145 /* Print ipa_tree_map data structures of all functions in the
2149 ipa_print_node_params (FILE * f
, struct cgraph_node
*node
)
2153 struct ipa_node_params
*info
;
2155 if (!node
->analyzed
)
2157 info
= IPA_NODE_REF (node
);
2158 fprintf (f
, " function %s parameter descriptors:\n",
2159 cgraph_node_name (node
));
2160 count
= ipa_get_param_count (info
);
2161 for (i
= 0; i
< count
; i
++)
2163 temp
= ipa_get_param (info
, i
);
2164 if (TREE_CODE (temp
) == PARM_DECL
)
2165 fprintf (f
, " param %d : %s", i
,
2167 ? (*lang_hooks
.decl_printable_name
) (temp
, 2)
2169 if (ipa_is_param_used (info
, i
))
2170 fprintf (f
, " used");
2175 /* Print ipa_tree_map data structures of all functions in the
2179 ipa_print_all_params (FILE * f
)
2181 struct cgraph_node
*node
;
2183 fprintf (f
, "\nFunction parameters:\n");
2184 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2185 ipa_print_node_params (f
, node
);
2188 /* Return a heap allocated vector containing formal parameters of FNDECL. */
2191 ipa_get_vector_of_formal_parms (tree fndecl
)
2193 VEC(tree
, heap
) *args
;
2197 count
= count_formal_params_1 (fndecl
);
2198 args
= VEC_alloc (tree
, heap
, count
);
2199 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= DECL_CHAIN (parm
))
2200 VEC_quick_push (tree
, args
, parm
);
2205 /* Return a heap allocated vector containing types of formal parameters of
2206 function type FNTYPE. */
2208 static inline VEC(tree
, heap
) *
2209 get_vector_of_formal_parm_types (tree fntype
)
2211 VEC(tree
, heap
) *types
;
2215 for (t
= TYPE_ARG_TYPES (fntype
); t
; t
= TREE_CHAIN (t
))
2218 types
= VEC_alloc (tree
, heap
, count
);
2219 for (t
= TYPE_ARG_TYPES (fntype
); t
; t
= TREE_CHAIN (t
))
2220 VEC_quick_push (tree
, types
, TREE_VALUE (t
));
2225 /* Modify the function declaration FNDECL and its type according to the plan in
2226 ADJUSTMENTS. It also sets base fields of individual adjustments structures
2227 to reflect the actual parameters being modified which are determined by the
2228 base_index field. */
2231 ipa_modify_formal_parameters (tree fndecl
, ipa_parm_adjustment_vec adjustments
,
2232 const char *synth_parm_prefix
)
2234 VEC(tree
, heap
) *oparms
, *otypes
;
2235 tree orig_type
, new_type
= NULL
;
2236 tree old_arg_types
, t
, new_arg_types
= NULL
;
2237 tree parm
, *link
= &DECL_ARGUMENTS (fndecl
);
2238 int i
, len
= VEC_length (ipa_parm_adjustment_t
, adjustments
);
2239 tree new_reversed
= NULL
;
2240 bool care_for_types
, last_parm_void
;
2242 if (!synth_parm_prefix
)
2243 synth_parm_prefix
= "SYNTH";
2245 oparms
= ipa_get_vector_of_formal_parms (fndecl
);
2246 orig_type
= TREE_TYPE (fndecl
);
2247 old_arg_types
= TYPE_ARG_TYPES (orig_type
);
2249 /* The following test is an ugly hack, some functions simply don't have any
2250 arguments in their type. This is probably a bug but well... */
2251 care_for_types
= (old_arg_types
!= NULL_TREE
);
2254 last_parm_void
= (TREE_VALUE (tree_last (old_arg_types
))
2256 otypes
= get_vector_of_formal_parm_types (orig_type
);
2258 gcc_assert (VEC_length (tree
, oparms
) + 1 == VEC_length (tree
, otypes
));
2260 gcc_assert (VEC_length (tree
, oparms
) == VEC_length (tree
, otypes
));
2264 last_parm_void
= false;
2268 for (i
= 0; i
< len
; i
++)
2270 struct ipa_parm_adjustment
*adj
;
2273 adj
= VEC_index (ipa_parm_adjustment_t
, adjustments
, i
);
2274 parm
= VEC_index (tree
, oparms
, adj
->base_index
);
2277 if (adj
->copy_param
)
2280 new_arg_types
= tree_cons (NULL_TREE
, VEC_index (tree
, otypes
,
2284 link
= &DECL_CHAIN (parm
);
2286 else if (!adj
->remove_param
)
2292 ptype
= build_pointer_type (adj
->type
);
2297 new_arg_types
= tree_cons (NULL_TREE
, ptype
, new_arg_types
);
2299 new_parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
, NULL_TREE
,
2301 DECL_NAME (new_parm
) = create_tmp_var_name (synth_parm_prefix
);
2303 DECL_ARTIFICIAL (new_parm
) = 1;
2304 DECL_ARG_TYPE (new_parm
) = ptype
;
2305 DECL_CONTEXT (new_parm
) = fndecl
;
2306 TREE_USED (new_parm
) = 1;
2307 DECL_IGNORED_P (new_parm
) = 1;
2308 layout_decl (new_parm
, 0);
2310 add_referenced_var (new_parm
);
2311 mark_sym_for_renaming (new_parm
);
2313 adj
->reduction
= new_parm
;
2317 link
= &DECL_CHAIN (new_parm
);
2325 new_reversed
= nreverse (new_arg_types
);
2329 TREE_CHAIN (new_arg_types
) = void_list_node
;
2331 new_reversed
= void_list_node
;
2335 /* Use copy_node to preserve as much as possible from original type
2336 (debug info, attribute lists etc.)
2337 Exception is METHOD_TYPEs must have THIS argument.
2338 When we are asked to remove it, we need to build new FUNCTION_TYPE
2340 if (TREE_CODE (orig_type
) != METHOD_TYPE
2341 || (VEC_index (ipa_parm_adjustment_t
, adjustments
, 0)->copy_param
2342 && VEC_index (ipa_parm_adjustment_t
, adjustments
, 0)->base_index
== 0))
2344 new_type
= build_distinct_type_copy (orig_type
);
2345 TYPE_ARG_TYPES (new_type
) = new_reversed
;
2350 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type
),
2352 TYPE_CONTEXT (new_type
) = TYPE_CONTEXT (orig_type
);
2353 DECL_VINDEX (fndecl
) = NULL_TREE
;
2356 /* When signature changes, we need to clear builtin info. */
2357 if (DECL_BUILT_IN (fndecl
))
2359 DECL_BUILT_IN_CLASS (fndecl
) = NOT_BUILT_IN
;
2360 DECL_FUNCTION_CODE (fndecl
) = (enum built_in_function
) 0;
2363 /* This is a new type, not a copy of an old type. Need to reassociate
2364 variants. We can handle everything except the main variant lazily. */
2365 t
= TYPE_MAIN_VARIANT (orig_type
);
2368 TYPE_MAIN_VARIANT (new_type
) = t
;
2369 TYPE_NEXT_VARIANT (new_type
) = TYPE_NEXT_VARIANT (t
);
2370 TYPE_NEXT_VARIANT (t
) = new_type
;
2374 TYPE_MAIN_VARIANT (new_type
) = new_type
;
2375 TYPE_NEXT_VARIANT (new_type
) = NULL
;
2378 TREE_TYPE (fndecl
) = new_type
;
2379 DECL_VIRTUAL_P (fndecl
) = 0;
2381 VEC_free (tree
, heap
, otypes
);
2382 VEC_free (tree
, heap
, oparms
);
2385 /* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS.
2386 If this is a directly recursive call, CS must be NULL. Otherwise it must
2387 contain the corresponding call graph edge. */
2390 ipa_modify_call_arguments (struct cgraph_edge
*cs
, gimple stmt
,
2391 ipa_parm_adjustment_vec adjustments
)
2393 VEC(tree
, heap
) *vargs
;
2395 gimple_stmt_iterator gsi
;
2399 len
= VEC_length (ipa_parm_adjustment_t
, adjustments
);
2400 vargs
= VEC_alloc (tree
, heap
, len
);
2402 gsi
= gsi_for_stmt (stmt
);
2403 for (i
= 0; i
< len
; i
++)
2405 struct ipa_parm_adjustment
*adj
;
2407 adj
= VEC_index (ipa_parm_adjustment_t
, adjustments
, i
);
2409 if (adj
->copy_param
)
2411 tree arg
= gimple_call_arg (stmt
, adj
->base_index
);
2413 VEC_quick_push (tree
, vargs
, arg
);
2415 else if (!adj
->remove_param
)
2417 tree expr
, base
, off
;
2420 /* We create a new parameter out of the value of the old one, we can
2421 do the following kind of transformations:
2423 - A scalar passed by reference is converted to a scalar passed by
2424 value. (adj->by_ref is false and the type of the original
2425 actual argument is a pointer to a scalar).
2427 - A part of an aggregate is passed instead of the whole aggregate.
2428 The part can be passed either by value or by reference, this is
2429 determined by value of adj->by_ref. Moreover, the code below
2430 handles both situations when the original aggregate is passed by
2431 value (its type is not a pointer) and when it is passed by
2432 reference (it is a pointer to an aggregate).
2434 When the new argument is passed by reference (adj->by_ref is true)
2435 it must be a part of an aggregate and therefore we form it by
2436 simply taking the address of a reference inside the original
2439 gcc_checking_assert (adj
->offset
% BITS_PER_UNIT
== 0);
2440 base
= gimple_call_arg (stmt
, adj
->base_index
);
2441 loc
= EXPR_LOCATION (base
);
2443 if (TREE_CODE (base
) != ADDR_EXPR
2444 && POINTER_TYPE_P (TREE_TYPE (base
)))
2445 off
= build_int_cst (adj
->alias_ptr_type
,
2446 adj
->offset
/ BITS_PER_UNIT
);
2449 HOST_WIDE_INT base_offset
;
2452 if (TREE_CODE (base
) == ADDR_EXPR
)
2453 base
= TREE_OPERAND (base
, 0);
2455 base
= get_addr_base_and_unit_offset (base
, &base_offset
);
2456 /* Aggregate arguments can have non-invariant addresses. */
2459 base
= build_fold_addr_expr (prev_base
);
2460 off
= build_int_cst (adj
->alias_ptr_type
,
2461 adj
->offset
/ BITS_PER_UNIT
);
2463 else if (TREE_CODE (base
) == MEM_REF
)
2465 off
= build_int_cst (adj
->alias_ptr_type
,
2467 + adj
->offset
/ BITS_PER_UNIT
);
2468 off
= int_const_binop (PLUS_EXPR
, TREE_OPERAND (base
, 1),
2470 base
= TREE_OPERAND (base
, 0);
2474 off
= build_int_cst (adj
->alias_ptr_type
,
2476 + adj
->offset
/ BITS_PER_UNIT
);
2477 base
= build_fold_addr_expr (base
);
2481 expr
= fold_build2_loc (loc
, MEM_REF
, adj
->type
, base
, off
);
2483 expr
= build_fold_addr_expr (expr
);
2485 expr
= force_gimple_operand_gsi (&gsi
, expr
,
2487 || is_gimple_reg_type (adj
->type
),
2488 NULL
, true, GSI_SAME_STMT
);
2489 VEC_quick_push (tree
, vargs
, expr
);
2493 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2495 fprintf (dump_file
, "replacing stmt:");
2496 print_gimple_stmt (dump_file
, gsi_stmt (gsi
), 0, 0);
2499 callee_decl
= !cs
? gimple_call_fndecl (stmt
) : cs
->callee
->decl
;
2500 new_stmt
= gimple_build_call_vec (callee_decl
, vargs
);
2501 VEC_free (tree
, heap
, vargs
);
2502 if (gimple_call_lhs (stmt
))
2503 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
2505 gimple_set_block (new_stmt
, gimple_block (stmt
));
2506 if (gimple_has_location (stmt
))
2507 gimple_set_location (new_stmt
, gimple_location (stmt
));
2508 gimple_call_copy_flags (new_stmt
, stmt
);
2509 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
2511 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2513 fprintf (dump_file
, "with stmt:");
2514 print_gimple_stmt (dump_file
, new_stmt
, 0, 0);
2515 fprintf (dump_file
, "\n");
2517 gsi_replace (&gsi
, new_stmt
, true);
2519 cgraph_set_call_stmt (cs
, new_stmt
);
2520 update_ssa (TODO_update_ssa
);
2521 free_dominance_info (CDI_DOMINATORS
);
2524 /* Return true iff BASE_INDEX is in ADJUSTMENTS more than once. */
2527 index_in_adjustments_multiple_times_p (int base_index
,
2528 ipa_parm_adjustment_vec adjustments
)
2530 int i
, len
= VEC_length (ipa_parm_adjustment_t
, adjustments
);
2533 for (i
= 0; i
< len
; i
++)
2535 struct ipa_parm_adjustment
*adj
;
2536 adj
= VEC_index (ipa_parm_adjustment_t
, adjustments
, i
);
2538 if (adj
->base_index
== base_index
)
2550 /* Return adjustments that should have the same effect on function parameters
2551 and call arguments as if they were first changed according to adjustments in
2552 INNER and then by adjustments in OUTER. */
2554 ipa_parm_adjustment_vec
2555 ipa_combine_adjustments (ipa_parm_adjustment_vec inner
,
2556 ipa_parm_adjustment_vec outer
)
2558 int i
, outlen
= VEC_length (ipa_parm_adjustment_t
, outer
);
2559 int inlen
= VEC_length (ipa_parm_adjustment_t
, inner
);
2561 ipa_parm_adjustment_vec adjustments
, tmp
;
2563 tmp
= VEC_alloc (ipa_parm_adjustment_t
, heap
, inlen
);
2564 for (i
= 0; i
< inlen
; i
++)
2566 struct ipa_parm_adjustment
*n
;
2567 n
= VEC_index (ipa_parm_adjustment_t
, inner
, i
);
2569 if (n
->remove_param
)
2572 VEC_quick_push (ipa_parm_adjustment_t
, tmp
, n
);
2575 adjustments
= VEC_alloc (ipa_parm_adjustment_t
, heap
, outlen
+ removals
);
2576 for (i
= 0; i
< outlen
; i
++)
2578 struct ipa_parm_adjustment
*r
;
2579 struct ipa_parm_adjustment
*out
= VEC_index (ipa_parm_adjustment_t
,
2581 struct ipa_parm_adjustment
*in
= VEC_index (ipa_parm_adjustment_t
, tmp
,
2584 gcc_assert (!in
->remove_param
);
2585 if (out
->remove_param
)
2587 if (!index_in_adjustments_multiple_times_p (in
->base_index
, tmp
))
2589 r
= VEC_quick_push (ipa_parm_adjustment_t
, adjustments
, NULL
);
2590 memset (r
, 0, sizeof (*r
));
2591 r
->remove_param
= true;
2596 r
= VEC_quick_push (ipa_parm_adjustment_t
, adjustments
, NULL
);
2597 memset (r
, 0, sizeof (*r
));
2598 r
->base_index
= in
->base_index
;
2599 r
->type
= out
->type
;
2601 /* FIXME: Create nonlocal value too. */
2603 if (in
->copy_param
&& out
->copy_param
)
2604 r
->copy_param
= true;
2605 else if (in
->copy_param
)
2606 r
->offset
= out
->offset
;
2607 else if (out
->copy_param
)
2608 r
->offset
= in
->offset
;
2610 r
->offset
= in
->offset
+ out
->offset
;
2613 for (i
= 0; i
< inlen
; i
++)
2615 struct ipa_parm_adjustment
*n
= VEC_index (ipa_parm_adjustment_t
,
2618 if (n
->remove_param
)
2619 VEC_quick_push (ipa_parm_adjustment_t
, adjustments
, n
);
2622 VEC_free (ipa_parm_adjustment_t
, heap
, tmp
);
2626 /* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human
2627 friendly way, assuming they are meant to be applied to FNDECL. */
2630 ipa_dump_param_adjustments (FILE *file
, ipa_parm_adjustment_vec adjustments
,
2633 int i
, len
= VEC_length (ipa_parm_adjustment_t
, adjustments
);
2635 VEC(tree
, heap
) *parms
= ipa_get_vector_of_formal_parms (fndecl
);
2637 fprintf (file
, "IPA param adjustments: ");
2638 for (i
= 0; i
< len
; i
++)
2640 struct ipa_parm_adjustment
*adj
;
2641 adj
= VEC_index (ipa_parm_adjustment_t
, adjustments
, i
);
2644 fprintf (file
, " ");
2648 fprintf (file
, "%i. base_index: %i - ", i
, adj
->base_index
);
2649 print_generic_expr (file
, VEC_index (tree
, parms
, adj
->base_index
), 0);
2652 fprintf (file
, ", base: ");
2653 print_generic_expr (file
, adj
->base
, 0);
2657 fprintf (file
, ", reduction: ");
2658 print_generic_expr (file
, adj
->reduction
, 0);
2660 if (adj
->new_ssa_base
)
2662 fprintf (file
, ", new_ssa_base: ");
2663 print_generic_expr (file
, adj
->new_ssa_base
, 0);
2666 if (adj
->copy_param
)
2667 fprintf (file
, ", copy_param");
2668 else if (adj
->remove_param
)
2669 fprintf (file
, ", remove_param");
2671 fprintf (file
, ", offset %li", (long) adj
->offset
);
2673 fprintf (file
, ", by_ref");
2674 print_node_brief (file
, ", type: ", adj
->type
, 0);
2675 fprintf (file
, "\n");
2677 VEC_free (tree
, heap
, parms
);
2680 /* Stream out jump function JUMP_FUNC to OB. */
2683 ipa_write_jump_function (struct output_block
*ob
,
2684 struct ipa_jump_func
*jump_func
)
2686 lto_output_uleb128_stream (ob
->main_stream
,
2689 switch (jump_func
->type
)
2691 case IPA_JF_UNKNOWN
:
2693 case IPA_JF_KNOWN_TYPE
:
2694 lto_output_tree (ob
, jump_func
->value
.base_binfo
, true);
2697 lto_output_tree (ob
, jump_func
->value
.constant
, true);
2699 case IPA_JF_PASS_THROUGH
:
2700 lto_output_tree (ob
, jump_func
->value
.pass_through
.operand
, true);
2701 lto_output_uleb128_stream (ob
->main_stream
,
2702 jump_func
->value
.pass_through
.formal_id
);
2703 lto_output_uleb128_stream (ob
->main_stream
,
2704 jump_func
->value
.pass_through
.operation
);
2706 case IPA_JF_ANCESTOR
:
2707 lto_output_uleb128_stream (ob
->main_stream
,
2708 jump_func
->value
.ancestor
.offset
);
2709 lto_output_tree (ob
, jump_func
->value
.ancestor
.type
, true);
2710 lto_output_uleb128_stream (ob
->main_stream
,
2711 jump_func
->value
.ancestor
.formal_id
);
2713 case IPA_JF_CONST_MEMBER_PTR
:
2714 lto_output_tree (ob
, jump_func
->value
.member_cst
.pfn
, true);
2715 lto_output_tree (ob
, jump_func
->value
.member_cst
.delta
, false);
2720 /* Read in jump function JUMP_FUNC from IB. */
2723 ipa_read_jump_function (struct lto_input_block
*ib
,
2724 struct ipa_jump_func
*jump_func
,
2725 struct data_in
*data_in
)
2727 jump_func
->type
= (enum jump_func_type
) lto_input_uleb128 (ib
);
2729 switch (jump_func
->type
)
2731 case IPA_JF_UNKNOWN
:
2733 case IPA_JF_KNOWN_TYPE
:
2734 jump_func
->value
.base_binfo
= lto_input_tree (ib
, data_in
);
2737 jump_func
->value
.constant
= lto_input_tree (ib
, data_in
);
2739 case IPA_JF_PASS_THROUGH
:
2740 jump_func
->value
.pass_through
.operand
= lto_input_tree (ib
, data_in
);
2741 jump_func
->value
.pass_through
.formal_id
= lto_input_uleb128 (ib
);
2742 jump_func
->value
.pass_through
.operation
= (enum tree_code
) lto_input_uleb128 (ib
);
2744 case IPA_JF_ANCESTOR
:
2745 jump_func
->value
.ancestor
.offset
= lto_input_uleb128 (ib
);
2746 jump_func
->value
.ancestor
.type
= lto_input_tree (ib
, data_in
);
2747 jump_func
->value
.ancestor
.formal_id
= lto_input_uleb128 (ib
);
2749 case IPA_JF_CONST_MEMBER_PTR
:
2750 jump_func
->value
.member_cst
.pfn
= lto_input_tree (ib
, data_in
);
2751 jump_func
->value
.member_cst
.delta
= lto_input_tree (ib
, data_in
);
2756 /* Stream out parts of cgraph_indirect_call_info corresponding to CS that are
2757 relevant to indirect inlining to OB. */
2760 ipa_write_indirect_edge_info (struct output_block
*ob
,
2761 struct cgraph_edge
*cs
)
2763 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
2764 struct bitpack_d bp
;
2766 lto_output_sleb128_stream (ob
->main_stream
, ii
->param_index
);
2767 lto_output_sleb128_stream (ob
->main_stream
, ii
->anc_offset
);
2768 bp
= bitpack_create (ob
->main_stream
);
2769 bp_pack_value (&bp
, ii
->polymorphic
, 1);
2770 lto_output_bitpack (&bp
);
2772 if (ii
->polymorphic
)
2774 lto_output_sleb128_stream (ob
->main_stream
, ii
->otr_token
);
2775 lto_output_tree (ob
, ii
->otr_type
, true);
2779 /* Read in parts of cgraph_indirect_call_info corresponding to CS that are
2780 relevant to indirect inlining from IB. */
2783 ipa_read_indirect_edge_info (struct lto_input_block
*ib
,
2784 struct data_in
*data_in ATTRIBUTE_UNUSED
,
2785 struct cgraph_edge
*cs
)
2787 struct cgraph_indirect_call_info
*ii
= cs
->indirect_info
;
2788 struct bitpack_d bp
;
2790 ii
->param_index
= (int) lto_input_sleb128 (ib
);
2791 ii
->anc_offset
= (HOST_WIDE_INT
) lto_input_sleb128 (ib
);
2792 bp
= lto_input_bitpack (ib
);
2793 ii
->polymorphic
= bp_unpack_value (&bp
, 1);
2794 if (ii
->polymorphic
)
2796 ii
->otr_token
= (HOST_WIDE_INT
) lto_input_sleb128 (ib
);
2797 ii
->otr_type
= lto_input_tree (ib
, data_in
);
2801 /* Stream out NODE info to OB. */
2804 ipa_write_node_info (struct output_block
*ob
, struct cgraph_node
*node
)
2807 lto_cgraph_encoder_t encoder
;
2808 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
2810 struct cgraph_edge
*e
;
2811 struct bitpack_d bp
;
2813 encoder
= ob
->decl_state
->cgraph_node_encoder
;
2814 node_ref
= lto_cgraph_encoder_encode (encoder
, node
);
2815 lto_output_uleb128_stream (ob
->main_stream
, node_ref
);
2817 bp
= bitpack_create (ob
->main_stream
);
2818 bp_pack_value (&bp
, info
->called_with_var_arguments
, 1);
2819 gcc_assert (info
->uses_analysis_done
2820 || ipa_get_param_count (info
) == 0);
2821 gcc_assert (!info
->node_enqueued
);
2822 gcc_assert (!info
->ipcp_orig_node
);
2823 for (j
= 0; j
< ipa_get_param_count (info
); j
++)
2824 bp_pack_value (&bp
, info
->params
[j
].used
, 1);
2825 lto_output_bitpack (&bp
);
2826 for (e
= node
->callees
; e
; e
= e
->next_callee
)
2828 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
2830 lto_output_uleb128_stream (ob
->main_stream
,
2831 ipa_get_cs_argument_count (args
));
2832 for (j
= 0; j
< ipa_get_cs_argument_count (args
); j
++)
2833 ipa_write_jump_function (ob
, ipa_get_ith_jump_func (args
, j
));
2835 for (e
= node
->indirect_calls
; e
; e
= e
->next_callee
)
2837 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
2839 lto_output_uleb128_stream (ob
->main_stream
,
2840 ipa_get_cs_argument_count (args
));
2841 for (j
= 0; j
< ipa_get_cs_argument_count (args
); j
++)
2842 ipa_write_jump_function (ob
, ipa_get_ith_jump_func (args
, j
));
2843 ipa_write_indirect_edge_info (ob
, e
);
2847 /* Stream in NODE info from IB. */
2850 ipa_read_node_info (struct lto_input_block
*ib
, struct cgraph_node
*node
,
2851 struct data_in
*data_in
)
2853 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
2855 struct cgraph_edge
*e
;
2856 struct bitpack_d bp
;
2858 ipa_initialize_node_params (node
);
2860 bp
= lto_input_bitpack (ib
);
2861 info
->called_with_var_arguments
= bp_unpack_value (&bp
, 1);
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
= create_output_block (LTO_section_jump_functions
);
2905 unsigned int count
= 0;
2906 cgraph_node_set_iterator csi
;
2908 ob
->cgraph_node
= NULL
;
2910 for (csi
= csi_start (set
); !csi_end_p (csi
); csi_next (&csi
))
2912 node
= csi_node (csi
);
2913 if (cgraph_function_with_gimple_body_p (node
)
2914 && IPA_NODE_REF (node
) != NULL
)
2918 lto_output_uleb128_stream (ob
->main_stream
, count
);
2920 /* Process all of the functions. */
2921 for (csi
= csi_start (set
); !csi_end_p (csi
); csi_next (&csi
))
2923 node
= csi_node (csi
);
2924 if (cgraph_function_with_gimple_body_p (node
)
2925 && IPA_NODE_REF (node
) != NULL
)
2926 ipa_write_node_info (ob
, node
);
2928 lto_output_1_stream (ob
->main_stream
, 0);
2929 produce_asm (ob
, NULL
);
2930 destroy_output_block (ob
);
2933 /* Read section in file FILE_DATA of length LEN with data DATA. */
2936 ipa_prop_read_section (struct lto_file_decl_data
*file_data
, const char *data
,
2939 const struct lto_function_header
*header
=
2940 (const struct lto_function_header
*) data
;
2941 const int32_t cfg_offset
= sizeof (struct lto_function_header
);
2942 const int32_t main_offset
= cfg_offset
+ header
->cfg_size
;
2943 const int32_t string_offset
= main_offset
+ header
->main_size
;
2944 struct data_in
*data_in
;
2945 struct lto_input_block ib_main
;
2949 LTO_INIT_INPUT_BLOCK (ib_main
, (const char *) data
+ main_offset
, 0,
2953 lto_data_in_create (file_data
, (const char *) data
+ string_offset
,
2954 header
->string_size
, NULL
);
2955 count
= lto_input_uleb128 (&ib_main
);
2957 for (i
= 0; i
< count
; i
++)
2960 struct cgraph_node
*node
;
2961 lto_cgraph_encoder_t encoder
;
2963 index
= lto_input_uleb128 (&ib_main
);
2964 encoder
= file_data
->cgraph_node_encoder
;
2965 node
= lto_cgraph_encoder_deref (encoder
, index
);
2966 gcc_assert (node
->analyzed
);
2967 ipa_read_node_info (&ib_main
, node
, data_in
);
2969 lto_free_section_data (file_data
, LTO_section_jump_functions
, NULL
, data
,
2971 lto_data_in_delete (data_in
);
2974 /* Read ipcp jump functions. */
2977 ipa_prop_read_jump_functions (void)
2979 struct lto_file_decl_data
**file_data_vec
= lto_get_file_decl_data ();
2980 struct lto_file_decl_data
*file_data
;
2983 ipa_check_create_node_params ();
2984 ipa_check_create_edge_args ();
2985 ipa_register_cgraph_hooks ();
2987 while ((file_data
= file_data_vec
[j
++]))
2990 const char *data
= lto_get_section_data (file_data
, LTO_section_jump_functions
, NULL
, &len
);
2993 ipa_prop_read_section (file_data
, data
, len
);
2997 /* After merging units, we can get mismatch in argument counts.
2998 Also decl merging might've rendered parameter lists obsolete.
2999 Also compute called_with_variable_arg info. */
3002 ipa_update_after_lto_read (void)
3004 struct cgraph_node
*node
;
3005 struct cgraph_edge
*cs
;
3007 ipa_check_create_node_params ();
3008 ipa_check_create_edge_args ();
3010 for (node
= cgraph_nodes
; node
; node
= node
->next
)
3012 ipa_initialize_node_params (node
);
3014 for (node
= cgraph_nodes
; node
; node
= node
->next
)
3016 for (cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
3018 if (ipa_get_cs_argument_count (IPA_EDGE_REF (cs
))
3019 != ipa_get_param_count (IPA_NODE_REF (cs
->callee
)))
3020 ipa_set_called_with_variable_arg (IPA_NODE_REF (cs
->callee
));
3024 /* Given the jump function JFUNC, compute the lattice LAT that describes the
3025 value coming down the callsite. INFO describes the caller node so that
3026 pass-through jump functions can be evaluated. */
3029 ipa_lattice_from_jfunc (struct ipa_node_params
*info
, struct ipcp_lattice
*lat
,
3030 struct ipa_jump_func
*jfunc
)
3032 if (jfunc
->type
== IPA_JF_CONST
)
3034 lat
->type
= IPA_CONST_VALUE
;
3035 lat
->constant
= jfunc
->value
.constant
;
3037 else if (jfunc
->type
== IPA_JF_PASS_THROUGH
)
3039 struct ipcp_lattice
*caller_lat
;
3042 caller_lat
= ipa_get_lattice (info
, jfunc
->value
.pass_through
.formal_id
);
3043 lat
->type
= caller_lat
->type
;
3044 if (caller_lat
->type
!= IPA_CONST_VALUE
)
3046 cst
= caller_lat
->constant
;
3048 if (jfunc
->value
.pass_through
.operation
!= NOP_EXPR
)
3051 if (TREE_CODE_CLASS (jfunc
->value
.pass_through
.operation
)
3053 restype
= boolean_type_node
;
3055 restype
= TREE_TYPE (cst
);
3056 cst
= fold_binary (jfunc
->value
.pass_through
.operation
,
3057 restype
, cst
, jfunc
->value
.pass_through
.operand
);
3059 if (!cst
|| !is_gimple_ip_invariant (cst
))
3060 lat
->type
= IPA_BOTTOM
;
3061 lat
->constant
= cst
;
3063 else if (jfunc
->type
== IPA_JF_ANCESTOR
)
3065 struct ipcp_lattice
*caller_lat
;
3068 caller_lat
= ipa_get_lattice (info
, jfunc
->value
.ancestor
.formal_id
);
3069 lat
->type
= caller_lat
->type
;
3070 if (caller_lat
->type
!= IPA_CONST_VALUE
)
3072 if (TREE_CODE (caller_lat
->constant
) != ADDR_EXPR
)
3074 /* This can happen when the constant is a NULL pointer. */
3075 lat
->type
= IPA_BOTTOM
;
3078 t
= TREE_OPERAND (caller_lat
->constant
, 0);
3079 t
= build_ref_for_offset (EXPR_LOCATION (t
), t
,
3080 jfunc
->value
.ancestor
.offset
,
3081 jfunc
->value
.ancestor
.type
, NULL
, false);
3082 lat
->constant
= build_fold_addr_expr (t
);
3085 lat
->type
= IPA_BOTTOM
;
3088 /* Determine whether JFUNC evaluates to a constant and if so, return it.
3089 Otherwise return NULL. INFO describes the caller node so that pass-through
3090 jump functions can be evaluated. */
3093 ipa_cst_from_jfunc (struct ipa_node_params
*info
, struct ipa_jump_func
*jfunc
)
3095 struct ipcp_lattice lat
;
3097 ipa_lattice_from_jfunc (info
, &lat
, jfunc
);
3098 if (lat
.type
== IPA_CONST_VALUE
)
3099 return lat
.constant
;