1 /* Interprocedural analyses.
2 Copyright (C) 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
24 #include "langhooks.h"
29 #include "tree-flow.h"
30 #include "tree-pass.h"
31 #include "tree-inline.h"
35 #include "diagnostic.h"
37 /* Vector where the parameter infos are actually stored. */
38 VEC (ipa_node_params_t
, heap
) *ipa_node_params_vector
;
39 /* Vector where the parameter infos are actually stored. */
40 VEC (ipa_edge_args_t
, heap
) *ipa_edge_args_vector
;
42 /* Holders of ipa cgraph hooks: */
43 static struct cgraph_edge_hook_list
*edge_removal_hook_holder
;
44 static struct cgraph_node_hook_list
*node_removal_hook_holder
;
45 static struct cgraph_2edge_hook_list
*edge_duplication_hook_holder
;
46 static struct cgraph_2node_hook_list
*node_duplication_hook_holder
;
48 /* Add cgraph NODE described by INFO to the worklist WL regardless of whether
49 it is in one or not. It should almost never be used directly, as opposed to
50 ipa_push_func_to_list. */
53 ipa_push_func_to_list_1 (struct ipa_func_list
**wl
,
54 struct cgraph_node
*node
,
55 struct ipa_node_params
*info
)
57 struct ipa_func_list
*temp
;
59 info
->node_enqueued
= 1;
60 temp
= XCNEW (struct ipa_func_list
);
66 /* Initialize worklist to contain all functions. */
68 struct ipa_func_list
*
69 ipa_init_func_list (void)
71 struct cgraph_node
*node
;
72 struct ipa_func_list
* wl
;
75 for (node
= cgraph_nodes
; node
; node
= node
->next
)
78 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
79 /* Unreachable nodes should have been eliminated before ipcp and
81 gcc_assert (node
->needed
|| node
->reachable
);
82 ipa_push_func_to_list_1 (&wl
, node
, info
);
88 /* Remove a function from the worklist WL and return it. */
91 ipa_pop_func_from_list (struct ipa_func_list
**wl
)
93 struct ipa_node_params
*info
;
94 struct ipa_func_list
*first
;
95 struct cgraph_node
*node
;
102 info
= IPA_NODE_REF (node
);
103 info
->node_enqueued
= 0;
107 /* Return index of the formal whose tree is PTREE in function which corresponds
111 ipa_get_param_decl_index (struct ipa_node_params
*info
, tree ptree
)
115 count
= ipa_get_param_count (info
);
116 for (i
= 0; i
< count
; i
++)
117 if (ipa_get_param(info
, i
) == ptree
)
123 /* Populate the param_decl field in parameter descriptors of INFO that
124 corresponds to NODE. */
127 ipa_populate_param_decls (struct cgraph_node
*node
,
128 struct ipa_node_params
*info
)
136 fnargs
= DECL_ARGUMENTS (fndecl
);
138 for (parm
= fnargs
; parm
; parm
= TREE_CHAIN (parm
))
140 info
->params
[param_num
].decl
= parm
;
145 /* Return how many formal parameters FNDECL has. */
148 count_formal_params_1 (tree fndecl
)
153 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= TREE_CHAIN (parm
))
159 /* Count number of formal parameters in NOTE. Store the result to the
160 appropriate field of INFO. */
163 ipa_count_formal_params (struct cgraph_node
*node
,
164 struct ipa_node_params
*info
)
168 param_num
= count_formal_params_1 (node
->decl
);
169 ipa_set_param_count (info
, param_num
);
172 /* Initialize the ipa_node_params structure associated with NODE by counting
173 the function parameters, creating the descriptors and populating their
177 ipa_initialize_node_params (struct cgraph_node
*node
)
179 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
183 ipa_count_formal_params (node
, info
);
184 info
->params
= XCNEWVEC (struct ipa_param_descriptor
,
185 ipa_get_param_count (info
));
186 ipa_populate_param_decls (node
, info
);
190 /* Callback of walk_stmt_load_store_addr_ops for the visit_store and visit_addr
191 parameters. If OP is a parameter declaration, mark it as modified in the
192 info structure passed in DATA. */
195 visit_store_addr_for_mod_analysis (gimple stmt ATTRIBUTE_UNUSED
,
198 struct ipa_node_params
*info
= (struct ipa_node_params
*) data
;
200 if (TREE_CODE (op
) == PARM_DECL
)
202 int index
= ipa_get_param_decl_index (info
, op
);
203 gcc_assert (index
>= 0);
204 info
->params
[index
].modified
= true;
210 /* Compute which formal parameters of function associated with NODE are locally
211 modified or their address is taken. Note that this does not apply on
212 parameters with SSA names but those can and should be analyzed
216 ipa_detect_param_modifications (struct cgraph_node
*node
)
218 tree decl
= node
->decl
;
220 struct function
*func
;
221 gimple_stmt_iterator gsi
;
222 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
224 if (ipa_get_param_count (info
) == 0 || info
->modification_analysis_done
)
227 func
= DECL_STRUCT_FUNCTION (decl
);
228 FOR_EACH_BB_FN (bb
, func
)
229 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
230 walk_stmt_load_store_addr_ops (gsi_stmt (gsi
), info
, NULL
,
231 visit_store_addr_for_mod_analysis
,
232 visit_store_addr_for_mod_analysis
);
234 info
->modification_analysis_done
= 1;
237 /* Count number of arguments callsite CS has and store it in
238 ipa_edge_args structure corresponding to this callsite. */
241 ipa_count_arguments (struct cgraph_edge
*cs
)
246 stmt
= cs
->call_stmt
;
247 gcc_assert (is_gimple_call (stmt
));
248 arg_num
= gimple_call_num_args (stmt
);
249 if (VEC_length (ipa_edge_args_t
, ipa_edge_args_vector
)
250 <= (unsigned) cgraph_edge_max_uid
)
251 VEC_safe_grow_cleared (ipa_edge_args_t
, heap
,
252 ipa_edge_args_vector
, cgraph_edge_max_uid
+ 1);
253 ipa_set_cs_argument_count (IPA_EDGE_REF (cs
), arg_num
);
256 /* Print the jump functions of all arguments on all call graph edges going from
260 ipa_print_node_jump_functions (FILE *f
, struct cgraph_node
*node
)
263 struct cgraph_edge
*cs
;
264 struct ipa_jump_func
*jump_func
;
265 enum jump_func_type type
;
267 fprintf (f
, " Jump functions of caller %s:\n", cgraph_node_name (node
));
268 for (cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
270 if (!ipa_edge_args_info_available_for_edge_p (cs
))
273 fprintf (f
, " callsite %s ", cgraph_node_name (node
));
274 fprintf (f
, "-> %s :: \n", cgraph_node_name (cs
->callee
));
276 count
= ipa_get_cs_argument_count (IPA_EDGE_REF (cs
));
277 for (i
= 0; i
< count
; i
++)
279 jump_func
= ipa_get_ith_jump_func (IPA_EDGE_REF (cs
), i
);
280 type
= jump_func
->type
;
282 fprintf (f
, " param %d: ", i
);
283 if (type
== IPA_JF_UNKNOWN
)
284 fprintf (f
, "UNKNOWN\n");
285 else if (type
== IPA_JF_CONST
)
287 tree val
= jump_func
->value
.constant
;
288 fprintf (f
, "CONST: ");
289 print_generic_expr (f
, val
, 0);
292 else if (type
== IPA_JF_CONST_MEMBER_PTR
)
294 fprintf (f
, "CONST MEMBER PTR: ");
295 print_generic_expr (f
, jump_func
->value
.member_cst
.pfn
, 0);
297 print_generic_expr (f
, jump_func
->value
.member_cst
.delta
, 0);
300 else if (type
== IPA_JF_PASS_THROUGH
)
302 fprintf (f
, "PASS THROUGH: ");
303 fprintf (f
, "%d, op %s ",
304 jump_func
->value
.pass_through
.formal_id
,
306 jump_func
->value
.pass_through
.operation
]);
307 if (jump_func
->value
.pass_through
.operation
!= NOP_EXPR
)
308 print_generic_expr (dump_file
,
309 jump_func
->value
.pass_through
.operand
, 0);
310 fprintf (dump_file
, "\n");
312 else if (type
== IPA_JF_ANCESTOR
)
314 fprintf (f
, "ANCESTOR: ");
315 fprintf (f
, "%d, offset "HOST_WIDE_INT_PRINT_DEC
"\n",
316 jump_func
->value
.ancestor
.formal_id
,
317 jump_func
->value
.ancestor
.offset
);
323 /* Print ipa_jump_func data structures of all nodes in the call graph to F. */
326 ipa_print_all_jump_functions (FILE *f
)
328 struct cgraph_node
*node
;
330 fprintf (f
, "\nJump functions:\n");
331 for (node
= cgraph_nodes
; node
; node
= node
->next
)
333 ipa_print_node_jump_functions (f
, node
);
337 /* Determine whether passing ssa name NAME constitutes a polynomial
338 pass-through function or getting an address of an acestor and if so, write
339 such a jump function to JFUNC. INFO describes the caller. */
342 compute_complex_pass_through (struct ipa_node_params
*info
,
343 struct ipa_jump_func
*jfunc
,
346 HOST_WIDE_INT offset
, size
, max_size
;
349 gimple stmt
= SSA_NAME_DEF_STMT (name
);
351 if (!is_gimple_assign (stmt
))
353 op1
= gimple_assign_rhs1 (stmt
);
354 op2
= gimple_assign_rhs2 (stmt
);
358 if (TREE_CODE (op1
) != SSA_NAME
359 || !SSA_NAME_IS_DEFAULT_DEF (op1
)
360 || !is_gimple_ip_invariant (op2
))
363 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (op1
));
366 jfunc
->type
= IPA_JF_PASS_THROUGH
;
367 jfunc
->value
.pass_through
.formal_id
= index
;
368 jfunc
->value
.pass_through
.operation
= gimple_assign_rhs_code (stmt
);
369 jfunc
->value
.pass_through
.operand
= op2
;
374 if (TREE_CODE (op1
) != ADDR_EXPR
)
376 op1
= TREE_OPERAND (op1
, 0);
377 type
= TREE_TYPE (op1
);
379 op1
= get_ref_base_and_extent (op1
, &offset
, &size
, &max_size
);
380 if (TREE_CODE (op1
) != INDIRECT_REF
381 /* If this is a varying address, punt. */
385 op1
= TREE_OPERAND (op1
, 0);
386 if (TREE_CODE (op1
) != SSA_NAME
387 || !SSA_NAME_IS_DEFAULT_DEF (op1
))
390 index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (op1
));
393 jfunc
->type
= IPA_JF_ANCESTOR
;
394 jfunc
->value
.ancestor
.formal_id
= index
;
395 jfunc
->value
.ancestor
.offset
= offset
;
396 jfunc
->value
.ancestor
.type
= type
;
401 /* Determine the jump functions of scalar arguments. Scalar means SSA names
402 and constants of a number of selected types. INFO is the ipa_node_params
403 structure associated with the caller, FUNCTIONS is a pointer to an array of
404 jump function structures associated with CALL which is the call statement
408 compute_scalar_jump_functions (struct ipa_node_params
*info
,
409 struct ipa_jump_func
*functions
,
415 for (num
= 0; num
< gimple_call_num_args (call
); num
++)
417 arg
= gimple_call_arg (call
, num
);
419 if (is_gimple_ip_invariant (arg
))
421 functions
[num
].type
= IPA_JF_CONST
;
422 functions
[num
].value
.constant
= arg
;
424 else if (TREE_CODE (arg
) == SSA_NAME
)
426 if (SSA_NAME_IS_DEFAULT_DEF (arg
))
428 int index
= ipa_get_param_decl_index (info
, SSA_NAME_VAR (arg
));
432 functions
[num
].type
= IPA_JF_PASS_THROUGH
;
433 functions
[num
].value
.pass_through
.formal_id
= index
;
434 functions
[num
].value
.pass_through
.operation
= NOP_EXPR
;
438 compute_complex_pass_through (info
, &functions
[num
], arg
);
443 /* Inspect the given TYPE and return true iff it has the same structure (the
444 same number of fields of the same types) as a C++ member pointer. If
445 METHOD_PTR and DELTA are non-NULL, store the trees representing the
446 corresponding fields there. */
449 type_like_member_ptr_p (tree type
, tree
*method_ptr
, tree
*delta
)
453 if (TREE_CODE (type
) != RECORD_TYPE
)
456 fld
= TYPE_FIELDS (type
);
457 if (!fld
|| !POINTER_TYPE_P (TREE_TYPE (fld
))
458 || TREE_CODE (TREE_TYPE (TREE_TYPE (fld
))) != METHOD_TYPE
)
464 fld
= TREE_CHAIN (fld
);
465 if (!fld
|| INTEGRAL_TYPE_P (fld
))
470 if (TREE_CHAIN (fld
))
476 /* Go through arguments of the CALL and for every one that looks like a member
477 pointer, check whether it can be safely declared pass-through and if so,
478 mark that to the corresponding item of jump FUNCTIONS. Return true iff
479 there are non-pass-through member pointers within the arguments. INFO
480 describes formal parameters of the caller. */
483 compute_pass_through_member_ptrs (struct ipa_node_params
*info
,
484 struct ipa_jump_func
*functions
,
487 bool undecided_members
= false;
491 for (num
= 0; num
< gimple_call_num_args (call
); num
++)
493 arg
= gimple_call_arg (call
, num
);
495 if (type_like_member_ptr_p (TREE_TYPE (arg
), NULL
, NULL
))
497 if (TREE_CODE (arg
) == PARM_DECL
)
499 int index
= ipa_get_param_decl_index (info
, arg
);
501 gcc_assert (index
>=0);
502 if (!ipa_is_param_modified (info
, index
))
504 functions
[num
].type
= IPA_JF_PASS_THROUGH
;
505 functions
[num
].value
.pass_through
.formal_id
= index
;
506 functions
[num
].value
.pass_through
.operation
= NOP_EXPR
;
509 undecided_members
= true;
512 undecided_members
= true;
516 return undecided_members
;
519 /* Simple function filling in a member pointer constant jump function (with PFN
520 and DELTA as the constant value) into JFUNC. */
523 fill_member_ptr_cst_jump_function (struct ipa_jump_func
*jfunc
,
524 tree pfn
, tree delta
)
526 jfunc
->type
= IPA_JF_CONST_MEMBER_PTR
;
527 jfunc
->value
.member_cst
.pfn
= pfn
;
528 jfunc
->value
.member_cst
.delta
= delta
;
531 /* If RHS is an SSA_NAMe and it is defined by a simple copy assign statement,
532 return the rhs of its defining statement. */
535 get_ssa_def_if_simple_copy (tree rhs
)
537 while (TREE_CODE (rhs
) == SSA_NAME
&& !SSA_NAME_IS_DEFAULT_DEF (rhs
))
539 gimple def_stmt
= SSA_NAME_DEF_STMT (rhs
);
541 if (gimple_assign_single_p (def_stmt
))
542 rhs
= gimple_assign_rhs1 (def_stmt
);
549 /* Traverse statements from CALL backwards, scanning whether the argument ARG
550 which is a member pointer is filled in with constant values. If it is, fill
551 the jump function JFUNC in appropriately. METHOD_FIELD and DELTA_FIELD are
552 fields of the record type of the member pointer. To give an example, we
553 look for a pattern looking like the following:
555 D.2515.__pfn ={v} printStuff;
556 D.2515.__delta ={v} 0;
557 i_1 = doprinting (D.2515); */
560 determine_cst_member_ptr (gimple call
, tree arg
, tree method_field
,
561 tree delta_field
, struct ipa_jump_func
*jfunc
)
563 gimple_stmt_iterator gsi
;
564 tree method
= NULL_TREE
;
565 tree delta
= NULL_TREE
;
567 gsi
= gsi_for_stmt (call
);
570 for (; !gsi_end_p (gsi
); gsi_prev (&gsi
))
572 gimple stmt
= gsi_stmt (gsi
);
575 if (!gimple_assign_single_p (stmt
))
578 lhs
= gimple_assign_lhs (stmt
);
579 rhs
= gimple_assign_rhs1 (stmt
);
581 if (TREE_CODE (lhs
) != COMPONENT_REF
582 || TREE_OPERAND (lhs
, 0) != arg
)
585 fld
= TREE_OPERAND (lhs
, 1);
586 if (!method
&& fld
== method_field
)
588 rhs
= get_ssa_def_if_simple_copy (rhs
);
589 if (TREE_CODE (rhs
) == ADDR_EXPR
590 && TREE_CODE (TREE_OPERAND (rhs
, 0)) == FUNCTION_DECL
591 && TREE_CODE (TREE_TYPE (TREE_OPERAND (rhs
, 0))) == METHOD_TYPE
)
593 method
= TREE_OPERAND (rhs
, 0);
596 fill_member_ptr_cst_jump_function (jfunc
, rhs
, delta
);
604 if (!delta
&& fld
== delta_field
)
606 rhs
= get_ssa_def_if_simple_copy (rhs
);
607 if (TREE_CODE (rhs
) == INTEGER_CST
)
612 fill_member_ptr_cst_jump_function (jfunc
, rhs
, delta
);
624 /* Go through the arguments of the CALL and for every member pointer within
625 tries determine whether it is a constant. If it is, create a corresponding
626 constant jump function in FUNCTIONS which is an array of jump functions
627 associated with the call. */
630 compute_cst_member_ptr_arguments (struct ipa_jump_func
*functions
,
634 tree arg
, method_field
, delta_field
;
636 for (num
= 0; num
< gimple_call_num_args (call
); num
++)
638 arg
= gimple_call_arg (call
, num
);
640 if (functions
[num
].type
== IPA_JF_UNKNOWN
641 && type_like_member_ptr_p (TREE_TYPE (arg
), &method_field
,
643 determine_cst_member_ptr (call
, arg
, method_field
, delta_field
,
648 /* Compute jump function for all arguments of callsite CS and insert the
649 information in the jump_functions array in the ipa_edge_args corresponding
653 ipa_compute_jump_functions (struct cgraph_edge
*cs
)
655 struct ipa_node_params
*info
= IPA_NODE_REF (cs
->caller
);
656 struct ipa_edge_args
*arguments
= IPA_EDGE_REF (cs
);
659 if (ipa_get_cs_argument_count (arguments
) == 0 || arguments
->jump_functions
)
661 arguments
->jump_functions
= XCNEWVEC (struct ipa_jump_func
,
662 ipa_get_cs_argument_count (arguments
));
664 call
= cs
->call_stmt
;
665 gcc_assert (is_gimple_call (call
));
667 /* We will deal with constants and SSA scalars first: */
668 compute_scalar_jump_functions (info
, arguments
->jump_functions
, call
);
670 /* Let's check whether there are any potential member pointers and if so,
671 whether we can determine their functions as pass_through. */
672 if (!compute_pass_through_member_ptrs (info
, arguments
->jump_functions
, call
))
675 /* Finally, let's check whether we actually pass a new constant member
677 compute_cst_member_ptr_arguments (arguments
->jump_functions
, call
);
680 /* If RHS looks like a rhs of a statement loading pfn from a member
681 pointer formal parameter, return the parameter, otherwise return
682 NULL. If USE_DELTA, then we look for a use of the delta field
683 rather than the pfn. */
686 ipa_get_member_ptr_load_param (tree rhs
, bool use_delta
)
692 if (TREE_CODE (rhs
) != COMPONENT_REF
)
695 rec
= TREE_OPERAND (rhs
, 0);
696 if (TREE_CODE (rec
) != PARM_DECL
697 || !type_like_member_ptr_p (TREE_TYPE (rec
), &ptr_field
, &delta_field
))
700 fld
= TREE_OPERAND (rhs
, 1);
701 if (use_delta
? (fld
== delta_field
) : (fld
== ptr_field
))
707 /* If STMT looks like a statement loading a value from a member pointer formal
708 parameter, this function returns that parameter. */
711 ipa_get_stmt_member_ptr_load_param (gimple stmt
, bool use_delta
)
715 if (!gimple_assign_single_p (stmt
))
718 rhs
= gimple_assign_rhs1 (stmt
);
719 return ipa_get_member_ptr_load_param (rhs
, use_delta
);
722 /* Returns true iff T is an SSA_NAME defined by a statement. */
725 ipa_is_ssa_with_stmt_def (tree t
)
727 if (TREE_CODE (t
) == SSA_NAME
728 && !SSA_NAME_IS_DEFAULT_DEF (t
))
734 /* Creates a new note describing a call to a parameter number FORMAL_ID and
735 attaches it to the linked list of INFO. It also sets the called flag of the
736 parameter. STMT is the corresponding call statement. */
739 ipa_note_param_call (struct ipa_node_params
*info
, int formal_id
,
742 struct ipa_param_call_note
*note
;
743 basic_block bb
= gimple_bb (stmt
);
745 info
->params
[formal_id
].called
= 1;
747 note
= XCNEW (struct ipa_param_call_note
);
748 note
->formal_id
= formal_id
;
750 note
->count
= bb
->count
;
751 note
->frequency
= compute_call_stmt_bb_frequency (current_function_decl
, bb
);
753 note
->next
= info
->param_calls
;
754 info
->param_calls
= note
;
759 /* Analyze the CALL and examine uses of formal parameters of the caller
760 (described by INFO). Currently it checks whether the call calls a pointer
761 that is a formal parameter and if so, the parameter is marked with the
762 called flag and a note describing the call is created. This is very simple
763 for ordinary pointers represented in SSA but not-so-nice when it comes to
764 member pointers. The ugly part of this function does nothing more than
765 tries to match the pattern of such a call. An example of such a pattern is
766 the gimple dump below, the call is on the last line:
769 f$__delta_5 = f.__delta;
770 f$__pfn_24 = f.__pfn;
771 D.2496_3 = (int) f$__pfn_24;
772 D.2497_4 = D.2496_3 & 1;
779 D.2500_7 = (unsigned int) f$__delta_5;
780 D.2501_8 = &S + D.2500_7;
781 D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8;
782 D.2503_10 = *D.2502_9;
783 D.2504_12 = f$__pfn_24 + -1;
784 D.2505_13 = (unsigned int) D.2504_12;
785 D.2506_14 = D.2503_10 + D.2505_13;
786 D.2507_15 = *D.2506_14;
787 iftmp.11_16 = (String:: *) D.2507_15;
790 # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)>
791 D.2500_19 = (unsigned int) f$__delta_5;
792 D.2508_20 = &S + D.2500_19;
793 D.2493_21 = iftmp.11_1 (D.2508_20, 4);
795 Such patterns are results of simple calls to a member pointer:
797 int doprinting (int (MyString::* f)(int) const)
799 MyString S ("somestring");
806 ipa_analyze_call_uses (struct ipa_node_params
*info
, gimple call
)
808 tree target
= gimple_call_fn (call
);
813 tree rec
, rec2
, cond
;
816 basic_block bb
, virt_bb
, join
;
818 if (TREE_CODE (target
) != SSA_NAME
)
821 var
= SSA_NAME_VAR (target
);
822 if (SSA_NAME_IS_DEFAULT_DEF (target
))
824 /* assuming TREE_CODE (var) == PARM_DECL */
825 index
= ipa_get_param_decl_index (info
, var
);
827 ipa_note_param_call (info
, index
, call
);
831 /* Now we need to try to match the complex pattern of calling a member
834 if (!POINTER_TYPE_P (TREE_TYPE (target
))
835 || TREE_CODE (TREE_TYPE (TREE_TYPE (target
))) != METHOD_TYPE
)
838 def
= SSA_NAME_DEF_STMT (target
);
839 if (gimple_code (def
) != GIMPLE_PHI
)
842 if (gimple_phi_num_args (def
) != 2)
845 /* First, we need to check whether one of these is a load from a member
846 pointer that is a parameter to this function. */
847 n1
= PHI_ARG_DEF (def
, 0);
848 n2
= PHI_ARG_DEF (def
, 1);
849 if (!ipa_is_ssa_with_stmt_def (n1
) || !ipa_is_ssa_with_stmt_def (n2
))
851 d1
= SSA_NAME_DEF_STMT (n1
);
852 d2
= SSA_NAME_DEF_STMT (n2
);
854 if ((rec
= ipa_get_stmt_member_ptr_load_param (d1
, false)))
856 if (ipa_get_stmt_member_ptr_load_param (d2
, false))
860 virt_bb
= gimple_bb (d2
);
862 else if ((rec
= ipa_get_stmt_member_ptr_load_param (d2
, false)))
865 virt_bb
= gimple_bb (d1
);
870 /* Second, we need to check that the basic blocks are laid out in the way
871 corresponding to the pattern. */
873 join
= gimple_bb (def
);
874 if (!single_pred_p (virt_bb
) || !single_succ_p (virt_bb
)
875 || single_pred (virt_bb
) != bb
876 || single_succ (virt_bb
) != join
)
879 /* Third, let's see that the branching is done depending on the least
880 significant bit of the pfn. */
882 branch
= last_stmt (bb
);
883 if (gimple_code (branch
) != GIMPLE_COND
)
886 if (gimple_cond_code (branch
) != NE_EXPR
887 || !integer_zerop (gimple_cond_rhs (branch
)))
890 cond
= gimple_cond_lhs (branch
);
891 if (!ipa_is_ssa_with_stmt_def (cond
))
894 def
= SSA_NAME_DEF_STMT (cond
);
895 if (!is_gimple_assign (def
)
896 || gimple_assign_rhs_code (def
) != BIT_AND_EXPR
897 || !integer_onep (gimple_assign_rhs2 (def
)))
900 cond
= gimple_assign_rhs1 (def
);
901 if (!ipa_is_ssa_with_stmt_def (cond
))
904 def
= SSA_NAME_DEF_STMT (cond
);
906 if (is_gimple_assign (def
)
907 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def
)))
909 cond
= gimple_assign_rhs1 (def
);
910 if (!ipa_is_ssa_with_stmt_def (cond
))
912 def
= SSA_NAME_DEF_STMT (cond
);
915 rec2
= ipa_get_stmt_member_ptr_load_param (def
,
916 (TARGET_PTRMEMFUNC_VBIT_LOCATION
917 == ptrmemfunc_vbit_in_delta
));
922 index
= ipa_get_param_decl_index (info
, rec
);
923 if (index
>= 0 && !ipa_is_param_modified (info
, index
))
924 ipa_note_param_call (info
, index
, call
);
929 /* Analyze the statement STMT with respect to formal parameters (described in
930 INFO) and their uses. Currently it only checks whether formal parameters
934 ipa_analyze_stmt_uses (struct ipa_node_params
*info
, gimple stmt
)
936 if (is_gimple_call (stmt
))
937 ipa_analyze_call_uses (info
, stmt
);
940 /* Scan the function body of NODE and inspect the uses of formal parameters.
941 Store the findings in various structures of the associated ipa_node_params
942 structure, such as parameter flags, notes etc. */
945 ipa_analyze_params_uses (struct cgraph_node
*node
)
947 tree decl
= node
->decl
;
949 struct function
*func
;
950 gimple_stmt_iterator gsi
;
951 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
953 if (ipa_get_param_count (info
) == 0 || info
->uses_analysis_done
)
956 func
= DECL_STRUCT_FUNCTION (decl
);
957 FOR_EACH_BB_FN (bb
, func
)
959 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
961 gimple stmt
= gsi_stmt (gsi
);
962 ipa_analyze_stmt_uses (info
, stmt
);
966 info
->uses_analysis_done
= 1;
969 /* Update the jump functions associated with call graph edge E when the call
970 graph edge CS is being inlined, assuming that E->caller is already (possibly
971 indirectly) inlined into CS->callee and that E has not been inlined.
973 We keep pass through functions only if they do not contain any operation.
974 This is sufficient for inlining and greately simplifies things. */
977 update_jump_functions_after_inlining (struct cgraph_edge
*cs
,
978 struct cgraph_edge
*e
)
980 struct ipa_edge_args
*top
= IPA_EDGE_REF (cs
);
981 struct ipa_edge_args
*args
= IPA_EDGE_REF (e
);
982 int count
= ipa_get_cs_argument_count (args
);
985 for (i
= 0; i
< count
; i
++)
987 struct ipa_jump_func
*src
, *dst
= ipa_get_ith_jump_func (args
, i
);
989 if (dst
->type
== IPA_JF_ANCESTOR
)
991 dst
->type
= IPA_JF_UNKNOWN
;
995 if (dst
->type
!= IPA_JF_PASS_THROUGH
)
998 /* We must check range due to calls with variable number of arguments and
999 we cannot combine jump functions with operations. */
1000 if (dst
->value
.pass_through
.operation
!= NOP_EXPR
1001 || (dst
->value
.pass_through
.formal_id
1002 >= ipa_get_cs_argument_count (top
)))
1004 dst
->type
= IPA_JF_UNKNOWN
;
1008 src
= ipa_get_ith_jump_func (top
, dst
->value
.pass_through
.formal_id
);
1013 /* Print out a debug message to file F that we have discovered that an indirect
1014 call described by NT is in fact a call of a known constant function described
1015 by JFUNC. NODE is the node where the call is. */
1018 print_edge_addition_message (FILE *f
, struct ipa_param_call_note
*nt
,
1019 struct ipa_jump_func
*jfunc
,
1020 struct cgraph_node
*node
)
1022 fprintf (f
, "ipa-prop: Discovered an indirect call to a known target (");
1023 if (jfunc
->type
== IPA_JF_CONST_MEMBER_PTR
)
1025 print_node_brief (f
, "", jfunc
->value
.member_cst
.pfn
, 0);
1026 print_node_brief (f
, ", ", jfunc
->value
.member_cst
.delta
, 0);
1029 print_node_brief(f
, "", jfunc
->value
.constant
, 0);
1031 fprintf (f
, ") in %s: ", cgraph_node_name (node
));
1032 print_gimple_stmt (f
, nt
->stmt
, 2, TDF_SLIM
);
1035 /* Update the param called notes associated with NODE when CS is being inlined,
1036 assuming NODE is (potentially indirectly) inlined into CS->callee.
1037 Moreover, if the callee is discovered to be constant, create a new cgraph
1038 edge for it. Newly discovered indirect edges will be added to *NEW_EDGES,
1039 unless NEW_EDGES is NULL. Return true iff a new edge(s) were created. */
1042 update_call_notes_after_inlining (struct cgraph_edge
*cs
,
1043 struct cgraph_node
*node
,
1044 VEC (cgraph_edge_p
, heap
) **new_edges
)
1046 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
1047 struct ipa_edge_args
*top
= IPA_EDGE_REF (cs
);
1048 struct ipa_param_call_note
*nt
;
1051 for (nt
= info
->param_calls
; nt
; nt
= nt
->next
)
1053 struct ipa_jump_func
*jfunc
;
1058 /* We must check range due to calls with variable number of arguments: */
1059 if (nt
->formal_id
>= ipa_get_cs_argument_count (top
))
1061 nt
->processed
= true;
1065 jfunc
= ipa_get_ith_jump_func (top
, nt
->formal_id
);
1066 if (jfunc
->type
== IPA_JF_PASS_THROUGH
1067 && jfunc
->value
.pass_through
.operation
== NOP_EXPR
)
1068 nt
->formal_id
= jfunc
->value
.pass_through
.formal_id
;
1069 else if (jfunc
->type
== IPA_JF_CONST
1070 || jfunc
->type
== IPA_JF_CONST_MEMBER_PTR
)
1072 struct cgraph_node
*callee
;
1073 struct cgraph_edge
*new_indirect_edge
;
1076 nt
->processed
= true;
1077 if (jfunc
->type
== IPA_JF_CONST_MEMBER_PTR
)
1078 decl
= jfunc
->value
.member_cst
.pfn
;
1080 decl
= jfunc
->value
.constant
;
1082 if (TREE_CODE (decl
) != ADDR_EXPR
)
1084 decl
= TREE_OPERAND (decl
, 0);
1086 if (TREE_CODE (decl
) != FUNCTION_DECL
)
1088 callee
= cgraph_node (decl
);
1089 if (!callee
|| !callee
->local
.inlinable
)
1094 print_edge_addition_message (dump_file
, nt
, jfunc
, node
);
1096 new_indirect_edge
= cgraph_create_edge (node
, callee
, nt
->stmt
,
1097 nt
->count
, nt
->frequency
,
1099 new_indirect_edge
->indirect_call
= 1;
1100 ipa_check_create_edge_args ();
1102 VEC_safe_push (cgraph_edge_p
, heap
, *new_edges
, new_indirect_edge
);
1103 top
= IPA_EDGE_REF (cs
);
1107 /* Ancestor jum functions and pass theoughs with operations should
1108 not be used on parameters that then get called. */
1109 gcc_assert (jfunc
->type
== IPA_JF_UNKNOWN
);
1110 nt
->processed
= true;
1116 /* Recursively traverse subtree of NODE (including node) made of inlined
1117 cgraph_edges when CS has been inlined and invoke
1118 update_call_notes_after_inlining on all nodes and
1119 update_jump_functions_after_inlining on all non-inlined edges that lead out
1120 of this subtree. Newly discovered indirect edges will be added to
1121 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were
1125 propagate_info_to_inlined_callees (struct cgraph_edge
*cs
,
1126 struct cgraph_node
*node
,
1127 VEC (cgraph_edge_p
, heap
) **new_edges
)
1129 struct cgraph_edge
*e
;
1132 res
= update_call_notes_after_inlining (cs
, node
, new_edges
);
1134 for (e
= node
->callees
; e
; e
= e
->next_callee
)
1135 if (!e
->inline_failed
)
1136 res
|= propagate_info_to_inlined_callees (cs
, e
->callee
, new_edges
);
1138 update_jump_functions_after_inlining (cs
, e
);
1143 /* Update jump functions and call note functions on inlining the call site CS.
1144 CS is expected to lead to a node already cloned by
1145 cgraph_clone_inline_nodes. Newly discovered indirect edges will be added to
1146 *NEW_EDGES, unless NEW_EDGES is NULL. Return true iff a new edge(s) were +
1150 ipa_propagate_indirect_call_infos (struct cgraph_edge
*cs
,
1151 VEC (cgraph_edge_p
, heap
) **new_edges
)
1153 /* Do nothing if the preparation phase has not been carried out yet
1154 (i.e. during early inlining). */
1155 if (!ipa_node_params_vector
)
1157 gcc_assert (ipa_edge_args_vector
);
1159 return propagate_info_to_inlined_callees (cs
, cs
->callee
, new_edges
);
1162 /* Frees all dynamically allocated structures that the argument info points
1166 ipa_free_edge_args_substructures (struct ipa_edge_args
*args
)
1168 if (args
->jump_functions
)
1169 free (args
->jump_functions
);
1171 memset (args
, 0, sizeof (*args
));
1174 /* Free all ipa_edge structures. */
1177 ipa_free_all_edge_args (void)
1180 struct ipa_edge_args
*args
;
1183 VEC_iterate (ipa_edge_args_t
, ipa_edge_args_vector
, i
, args
);
1185 ipa_free_edge_args_substructures (args
);
1187 VEC_free (ipa_edge_args_t
, heap
, ipa_edge_args_vector
);
1188 ipa_edge_args_vector
= NULL
;
1191 /* Frees all dynamically allocated structures that the param info points
1195 ipa_free_node_params_substructures (struct ipa_node_params
*info
)
1198 free (info
->params
);
1200 while (info
->param_calls
)
1202 struct ipa_param_call_note
*note
= info
->param_calls
;
1203 info
->param_calls
= note
->next
;
1207 memset (info
, 0, sizeof (*info
));
1210 /* Free all ipa_node_params structures. */
1213 ipa_free_all_node_params (void)
1216 struct ipa_node_params
*info
;
1219 VEC_iterate (ipa_node_params_t
, ipa_node_params_vector
, i
, info
);
1221 ipa_free_node_params_substructures (info
);
1223 VEC_free (ipa_node_params_t
, heap
, ipa_node_params_vector
);
1224 ipa_node_params_vector
= NULL
;
1227 /* Hook that is called by cgraph.c when an edge is removed. */
1230 ipa_edge_removal_hook (struct cgraph_edge
*cs
, void *data ATTRIBUTE_UNUSED
)
1232 /* During IPA-CP updating we can be called on not-yet analyze clones. */
1233 if (VEC_length (ipa_edge_args_t
, ipa_edge_args_vector
)
1234 <= (unsigned)cs
->uid
)
1236 ipa_free_edge_args_substructures (IPA_EDGE_REF (cs
));
1239 /* Hook that is called by cgraph.c when a node is removed. */
1242 ipa_node_removal_hook (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
1244 ipa_free_node_params_substructures (IPA_NODE_REF (node
));
1247 /* Helper function to duplicate an array of size N that is at SRC and store a
1248 pointer to it to DST. Nothing is done if SRC is NULL. */
1251 duplicate_array (void *src
, size_t n
)
1263 /* Hook that is called by cgraph.c when a node is duplicated. */
1266 ipa_edge_duplication_hook (struct cgraph_edge
*src
, struct cgraph_edge
*dst
,
1267 __attribute__((unused
)) void *data
)
1269 struct ipa_edge_args
*old_args
, *new_args
;
1272 ipa_check_create_edge_args ();
1274 old_args
= IPA_EDGE_REF (src
);
1275 new_args
= IPA_EDGE_REF (dst
);
1277 arg_count
= ipa_get_cs_argument_count (old_args
);
1278 ipa_set_cs_argument_count (new_args
, arg_count
);
1279 new_args
->jump_functions
= (struct ipa_jump_func
*)
1280 duplicate_array (old_args
->jump_functions
,
1281 sizeof (struct ipa_jump_func
) * arg_count
);
1284 /* Hook that is called by cgraph.c when a node is duplicated. */
1287 ipa_node_duplication_hook (struct cgraph_node
*src
, struct cgraph_node
*dst
,
1288 __attribute__((unused
)) void *data
)
1290 struct ipa_node_params
*old_info
, *new_info
;
1291 struct ipa_param_call_note
*note
;
1294 ipa_check_create_node_params ();
1295 old_info
= IPA_NODE_REF (src
);
1296 new_info
= IPA_NODE_REF (dst
);
1297 param_count
= ipa_get_param_count (old_info
);
1299 ipa_set_param_count (new_info
, param_count
);
1300 new_info
->params
= (struct ipa_param_descriptor
*)
1301 duplicate_array (old_info
->params
,
1302 sizeof (struct ipa_param_descriptor
) * param_count
);
1303 new_info
->ipcp_orig_node
= old_info
->ipcp_orig_node
;
1304 new_info
->count_scale
= old_info
->count_scale
;
1306 for (note
= old_info
->param_calls
; note
; note
= note
->next
)
1308 struct ipa_param_call_note
*nn
;
1310 nn
= (struct ipa_param_call_note
*)
1311 xcalloc (1, sizeof (struct ipa_param_call_note
));
1312 memcpy (nn
, note
, sizeof (struct ipa_param_call_note
));
1313 nn
->next
= new_info
->param_calls
;
1314 new_info
->param_calls
= nn
;
1318 /* Register our cgraph hooks if they are not already there. */
1321 ipa_register_cgraph_hooks (void)
1323 if (!edge_removal_hook_holder
)
1324 edge_removal_hook_holder
=
1325 cgraph_add_edge_removal_hook (&ipa_edge_removal_hook
, NULL
);
1326 if (!node_removal_hook_holder
)
1327 node_removal_hook_holder
=
1328 cgraph_add_node_removal_hook (&ipa_node_removal_hook
, NULL
);
1329 if (!edge_duplication_hook_holder
)
1330 edge_duplication_hook_holder
=
1331 cgraph_add_edge_duplication_hook (&ipa_edge_duplication_hook
, NULL
);
1332 if (!node_duplication_hook_holder
)
1333 node_duplication_hook_holder
=
1334 cgraph_add_node_duplication_hook (&ipa_node_duplication_hook
, NULL
);
1337 /* Unregister our cgraph hooks if they are not already there. */
1340 ipa_unregister_cgraph_hooks (void)
1342 cgraph_remove_edge_removal_hook (edge_removal_hook_holder
);
1343 edge_removal_hook_holder
= NULL
;
1344 cgraph_remove_node_removal_hook (node_removal_hook_holder
);
1345 node_removal_hook_holder
= NULL
;
1346 cgraph_remove_edge_duplication_hook (edge_duplication_hook_holder
);
1347 edge_duplication_hook_holder
= NULL
;
1348 cgraph_remove_node_duplication_hook (node_duplication_hook_holder
);
1349 node_duplication_hook_holder
= NULL
;
1352 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
1353 longer needed after ipa-cp. */
1356 free_all_ipa_structures_after_ipa_cp (void)
1358 if (!flag_indirect_inlining
)
1360 ipa_free_all_edge_args ();
1361 ipa_free_all_node_params ();
1362 ipa_unregister_cgraph_hooks ();
1366 /* Free all ipa_node_params and all ipa_edge_args structures if they are no
1367 longer needed after indirect inlining. */
1370 free_all_ipa_structures_after_iinln (void)
1372 ipa_free_all_edge_args ();
1373 ipa_free_all_node_params ();
1374 ipa_unregister_cgraph_hooks ();
1377 /* Print ipa_tree_map data structures of all functions in the
1381 ipa_print_node_params (FILE * f
, struct cgraph_node
*node
)
1385 struct ipa_node_params
*info
;
1387 if (!node
->analyzed
)
1389 info
= IPA_NODE_REF (node
);
1390 fprintf (f
, " function %s Trees :: \n", cgraph_node_name (node
));
1391 count
= ipa_get_param_count (info
);
1392 for (i
= 0; i
< count
; i
++)
1394 temp
= ipa_get_param (info
, i
);
1395 if (TREE_CODE (temp
) == PARM_DECL
)
1396 fprintf (f
, " param %d : %s", i
,
1397 (*lang_hooks
.decl_printable_name
) (temp
, 2));
1398 if (ipa_is_param_modified (info
, i
))
1399 fprintf (f
, " modified");
1400 if (ipa_is_param_called (info
, i
))
1401 fprintf (f
, " called");
1406 /* Print ipa_tree_map data structures of all functions in the
1410 ipa_print_all_params (FILE * f
)
1412 struct cgraph_node
*node
;
1414 fprintf (f
, "\nFunction parameters:\n");
1415 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1416 ipa_print_node_params (f
, node
);
1419 /* Return a heap allocated vector containing formal parameters of FNDECL. */
1422 ipa_get_vector_of_formal_parms (tree fndecl
)
1424 VEC(tree
, heap
) *args
;
1428 count
= count_formal_params_1 (fndecl
);
1429 args
= VEC_alloc (tree
, heap
, count
);
1430 for (parm
= DECL_ARGUMENTS (fndecl
); parm
; parm
= TREE_CHAIN (parm
))
1431 VEC_quick_push (tree
, args
, parm
);
1436 /* Return a heap allocated vector containing types of formal parameters of
1437 function type FNTYPE. */
1439 static inline VEC(tree
, heap
) *
1440 get_vector_of_formal_parm_types (tree fntype
)
1442 VEC(tree
, heap
) *types
;
1446 for (t
= TYPE_ARG_TYPES (fntype
); t
; t
= TREE_CHAIN (t
))
1449 types
= VEC_alloc (tree
, heap
, count
);
1450 for (t
= TYPE_ARG_TYPES (fntype
); t
; t
= TREE_CHAIN (t
))
1451 VEC_quick_push (tree
, types
, TREE_VALUE (t
));
1456 /* Modify the function declaration FNDECL and its type according to the plan in
1457 ADJUSTMENTS. It also sets base fields of individual adjustments structures
1458 to reflect the actual parameters being modified which are determined by the
1459 base_index field. */
1462 ipa_modify_formal_parameters (tree fndecl
, ipa_parm_adjustment_vec adjustments
,
1463 const char *synth_parm_prefix
)
1465 VEC(tree
, heap
) *oparms
, *otypes
;
1466 tree orig_type
, new_type
= NULL
;
1467 tree old_arg_types
, t
, new_arg_types
= NULL
;
1468 tree parm
, *link
= &DECL_ARGUMENTS (fndecl
);
1469 int i
, len
= VEC_length (ipa_parm_adjustment_t
, adjustments
);
1470 tree new_reversed
= NULL
;
1471 bool care_for_types
, last_parm_void
;
1473 if (!synth_parm_prefix
)
1474 synth_parm_prefix
= "SYNTH";
1476 oparms
= ipa_get_vector_of_formal_parms (fndecl
);
1477 orig_type
= TREE_TYPE (fndecl
);
1478 old_arg_types
= TYPE_ARG_TYPES (orig_type
);
1480 /* The following test is an ugly hack, some functions simply don't have any
1481 arguments in their type. This is probably a bug but well... */
1482 care_for_types
= (old_arg_types
!= NULL_TREE
);
1485 last_parm_void
= (TREE_VALUE (tree_last (old_arg_types
))
1487 otypes
= get_vector_of_formal_parm_types (orig_type
);
1489 gcc_assert (VEC_length (tree
, oparms
) + 1 == VEC_length (tree
, otypes
));
1491 gcc_assert (VEC_length (tree
, oparms
) == VEC_length (tree
, otypes
));
1495 last_parm_void
= false;
1499 for (i
= 0; i
< len
; i
++)
1501 struct ipa_parm_adjustment
*adj
;
1504 adj
= VEC_index (ipa_parm_adjustment_t
, adjustments
, i
);
1505 parm
= VEC_index (tree
, oparms
, adj
->base_index
);
1508 if (adj
->copy_param
)
1511 new_arg_types
= tree_cons (NULL_TREE
, VEC_index (tree
, otypes
,
1515 link
= &TREE_CHAIN (parm
);
1517 else if (!adj
->remove_param
)
1523 ptype
= build_pointer_type (adj
->type
);
1528 new_arg_types
= tree_cons (NULL_TREE
, ptype
, new_arg_types
);
1530 new_parm
= build_decl (UNKNOWN_LOCATION
, PARM_DECL
, NULL_TREE
,
1532 DECL_NAME (new_parm
) = create_tmp_var_name (synth_parm_prefix
);
1534 DECL_ARTIFICIAL (new_parm
) = 1;
1535 DECL_ARG_TYPE (new_parm
) = ptype
;
1536 DECL_CONTEXT (new_parm
) = fndecl
;
1537 TREE_USED (new_parm
) = 1;
1538 DECL_IGNORED_P (new_parm
) = 1;
1539 layout_decl (new_parm
, 0);
1541 add_referenced_var (new_parm
);
1542 mark_sym_for_renaming (new_parm
);
1544 adj
->reduction
= new_parm
;
1548 link
= &TREE_CHAIN (new_parm
);
1556 new_reversed
= nreverse (new_arg_types
);
1560 TREE_CHAIN (new_arg_types
) = void_list_node
;
1562 new_reversed
= void_list_node
;
1566 /* Use copy_node to preserve as much as possible from original type
1567 (debug info, attribute lists etc.)
1568 Exception is METHOD_TYPEs must have THIS argument.
1569 When we are asked to remove it, we need to build new FUNCTION_TYPE
1571 if (TREE_CODE (orig_type
) != METHOD_TYPE
1572 || (VEC_index (ipa_parm_adjustment_t
, adjustments
, 0)->copy_param
1573 && VEC_index (ipa_parm_adjustment_t
, adjustments
, 0)->base_index
== 0))
1575 new_type
= copy_node (orig_type
);
1576 TYPE_ARG_TYPES (new_type
) = new_reversed
;
1581 = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type
),
1583 TYPE_CONTEXT (new_type
) = TYPE_CONTEXT (orig_type
);
1584 DECL_VINDEX (fndecl
) = NULL_TREE
;
1587 /* This is a new type, not a copy of an old type. Need to reassociate
1588 variants. We can handle everything except the main variant lazily. */
1589 t
= TYPE_MAIN_VARIANT (orig_type
);
1592 TYPE_MAIN_VARIANT (new_type
) = t
;
1593 TYPE_NEXT_VARIANT (new_type
) = TYPE_NEXT_VARIANT (t
);
1594 TYPE_NEXT_VARIANT (t
) = new_type
;
1598 TYPE_MAIN_VARIANT (new_type
) = new_type
;
1599 TYPE_NEXT_VARIANT (new_type
) = NULL
;
1602 TREE_TYPE (fndecl
) = new_type
;
1604 VEC_free (tree
, heap
, otypes
);
1605 VEC_free (tree
, heap
, oparms
);
1608 /* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS.
1609 If this is a directly recursive call, CS must be NULL. Otherwise it must
1610 contain the corresponding call graph edge. */
1613 ipa_modify_call_arguments (struct cgraph_edge
*cs
, gimple stmt
,
1614 ipa_parm_adjustment_vec adjustments
)
1616 VEC(tree
, heap
) *vargs
;
1618 gimple_stmt_iterator gsi
;
1622 len
= VEC_length (ipa_parm_adjustment_t
, adjustments
);
1623 vargs
= VEC_alloc (tree
, heap
, len
);
1625 gsi
= gsi_for_stmt (stmt
);
1626 for (i
= 0; i
< len
; i
++)
1628 struct ipa_parm_adjustment
*adj
;
1630 adj
= VEC_index (ipa_parm_adjustment_t
, adjustments
, i
);
1632 if (adj
->copy_param
)
1634 tree arg
= gimple_call_arg (stmt
, adj
->base_index
);
1636 VEC_quick_push (tree
, vargs
, arg
);
1638 else if (!adj
->remove_param
)
1640 tree expr
, orig_expr
;
1641 bool allow_ptr
, repl_found
;
1643 orig_expr
= expr
= gimple_call_arg (stmt
, adj
->base_index
);
1644 if (TREE_CODE (expr
) == ADDR_EXPR
)
1647 expr
= TREE_OPERAND (expr
, 0);
1652 repl_found
= build_ref_for_offset (&expr
, TREE_TYPE (expr
),
1653 adj
->offset
, adj
->type
,
1658 expr
= build_fold_addr_expr (expr
);
1662 tree ptrtype
= build_pointer_type (adj
->type
);
1664 if (!POINTER_TYPE_P (TREE_TYPE (expr
)))
1665 expr
= build_fold_addr_expr (expr
);
1666 if (!useless_type_conversion_p (ptrtype
, TREE_TYPE (expr
)))
1667 expr
= fold_convert (ptrtype
, expr
);
1668 expr
= fold_build2 (POINTER_PLUS_EXPR
, ptrtype
, expr
,
1669 build_int_cst (size_type_node
,
1670 adj
->offset
/ BITS_PER_UNIT
));
1672 expr
= fold_build1 (INDIRECT_REF
, adj
->type
, expr
);
1674 expr
= force_gimple_operand_gsi (&gsi
, expr
,
1676 || is_gimple_reg_type (adj
->type
),
1677 NULL
, true, GSI_SAME_STMT
);
1678 VEC_quick_push (tree
, vargs
, expr
);
1682 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1684 fprintf (dump_file
, "replacing stmt:");
1685 print_gimple_stmt (dump_file
, gsi_stmt (gsi
), 0, 0);
1688 callee_decl
= !cs
? gimple_call_fndecl (stmt
) : cs
->callee
->decl
;
1689 new_stmt
= gimple_build_call_vec (callee_decl
, vargs
);
1690 VEC_free (tree
, heap
, vargs
);
1691 if (gimple_call_lhs (stmt
))
1692 gimple_call_set_lhs (new_stmt
, gimple_call_lhs (stmt
));
1694 gimple_set_block (new_stmt
, gimple_block (stmt
));
1695 if (gimple_has_location (stmt
))
1696 gimple_set_location (new_stmt
, gimple_location (stmt
));
1697 gimple_call_copy_flags (new_stmt
, stmt
);
1698 gimple_call_set_chain (new_stmt
, gimple_call_chain (stmt
));
1700 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1702 fprintf (dump_file
, "with stmt:");
1703 print_gimple_stmt (dump_file
, new_stmt
, 0, 0);
1704 fprintf (dump_file
, "\n");
1706 gsi_replace (&gsi
, new_stmt
, true);
1708 cgraph_set_call_stmt (cs
, new_stmt
);
1709 update_ssa (TODO_update_ssa
);
1710 free_dominance_info (CDI_DOMINATORS
);
1713 /* Return true iff BASE_INDEX is in ADJUSTMENTS more than once. */
1716 index_in_adjustments_multiple_times_p (int base_index
,
1717 ipa_parm_adjustment_vec adjustments
)
1719 int i
, len
= VEC_length (ipa_parm_adjustment_t
, adjustments
);
1722 for (i
= 0; i
< len
; i
++)
1724 struct ipa_parm_adjustment
*adj
;
1725 adj
= VEC_index (ipa_parm_adjustment_t
, adjustments
, i
);
1727 if (adj
->base_index
== base_index
)
1739 /* Return adjustments that should have the same effect on function parameters
1740 and call arguments as if they were first changed according to adjustments in
1741 INNER and then by adjustments in OUTER. */
1743 ipa_parm_adjustment_vec
1744 ipa_combine_adjustments (ipa_parm_adjustment_vec inner
,
1745 ipa_parm_adjustment_vec outer
)
1747 int i
, outlen
= VEC_length (ipa_parm_adjustment_t
, outer
);
1748 int inlen
= VEC_length (ipa_parm_adjustment_t
, inner
);
1750 ipa_parm_adjustment_vec adjustments
, tmp
;
1752 tmp
= VEC_alloc (ipa_parm_adjustment_t
, heap
, inlen
);
1753 for (i
= 0; i
< inlen
; i
++)
1755 struct ipa_parm_adjustment
*n
;
1756 n
= VEC_index (ipa_parm_adjustment_t
, inner
, i
);
1758 if (n
->remove_param
)
1761 VEC_quick_push (ipa_parm_adjustment_t
, tmp
, n
);
1764 adjustments
= VEC_alloc (ipa_parm_adjustment_t
, heap
, outlen
+ removals
);
1765 for (i
= 0; i
< outlen
; i
++)
1767 struct ipa_parm_adjustment
*r
;
1768 struct ipa_parm_adjustment
*out
= VEC_index (ipa_parm_adjustment_t
,
1770 struct ipa_parm_adjustment
*in
= VEC_index (ipa_parm_adjustment_t
, tmp
,
1773 gcc_assert (!in
->remove_param
);
1774 if (out
->remove_param
)
1776 if (!index_in_adjustments_multiple_times_p (in
->base_index
, tmp
))
1778 r
= VEC_quick_push (ipa_parm_adjustment_t
, adjustments
, NULL
);
1779 memset (r
, 0, sizeof (*r
));
1780 r
->remove_param
= true;
1785 r
= VEC_quick_push (ipa_parm_adjustment_t
, adjustments
, NULL
);
1786 memset (r
, 0, sizeof (*r
));
1787 r
->base_index
= in
->base_index
;
1788 r
->type
= out
->type
;
1790 /* FIXME: Create nonlocal value too. */
1792 if (in
->copy_param
&& out
->copy_param
)
1793 r
->copy_param
= true;
1794 else if (in
->copy_param
)
1795 r
->offset
= out
->offset
;
1796 else if (out
->copy_param
)
1797 r
->offset
= in
->offset
;
1799 r
->offset
= in
->offset
+ out
->offset
;
1802 for (i
= 0; i
< inlen
; i
++)
1804 struct ipa_parm_adjustment
*n
= VEC_index (ipa_parm_adjustment_t
,
1807 if (n
->remove_param
)
1808 VEC_quick_push (ipa_parm_adjustment_t
, adjustments
, n
);
1811 VEC_free (ipa_parm_adjustment_t
, heap
, tmp
);
1815 /* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human
1816 friendly way, assuming they are meant to be applied to FNDECL. */
1819 ipa_dump_param_adjustments (FILE *file
, ipa_parm_adjustment_vec adjustments
,
1822 int i
, len
= VEC_length (ipa_parm_adjustment_t
, adjustments
);
1824 VEC(tree
, heap
) *parms
= ipa_get_vector_of_formal_parms (fndecl
);
1826 fprintf (file
, "IPA param adjustments: ");
1827 for (i
= 0; i
< len
; i
++)
1829 struct ipa_parm_adjustment
*adj
;
1830 adj
= VEC_index (ipa_parm_adjustment_t
, adjustments
, i
);
1833 fprintf (file
, " ");
1837 fprintf (file
, "%i. base_index: %i - ", i
, adj
->base_index
);
1838 print_generic_expr (file
, VEC_index (tree
, parms
, adj
->base_index
), 0);
1841 fprintf (file
, ", base: ");
1842 print_generic_expr (file
, adj
->base
, 0);
1846 fprintf (file
, ", reduction: ");
1847 print_generic_expr (file
, adj
->reduction
, 0);
1849 if (adj
->new_ssa_base
)
1851 fprintf (file
, ", new_ssa_base: ");
1852 print_generic_expr (file
, adj
->new_ssa_base
, 0);
1855 if (adj
->copy_param
)
1856 fprintf (file
, ", copy_param");
1857 else if (adj
->remove_param
)
1858 fprintf (file
, ", remove_param");
1860 fprintf (file
, ", offset %li", (long) adj
->offset
);
1862 fprintf (file
, ", by_ref");
1863 print_node_brief (file
, ", type: ", adj
->type
, 0);
1864 fprintf (file
, "\n");
1866 VEC_free (tree
, heap
, parms
);