1 /* Interprocedural constant propagation
2 Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
3 Free Software Foundation, Inc.
4 Contributed by Razya Ladelsky <RAZYA@il.ibm.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* Interprocedural constant propagation. The aim of interprocedural constant
23 propagation (IPCP) is to find which function's argument has the same
24 constant value in each invocation throughout the whole program. For example,
25 consider the following program:
29 printf ("value is %d",y);
49 The IPCP algorithm will find that g's formal argument y is always called
52 The algorithm used is based on "Interprocedural Constant Propagation", by
53 David Callahan, Keith D Cooper, Ken Kennedy, Linda Torczon, Comp86, pg
56 The optimization is divided into three stages:
58 First stage - intraprocedural analysis
59 =======================================
60 This phase computes jump_function and modification flags.
62 A jump function for a callsite represents the values passed as an actual
63 arguments of a given callsite. There are three types of values:
64 Pass through - the caller's formal parameter is passed as an actual argument.
65 Constant - a constant is passed as an actual argument.
66 Unknown - neither of the above.
68 The jump function info, ipa_jump_func, is stored in ipa_edge_args
69 structure (defined in ipa_prop.h and pointed to by cgraph_node->aux)
70 modified_flags are defined in ipa_node_params structure
71 (defined in ipa_prop.h and pointed to by cgraph_edge->aux).
73 -ipcp_generate_summary() is the first stage driver.
75 Second stage - interprocedural analysis
76 ========================================
77 This phase does the interprocedural constant propagation.
78 It computes lattices for all formal parameters in the program
79 and their value that may be:
81 BOTTOM - non constant.
82 CONSTANT - constant value.
84 Lattice describing a formal parameter p will have a constant value if all
85 callsites invoking this function have the same constant value passed to p.
87 The lattices are stored in ipcp_lattice which is itself in ipa_node_params
88 structure (defined in ipa_prop.h and pointed to by cgraph_edge->aux).
90 -ipcp_iterate_stage() is the second stage driver.
92 Third phase - transformation of function code
93 ============================================
94 Propagates the constant-valued formals into the function.
95 For each function whose parameters are constants, we create its clone.
97 Then we process the clone in two ways:
98 1. We insert an assignment statement 'parameter = const' at the beginning
99 of the cloned function.
100 2. For read-only parameters that do not live in memory, we replace all their
101 uses with the constant.
103 We also need to modify some callsites to call the cloned functions instead
104 of the original ones. For a callsite passing an argument found to be a
105 constant by IPCP, there are two different cases to handle:
106 1. A constant is passed as an argument. In this case the callsite in the
107 should be redirected to call the cloned callee.
108 2. A parameter (of the caller) passed as an argument (pass through
109 argument). In such cases both the caller and the callee have clones and
110 only the callsite in the cloned caller is redirected to call to the
113 This update is done in two steps: First all cloned functions are created
114 during a traversal of the call graph, during which all callsites are
115 redirected to call the cloned function. Then the callsites are traversed
116 and many calls redirected back to fit the description above.
118 -ipcp_insert_stage() is the third phase driver.
121 This pass also performs devirtualization - turns virtual calls into direct
122 ones if it can prove that all invocations of the function call the same
123 callee. This is achieved by building a list of all base types (actually,
124 their BINFOs) that individual parameters can have in an iterative matter
125 just like propagating scalar constants and then examining whether virtual
126 calls which take a parameter as their object fold to the same target for all
127 these types. If we cannot enumerate all types or there is a type which does
128 not have any BINFO associated with it, cannot_devirtualize of the associated
129 parameter descriptor is set which is an equivalent of BOTTOM lattice value
130 in standard IPA constant propagation.
135 #include "coretypes.h"
140 #include "ipa-prop.h"
141 #include "tree-flow.h"
142 #include "tree-pass.h"
145 #include "diagnostic.h"
146 #include "tree-pretty-print.h"
147 #include "tree-dump.h"
148 #include "tree-inline.h"
152 /* Number of functions identified as candidates for cloning. When not cloning
153 we can simplify iterate stage not forcing it to go through the decision
154 on what is profitable and what not. */
155 static int n_cloning_candidates
;
157 /* Maximal count found in program. */
158 static gcov_type max_count
;
160 /* Cgraph nodes that has been completely replaced by cloning during iterate
161 * stage and will be removed after ipcp is finished. */
162 static bitmap dead_nodes
;
164 static void ipcp_print_profile_data (FILE *);
165 static void ipcp_function_scale_print (FILE *);
167 /* Get the original node field of ipa_node_params associated with node NODE. */
168 static inline struct cgraph_node
*
169 ipcp_get_orig_node (struct cgraph_node
*node
)
171 return IPA_NODE_REF (node
)->ipcp_orig_node
;
174 /* Return true if NODE describes a cloned/versioned function. */
176 ipcp_node_is_clone (struct cgraph_node
*node
)
178 return (ipcp_get_orig_node (node
) != NULL
);
181 /* Create ipa_node_params and its data structures for NEW_NODE. Set ORIG_NODE
182 as the ipcp_orig_node field in ipa_node_params. */
184 ipcp_init_cloned_node (struct cgraph_node
*orig_node
,
185 struct cgraph_node
*new_node
)
187 gcc_checking_assert (ipa_node_params_vector
188 && (VEC_length (ipa_node_params_t
,
189 ipa_node_params_vector
)
190 > (unsigned) cgraph_max_uid
));
191 gcc_checking_assert (IPA_NODE_REF (new_node
)->params
);
192 IPA_NODE_REF (new_node
)->ipcp_orig_node
= orig_node
;
195 /* Return scale for NODE. */
196 static inline gcov_type
197 ipcp_get_node_scale (struct cgraph_node
*node
)
199 return IPA_NODE_REF (node
)->count_scale
;
202 /* Set COUNT as scale for NODE. */
204 ipcp_set_node_scale (struct cgraph_node
*node
, gcov_type count
)
206 IPA_NODE_REF (node
)->count_scale
= count
;
209 /* Return whether LAT is a constant lattice. */
211 ipcp_lat_is_const (struct ipcp_lattice
*lat
)
213 if (lat
->type
== IPA_CONST_VALUE
)
219 /* Return whether LAT is a constant lattice that ipa-cp can actually insert
220 into the code (i.e. constants excluding member pointers and pointers). */
222 ipcp_lat_is_insertable (struct ipcp_lattice
*lat
)
224 return lat
->type
== IPA_CONST_VALUE
;
227 /* Return true if LAT1 and LAT2 are equal. */
229 ipcp_lats_are_equal (struct ipcp_lattice
*lat1
, struct ipcp_lattice
*lat2
)
231 gcc_assert (ipcp_lat_is_const (lat1
) && ipcp_lat_is_const (lat2
));
232 if (lat1
->type
!= lat2
->type
)
235 if (TREE_CODE (lat1
->constant
) == ADDR_EXPR
236 && TREE_CODE (lat2
->constant
) == ADDR_EXPR
237 && TREE_CODE (TREE_OPERAND (lat1
->constant
, 0)) == CONST_DECL
238 && TREE_CODE (TREE_OPERAND (lat2
->constant
, 0)) == CONST_DECL
)
239 return operand_equal_p (DECL_INITIAL (TREE_OPERAND (lat1
->constant
, 0)),
240 DECL_INITIAL (TREE_OPERAND (lat2
->constant
, 0)), 0);
242 return operand_equal_p (lat1
->constant
, lat2
->constant
, 0);
245 /* Compute Meet arithmetics:
246 Meet (IPA_BOTTOM, x) = IPA_BOTTOM
248 Meet (const_a,const_b) = IPA_BOTTOM, if const_a != const_b.
249 MEET (const_a,const_b) = const_a, if const_a == const_b.*/
251 ipa_lattice_meet (struct ipcp_lattice
*res
, struct ipcp_lattice
*lat1
,
252 struct ipcp_lattice
*lat2
)
254 if (lat1
->type
== IPA_BOTTOM
|| lat2
->type
== IPA_BOTTOM
)
256 res
->type
= IPA_BOTTOM
;
259 if (lat1
->type
== IPA_TOP
)
261 res
->type
= lat2
->type
;
262 res
->constant
= lat2
->constant
;
265 if (lat2
->type
== IPA_TOP
)
267 res
->type
= lat1
->type
;
268 res
->constant
= lat1
->constant
;
271 if (!ipcp_lats_are_equal (lat1
, lat2
))
273 res
->type
= IPA_BOTTOM
;
276 res
->type
= lat1
->type
;
277 res
->constant
= lat1
->constant
;
280 /* Return the lattice corresponding to the Ith formal parameter of the function
281 described by INFO. */
282 static inline struct ipcp_lattice
*
283 ipcp_get_lattice (struct ipa_node_params
*info
, int i
)
285 return &(info
->params
[i
].ipcp_lattice
);
288 /* Given the jump function JFUNC, compute the lattice LAT that describes the
289 value coming down the callsite. INFO describes the caller node so that
290 pass-through jump functions can be evaluated. */
292 ipcp_lattice_from_jfunc (struct ipa_node_params
*info
, struct ipcp_lattice
*lat
,
293 struct ipa_jump_func
*jfunc
)
295 if (jfunc
->type
== IPA_JF_CONST
)
297 lat
->type
= IPA_CONST_VALUE
;
298 lat
->constant
= jfunc
->value
.constant
;
300 else if (jfunc
->type
== IPA_JF_PASS_THROUGH
)
302 struct ipcp_lattice
*caller_lat
;
305 caller_lat
= ipcp_get_lattice (info
, jfunc
->value
.pass_through
.formal_id
);
306 lat
->type
= caller_lat
->type
;
307 if (caller_lat
->type
!= IPA_CONST_VALUE
)
309 cst
= caller_lat
->constant
;
311 if (jfunc
->value
.pass_through
.operation
!= NOP_EXPR
)
314 if (TREE_CODE_CLASS (jfunc
->value
.pass_through
.operation
)
316 restype
= boolean_type_node
;
318 restype
= TREE_TYPE (cst
);
319 cst
= fold_binary (jfunc
->value
.pass_through
.operation
,
320 restype
, cst
, jfunc
->value
.pass_through
.operand
);
322 if (!cst
|| !is_gimple_ip_invariant (cst
))
323 lat
->type
= IPA_BOTTOM
;
326 else if (jfunc
->type
== IPA_JF_ANCESTOR
)
328 struct ipcp_lattice
*caller_lat
;
331 caller_lat
= ipcp_get_lattice (info
, jfunc
->value
.ancestor
.formal_id
);
332 lat
->type
= caller_lat
->type
;
333 if (caller_lat
->type
!= IPA_CONST_VALUE
)
335 if (TREE_CODE (caller_lat
->constant
) != ADDR_EXPR
)
337 /* This can happen when the constant is a NULL pointer. */
338 lat
->type
= IPA_BOTTOM
;
341 t
= TREE_OPERAND (caller_lat
->constant
, 0);
342 t
= build_ref_for_offset (EXPR_LOCATION (t
), t
,
343 jfunc
->value
.ancestor
.offset
,
344 jfunc
->value
.ancestor
.type
, NULL
, false);
345 lat
->constant
= build_fold_addr_expr (t
);
348 lat
->type
= IPA_BOTTOM
;
351 /* True when OLD_LAT and NEW_LAT values are not the same. */
354 ipcp_lattice_changed (struct ipcp_lattice
*old_lat
,
355 struct ipcp_lattice
*new_lat
)
357 if (old_lat
->type
== new_lat
->type
)
359 if (!ipcp_lat_is_const (old_lat
))
361 if (ipcp_lats_are_equal (old_lat
, new_lat
))
367 /* Print all ipcp_lattices of all functions to F. */
369 ipcp_print_all_lattices (FILE * f
)
371 struct cgraph_node
*node
;
374 fprintf (f
, "\nLattice:\n");
375 for (node
= cgraph_nodes
; node
; node
= node
->next
)
377 struct ipa_node_params
*info
;
381 info
= IPA_NODE_REF (node
);
382 fprintf (f
, " Node: %s:\n", cgraph_node_name (node
));
383 count
= ipa_get_param_count (info
);
384 for (i
= 0; i
< count
; i
++)
386 struct ipcp_lattice
*lat
= ipcp_get_lattice (info
, i
);
388 fprintf (f
, " param [%d]: ", i
);
389 if (lat
->type
== IPA_CONST_VALUE
)
391 tree cst
= lat
->constant
;
392 fprintf (f
, "type is CONST ");
393 print_generic_expr (f
, cst
, 0);
394 if (TREE_CODE (cst
) == ADDR_EXPR
395 && TREE_CODE (TREE_OPERAND (cst
, 0)) == CONST_DECL
)
398 print_generic_expr (f
, DECL_INITIAL (TREE_OPERAND (cst
, 0)),
402 else if (lat
->type
== IPA_TOP
)
403 fprintf (f
, "type is TOP");
405 fprintf (f
, "type is BOTTOM");
406 if (ipa_param_cannot_devirtualize_p (info
, i
))
407 fprintf (f
, " - cannot_devirtualize set\n");
408 else if (ipa_param_types_vec_empty (info
, i
))
409 fprintf (f
, " - type list empty\n");
416 /* Return true if ipcp algorithms would allow cloning NODE. */
419 ipcp_versionable_function_p (struct cgraph_node
*node
)
421 struct cgraph_edge
*edge
;
423 /* There are a number of generic reasons functions cannot be versioned. We
424 also cannot remove parameters if there are type attributes such as fnspec
426 if (!node
->local
.versionable
427 || TYPE_ATTRIBUTES (TREE_TYPE (node
->decl
)))
430 /* Removing arguments doesn't work if the function takes varargs
431 or use __builtin_apply_args. */
432 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
434 tree t
= edge
->callee
->decl
;
435 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
436 && (DECL_FUNCTION_CODE (t
) == BUILT_IN_APPLY_ARGS
437 || DECL_FUNCTION_CODE (t
) == BUILT_IN_VA_START
))
444 /* Return true if this NODE is viable candidate for cloning. */
446 ipcp_cloning_candidate_p (struct cgraph_node
*node
)
450 gcov_type direct_call_sum
= 0;
451 struct cgraph_edge
*e
;
453 /* We never clone functions that are not visible from outside.
454 FIXME: in future we should clone such functions when they are called with
455 different constants, but current ipcp implementation is not good on this.
457 if (cgraph_only_called_directly_p (node
) || !node
->analyzed
)
460 /* When function address is taken, we are pretty sure it will be called in hidden way. */
461 if (node
->address_taken
)
464 fprintf (dump_file
, "Not considering %s for cloning; address is taken.\n",
465 cgraph_node_name (node
));
469 if (cgraph_function_body_availability (node
) <= AVAIL_OVERWRITABLE
)
472 fprintf (dump_file
, "Not considering %s for cloning; body is overwritable.\n",
473 cgraph_node_name (node
));
476 if (!ipcp_versionable_function_p (node
))
479 fprintf (dump_file
, "Not considering %s for cloning; body is not versionable.\n",
480 cgraph_node_name (node
));
483 for (e
= node
->callers
; e
; e
= e
->next_caller
)
485 direct_call_sum
+= e
->count
;
487 if (cgraph_maybe_hot_edge_p (e
))
494 fprintf (dump_file
, "Not considering %s for cloning; no direct calls.\n",
495 cgraph_node_name (node
));
498 if (node
->local
.inline_summary
.self_size
< n_calls
)
501 fprintf (dump_file
, "Considering %s for cloning; code would shrink.\n",
502 cgraph_node_name (node
));
506 if (!flag_ipa_cp_clone
)
509 fprintf (dump_file
, "Not considering %s for cloning; -fipa-cp-clone disabled.\n",
510 cgraph_node_name (node
));
514 if (!optimize_function_for_speed_p (DECL_STRUCT_FUNCTION (node
->decl
)))
517 fprintf (dump_file
, "Not considering %s for cloning; optimizing it for size.\n",
518 cgraph_node_name (node
));
522 /* When profile is available and function is hot, propagate into it even if
523 calls seems cold; constant propagation can improve function's speed
527 if (direct_call_sum
> node
->count
* 90 / 100)
530 fprintf (dump_file
, "Considering %s for cloning; usually called directly.\n",
531 cgraph_node_name (node
));
538 fprintf (dump_file
, "Not considering %s for cloning; no hot calls.\n",
539 cgraph_node_name (node
));
543 fprintf (dump_file
, "Considering %s for cloning.\n",
544 cgraph_node_name (node
));
548 /* Mark parameter with index I of function described by INFO as unsuitable for
549 devirtualization. Return true if it has already been marked so. */
552 ipa_set_param_cannot_devirtualize (struct ipa_node_params
*info
, int i
)
554 bool ret
= info
->params
[i
].cannot_devirtualize
;
555 info
->params
[i
].cannot_devirtualize
= true;
556 if (info
->params
[i
].types
)
557 VEC_free (tree
, heap
, info
->params
[i
].types
);
561 /* Initialize ipcp_lattices array. The lattices corresponding to supported
562 types (integers, real types and Fortran constants defined as const_decls)
563 are initialized to IPA_TOP, the rest of them to IPA_BOTTOM. */
565 ipcp_initialize_node_lattices (struct cgraph_node
*node
)
568 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
569 enum ipa_lattice_type type
;
571 if (ipa_is_called_with_var_arguments (info
))
573 else if (node
->local
.local
)
575 /* When cloning is allowed, we can assume that externally visible functions
576 are not called. We will compensate this by cloning later. */
577 else if (ipcp_cloning_candidate_p (node
))
578 type
= IPA_TOP
, n_cloning_candidates
++;
582 for (i
= 0; i
< ipa_get_param_count (info
) ; i
++)
584 ipcp_get_lattice (info
, i
)->type
= type
;
585 if (type
== IPA_BOTTOM
)
586 ipa_set_param_cannot_devirtualize (info
, i
);
590 /* Build a constant tree with type TREE_TYPE and value according to LAT.
591 Return the tree, or, if it is not possible to convert such value
592 to TREE_TYPE, NULL. */
594 build_const_val (struct ipcp_lattice
*lat
, tree tree_type
)
598 gcc_assert (ipcp_lat_is_const (lat
));
601 if (!useless_type_conversion_p (tree_type
, TREE_TYPE (val
)))
603 if (fold_convertible_p (tree_type
, val
))
604 return fold_build1 (NOP_EXPR
, tree_type
, val
);
605 else if (TYPE_SIZE (tree_type
) == TYPE_SIZE (TREE_TYPE (val
)))
606 return fold_build1 (VIEW_CONVERT_EXPR
, tree_type
, val
);
613 /* Compute the proper scale for NODE. It is the ratio between the number of
614 direct calls (represented on the incoming cgraph_edges) and sum of all
615 invocations of NODE (represented as count in cgraph_node).
617 FIXME: This code is wrong. Since the callers can be also clones and
618 the clones are not scaled yet, the sums gets unrealistically high.
619 To properly compute the counts, we would need to do propagation across
620 callgraph (as external call to A might imply call to non-cloned B
621 if A's clone calls cloned B). */
623 ipcp_compute_node_scale (struct cgraph_node
*node
)
626 struct cgraph_edge
*cs
;
629 /* Compute sum of all counts of callers. */
630 for (cs
= node
->callers
; cs
!= NULL
; cs
= cs
->next_caller
)
632 /* Work around the unrealistically high sum problem. We just don't want
633 the non-cloned body to have negative or very low frequency. Since
634 majority of execution time will be spent in clones anyway, this should
635 give good enough profile. */
636 if (sum
> node
->count
* 9 / 10)
637 sum
= node
->count
* 9 / 10;
638 if (node
->count
== 0)
639 ipcp_set_node_scale (node
, 0);
641 ipcp_set_node_scale (node
, sum
* REG_BR_PROB_BASE
/ node
->count
);
644 /* Return true if there are some formal parameters whose value is IPA_TOP (in
645 the whole compilation unit). Change their values to IPA_BOTTOM, since they
646 most probably get their values from outside of this compilation unit. */
648 ipcp_change_tops_to_bottom (void)
651 struct cgraph_node
*node
;
655 for (node
= cgraph_nodes
; node
; node
= node
->next
)
657 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
658 count
= ipa_get_param_count (info
);
659 for (i
= 0; i
< count
; i
++)
661 struct ipcp_lattice
*lat
= ipcp_get_lattice (info
, i
);
662 if (lat
->type
== IPA_TOP
)
667 fprintf (dump_file
, "Forcing param ");
668 print_generic_expr (dump_file
, ipa_get_param (info
, i
), 0);
669 fprintf (dump_file
, " of node %s to bottom.\n",
670 cgraph_node_name (node
));
672 lat
->type
= IPA_BOTTOM
;
674 if (!ipa_param_cannot_devirtualize_p (info
, i
)
675 && ipa_param_types_vec_empty (info
, i
))
678 ipa_set_param_cannot_devirtualize (info
, i
);
681 fprintf (dump_file
, "Marking param ");
682 print_generic_expr (dump_file
, ipa_get_param (info
, i
), 0);
683 fprintf (dump_file
, " of node %s as unusable for "
684 "devirtualization.\n",
685 cgraph_node_name (node
));
693 /* Insert BINFO to the list of known types of parameter number I of the
694 function described by CALLEE_INFO. Return true iff the type information
695 associated with the callee parameter changed in any way. */
698 ipcp_add_param_type (struct ipa_node_params
*callee_info
, int i
, tree binfo
)
702 if (ipa_param_cannot_devirtualize_p (callee_info
, i
))
705 if (callee_info
->params
[i
].types
)
707 count
= VEC_length (tree
, callee_info
->params
[i
].types
);
708 for (j
= 0; j
< count
; j
++)
709 if (VEC_index (tree
, callee_info
->params
[i
].types
, j
) == binfo
)
713 if (VEC_length (tree
, callee_info
->params
[i
].types
)
714 == (unsigned) PARAM_VALUE (PARAM_DEVIRT_TYPE_LIST_SIZE
))
715 return !ipa_set_param_cannot_devirtualize (callee_info
, i
);
717 VEC_safe_push (tree
, heap
, callee_info
->params
[i
].types
, binfo
);
721 /* Copy known types information for parameter number CALLEE_IDX of CALLEE_INFO
722 from a parameter of CALLER_INFO as described by JF. Return true iff the
723 type information changed in any way. JF must be a pass-through or an
724 ancestor jump function. */
727 ipcp_copy_types (struct ipa_node_params
*caller_info
,
728 struct ipa_node_params
*callee_info
,
729 int callee_idx
, struct ipa_jump_func
*jf
)
731 int caller_idx
, j
, count
;
734 if (ipa_param_cannot_devirtualize_p (callee_info
, callee_idx
))
737 if (jf
->type
== IPA_JF_PASS_THROUGH
)
739 if (jf
->value
.pass_through
.operation
!= NOP_EXPR
)
741 ipa_set_param_cannot_devirtualize (callee_info
, callee_idx
);
744 caller_idx
= jf
->value
.pass_through
.formal_id
;
747 caller_idx
= jf
->value
.ancestor
.formal_id
;
749 if (ipa_param_cannot_devirtualize_p (caller_info
, caller_idx
))
751 ipa_set_param_cannot_devirtualize (callee_info
, callee_idx
);
755 if (!caller_info
->params
[caller_idx
].types
)
759 count
= VEC_length (tree
, caller_info
->params
[caller_idx
].types
);
760 for (j
= 0; j
< count
; j
++)
762 tree binfo
= VEC_index (tree
, caller_info
->params
[caller_idx
].types
, j
);
763 if (jf
->type
== IPA_JF_ANCESTOR
)
765 binfo
= get_binfo_at_offset (binfo
, jf
->value
.ancestor
.offset
,
766 jf
->value
.ancestor
.type
);
769 ipa_set_param_cannot_devirtualize (callee_info
, callee_idx
);
773 res
|= ipcp_add_param_type (callee_info
, callee_idx
, binfo
);
778 /* Propagate type information for parameter of CALLEE_INFO number I as
779 described by JF. CALLER_INFO describes the caller. Return true iff the
780 type information changed in any way. */
783 ipcp_propagate_types (struct ipa_node_params
*caller_info
,
784 struct ipa_node_params
*callee_info
,
785 struct ipa_jump_func
*jf
, int i
)
790 case IPA_JF_CONST_MEMBER_PTR
:
794 case IPA_JF_KNOWN_TYPE
:
795 return ipcp_add_param_type (callee_info
, i
, jf
->value
.base_binfo
);
797 case IPA_JF_PASS_THROUGH
:
798 case IPA_JF_ANCESTOR
:
799 return ipcp_copy_types (caller_info
, callee_info
, i
, jf
);
802 /* If we reach this we cannot use this parameter for devirtualization. */
803 return !ipa_set_param_cannot_devirtualize (callee_info
, i
);
806 /* Interprocedural analysis. The algorithm propagates constants from the
807 caller's parameters to the callee's arguments. */
809 ipcp_propagate_stage (void)
812 struct ipcp_lattice inc_lat
= { IPA_BOTTOM
, NULL
};
813 struct ipcp_lattice new_lat
= { IPA_BOTTOM
, NULL
};
814 struct ipcp_lattice
*dest_lat
;
815 struct cgraph_edge
*cs
;
816 struct ipa_jump_func
*jump_func
;
817 struct ipa_func_list
*wl
;
820 ipa_check_create_node_params ();
821 ipa_check_create_edge_args ();
823 /* Initialize worklist to contain all functions. */
824 wl
= ipa_init_func_list ();
827 struct cgraph_node
*node
= ipa_pop_func_from_list (&wl
);
828 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
830 for (cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
832 struct ipa_node_params
*callee_info
= IPA_NODE_REF (cs
->callee
);
833 struct ipa_edge_args
*args
= IPA_EDGE_REF (cs
);
835 if (ipa_is_called_with_var_arguments (callee_info
)
836 || !cs
->callee
->analyzed
837 || ipa_is_called_with_var_arguments (callee_info
))
840 count
= ipa_get_cs_argument_count (args
);
841 for (i
= 0; i
< count
; i
++)
843 jump_func
= ipa_get_ith_jump_func (args
, i
);
844 ipcp_lattice_from_jfunc (info
, &inc_lat
, jump_func
);
845 dest_lat
= ipcp_get_lattice (callee_info
, i
);
846 ipa_lattice_meet (&new_lat
, &inc_lat
, dest_lat
);
847 if (ipcp_lattice_changed (&new_lat
, dest_lat
))
849 dest_lat
->type
= new_lat
.type
;
850 dest_lat
->constant
= new_lat
.constant
;
851 ipa_push_func_to_list (&wl
, cs
->callee
);
854 if (ipcp_propagate_types (info
, callee_info
, jump_func
, i
))
855 ipa_push_func_to_list (&wl
, cs
->callee
);
861 /* Call the constant propagation algorithm and re-call it if necessary
862 (if there are undetermined values left). */
864 ipcp_iterate_stage (void)
866 struct cgraph_node
*node
;
867 n_cloning_candidates
= 0;
870 fprintf (dump_file
, "\nIPA iterate stage:\n\n");
873 ipa_update_after_lto_read ();
875 for (node
= cgraph_nodes
; node
; node
= node
->next
)
877 ipcp_initialize_node_lattices (node
);
878 ipcp_compute_node_scale (node
);
880 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
882 ipcp_print_all_lattices (dump_file
);
883 ipcp_function_scale_print (dump_file
);
886 ipcp_propagate_stage ();
887 if (ipcp_change_tops_to_bottom ())
888 /* Some lattices have changed from IPA_TOP to IPA_BOTTOM.
889 This change should be propagated. */
891 gcc_assert (n_cloning_candidates
);
892 ipcp_propagate_stage ();
896 fprintf (dump_file
, "\nIPA lattices after propagation:\n");
897 ipcp_print_all_lattices (dump_file
);
898 if (dump_flags
& TDF_DETAILS
)
899 ipcp_print_profile_data (dump_file
);
903 /* Check conditions to forbid constant insertion to function described by
906 ipcp_node_modifiable_p (struct cgraph_node
*node
)
908 /* Once we will be able to do in-place replacement, we can be more
910 return ipcp_versionable_function_p (node
);
913 /* Print count scale data structures. */
915 ipcp_function_scale_print (FILE * f
)
917 struct cgraph_node
*node
;
919 for (node
= cgraph_nodes
; node
; node
= node
->next
)
923 fprintf (f
, "printing scale for %s: ", cgraph_node_name (node
));
924 fprintf (f
, "value is " HOST_WIDE_INT_PRINT_DEC
925 " \n", (HOST_WIDE_INT
) ipcp_get_node_scale (node
));
929 /* Print counts of all cgraph nodes. */
931 ipcp_print_func_profile_counts (FILE * f
)
933 struct cgraph_node
*node
;
935 for (node
= cgraph_nodes
; node
; node
= node
->next
)
937 fprintf (f
, "function %s: ", cgraph_node_name (node
));
938 fprintf (f
, "count is " HOST_WIDE_INT_PRINT_DEC
939 " \n", (HOST_WIDE_INT
) node
->count
);
943 /* Print counts of all cgraph edges. */
945 ipcp_print_call_profile_counts (FILE * f
)
947 struct cgraph_node
*node
;
948 struct cgraph_edge
*cs
;
950 for (node
= cgraph_nodes
; node
; node
= node
->next
)
952 for (cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
954 fprintf (f
, "%s -> %s ", cgraph_node_name (cs
->caller
),
955 cgraph_node_name (cs
->callee
));
956 fprintf (f
, "count is " HOST_WIDE_INT_PRINT_DEC
" \n",
957 (HOST_WIDE_INT
) cs
->count
);
962 /* Print profile info for all functions. */
964 ipcp_print_profile_data (FILE * f
)
966 fprintf (f
, "\nNODE COUNTS :\n");
967 ipcp_print_func_profile_counts (f
);
968 fprintf (f
, "\nCS COUNTS stage:\n");
969 ipcp_print_call_profile_counts (f
);
972 /* Build and initialize ipa_replace_map struct according to LAT. This struct is
973 processed by versioning, which operates according to the flags set.
974 PARM_TREE is the formal parameter found to be constant. LAT represents the
976 static struct ipa_replace_map
*
977 ipcp_create_replace_map (tree parm_tree
, struct ipcp_lattice
*lat
)
979 struct ipa_replace_map
*replace_map
;
982 const_val
= build_const_val (lat
, TREE_TYPE (parm_tree
));
983 if (const_val
== NULL_TREE
)
987 fprintf (dump_file
, " const ");
988 print_generic_expr (dump_file
, lat
->constant
, 0);
989 fprintf (dump_file
, " can't be converted to param ");
990 print_generic_expr (dump_file
, parm_tree
, 0);
991 fprintf (dump_file
, "\n");
995 replace_map
= ggc_alloc_ipa_replace_map ();
998 fprintf (dump_file
, " replacing param ");
999 print_generic_expr (dump_file
, parm_tree
, 0);
1000 fprintf (dump_file
, " with const ");
1001 print_generic_expr (dump_file
, const_val
, 0);
1002 fprintf (dump_file
, "\n");
1004 replace_map
->old_tree
= parm_tree
;
1005 replace_map
->new_tree
= const_val
;
1006 replace_map
->replace_p
= true;
1007 replace_map
->ref_p
= false;
1012 /* Return true if this callsite should be redirected to the original callee
1013 (instead of the cloned one). */
1015 ipcp_need_redirect_p (struct cgraph_edge
*cs
)
1017 struct ipa_node_params
*orig_callee_info
;
1019 struct cgraph_node
*node
= cs
->callee
, *orig
;
1021 if (!n_cloning_candidates
)
1024 if ((orig
= ipcp_get_orig_node (node
)) != NULL
)
1026 if (ipcp_get_orig_node (cs
->caller
))
1029 orig_callee_info
= IPA_NODE_REF (node
);
1030 count
= ipa_get_param_count (orig_callee_info
);
1031 for (i
= 0; i
< count
; i
++)
1033 struct ipcp_lattice
*lat
= ipcp_get_lattice (orig_callee_info
, i
);
1034 struct ipa_jump_func
*jump_func
;
1036 jump_func
= ipa_get_ith_jump_func (IPA_EDGE_REF (cs
), i
);
1037 if ((ipcp_lat_is_const (lat
)
1038 && jump_func
->type
!= IPA_JF_CONST
)
1039 || (!ipa_param_cannot_devirtualize_p (orig_callee_info
, i
)
1040 && !ipa_param_types_vec_empty (orig_callee_info
, i
)
1041 && jump_func
->type
!= IPA_JF_CONST
1042 && jump_func
->type
!= IPA_JF_KNOWN_TYPE
))
1049 /* Fix the callsites and the call graph after function cloning was done. */
1051 ipcp_update_callgraph (void)
1053 struct cgraph_node
*node
;
1055 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1056 if (node
->analyzed
&& ipcp_node_is_clone (node
))
1058 bitmap args_to_skip
= NULL
;
1059 struct cgraph_node
*orig_node
= ipcp_get_orig_node (node
);
1060 struct ipa_node_params
*info
= IPA_NODE_REF (orig_node
);
1061 int i
, count
= ipa_get_param_count (info
);
1062 struct cgraph_edge
*cs
, *next
;
1064 if (node
->local
.can_change_signature
)
1066 args_to_skip
= BITMAP_ALLOC (NULL
);
1067 for (i
= 0; i
< count
; i
++)
1069 struct ipcp_lattice
*lat
= ipcp_get_lattice (info
, i
);
1071 /* We can proactively remove obviously unused arguments. */
1072 if (!ipa_is_param_used (info
, i
))
1074 bitmap_set_bit (args_to_skip
, i
);
1078 if (lat
->type
== IPA_CONST_VALUE
)
1079 bitmap_set_bit (args_to_skip
, i
);
1082 for (cs
= node
->callers
; cs
; cs
= next
)
1084 next
= cs
->next_caller
;
1085 if (!ipcp_node_is_clone (cs
->caller
) && ipcp_need_redirect_p (cs
))
1088 fprintf (dump_file
, "Redirecting edge %s/%i -> %s/%i "
1090 cgraph_node_name (cs
->caller
), cs
->caller
->uid
,
1091 cgraph_node_name (cs
->callee
), cs
->callee
->uid
,
1092 cgraph_node_name (orig_node
), orig_node
->uid
);
1093 cgraph_redirect_edge_callee (cs
, orig_node
);
1099 /* Update profiling info for versioned functions and the functions they were
1102 ipcp_update_profiling (void)
1104 struct cgraph_node
*node
, *orig_node
;
1105 gcov_type scale
, scale_complement
;
1106 struct cgraph_edge
*cs
;
1108 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1110 if (ipcp_node_is_clone (node
))
1112 orig_node
= ipcp_get_orig_node (node
);
1113 scale
= ipcp_get_node_scale (orig_node
);
1114 node
->count
= orig_node
->count
* scale
/ REG_BR_PROB_BASE
;
1115 scale_complement
= REG_BR_PROB_BASE
- scale
;
1117 /* Negative scale complement can result from insane profile data
1118 in which the total incoming edge counts in this module is
1119 larger than the callee's entry count. The insane profile data
1120 usually gets generated due to the following reasons:
1122 1) in multithreaded programs, when profile data is dumped
1123 to gcda files in gcov_exit, some other threads are still running.
1124 The profile counters are dumped in bottom up order (call graph).
1125 The caller's BB counters may still be updated while the callee's
1126 counter data is already saved to disk.
1128 2) Comdat functions: comdat functions' profile data are not
1129 allocated in comdat. When a comdat callee function gets inlined
1130 at some callsites after instrumentation, and the remaining calls
1131 to this function resolves to a comdat copy in another module,
1132 the profile counters for this function are split. This can
1133 result in sum of incoming edge counts from this module being
1134 larger than callee instance's entry count. */
1136 if (scale_complement
< 0 && flag_profile_correction
)
1137 scale_complement
= 0;
1140 orig_node
->count
* scale_complement
/ REG_BR_PROB_BASE
;
1141 for (cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
1142 cs
->count
= cs
->count
* scale
/ REG_BR_PROB_BASE
;
1143 for (cs
= orig_node
->callees
; cs
; cs
= cs
->next_callee
)
1144 cs
->count
= cs
->count
* scale_complement
/ REG_BR_PROB_BASE
;
1149 /* If NODE was cloned, how much would program grow? */
1151 ipcp_estimate_growth (struct cgraph_node
*node
)
1153 struct cgraph_edge
*cs
;
1154 int redirectable_node_callers
= 0;
1155 int removable_args
= 0;
1157 = !cgraph_will_be_removed_from_program_if_no_direct_calls (node
);
1158 struct ipa_node_params
*info
;
1162 for (cs
= node
->callers
; cs
!= NULL
; cs
= cs
->next_caller
)
1163 if (cs
->caller
== node
|| !ipcp_need_redirect_p (cs
))
1164 redirectable_node_callers
++;
1166 need_original
= true;
1168 /* If we will be able to fully replace original node, we never increase
1173 info
= IPA_NODE_REF (node
);
1174 count
= ipa_get_param_count (info
);
1175 if (node
->local
.can_change_signature
)
1176 for (i
= 0; i
< count
; i
++)
1178 struct ipcp_lattice
*lat
= ipcp_get_lattice (info
, i
);
1180 /* We can proactively remove obviously unused arguments. */
1181 if (!ipa_is_param_used (info
, i
))
1184 if (lat
->type
== IPA_CONST_VALUE
)
1188 /* We make just very simple estimate of savings for removal of operand from
1189 call site. Precise cost is difficult to get, as our size metric counts
1190 constants and moves as free. Generally we are looking for cases that
1191 small function is called very many times. */
1192 growth
= node
->local
.inline_summary
.self_size
1193 - removable_args
* redirectable_node_callers
;
1200 /* Estimate cost of cloning NODE. */
1202 ipcp_estimate_cloning_cost (struct cgraph_node
*node
)
1205 gcov_type count_sum
= 1;
1206 struct cgraph_edge
*e
;
1209 cost
= ipcp_estimate_growth (node
) * 1000;
1213 fprintf (dump_file
, "Versioning of %s will save code size\n",
1214 cgraph_node_name (node
));
1218 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1219 if (!bitmap_bit_p (dead_nodes
, e
->caller
->uid
)
1220 && !ipcp_need_redirect_p (e
))
1222 count_sum
+= e
->count
;
1223 freq_sum
+= e
->frequency
+ 1;
1227 cost
/= count_sum
* 1000 / max_count
+ 1;
1229 cost
/= freq_sum
* 1000 / REG_BR_PROB_BASE
+ 1;
1231 fprintf (dump_file
, "Cost of versioning %s is %i, (size: %i, freq: %i)\n",
1232 cgraph_node_name (node
), cost
, node
->local
.inline_summary
.self_size
,
1237 /* Walk indirect calls of NODE and if any polymorphic can be turned into a
1238 direct one now, do so. */
1241 ipcp_process_devirtualization_opportunities (struct cgraph_node
*node
)
1243 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
1244 struct cgraph_edge
*ie
, *next_ie
;
1246 for (ie
= node
->indirect_calls
; ie
; ie
= next_ie
)
1248 int param_index
, types_count
, j
;
1249 HOST_WIDE_INT token
;
1252 next_ie
= ie
->next_callee
;
1253 if (!ie
->indirect_info
->polymorphic
)
1255 param_index
= ie
->indirect_info
->param_index
;
1256 if (param_index
== -1
1257 || ipa_param_cannot_devirtualize_p (info
, param_index
)
1258 || ipa_param_types_vec_empty (info
, param_index
))
1261 token
= ie
->indirect_info
->otr_token
;
1263 types_count
= VEC_length (tree
, info
->params
[param_index
].types
);
1264 for (j
= 0; j
< types_count
; j
++)
1266 tree binfo
= VEC_index (tree
, info
->params
[param_index
].types
, j
);
1268 tree t
= gimple_get_virt_mehtod_for_binfo (token
, binfo
, &d
, true);
1280 else if (target
!= t
|| !tree_int_cst_equal (delta
, d
))
1288 ipa_make_edge_direct_to_target (ie
, target
, delta
);
1292 /* Return number of live constant parameters. */
1294 ipcp_const_param_count (struct cgraph_node
*node
)
1296 int const_param
= 0;
1297 struct ipa_node_params
*info
= IPA_NODE_REF (node
);
1298 int count
= ipa_get_param_count (info
);
1301 for (i
= 0; i
< count
; i
++)
1303 struct ipcp_lattice
*lat
= ipcp_get_lattice (info
, i
);
1304 if ((ipcp_lat_is_insertable (lat
)
1305 /* Do not count obviously unused arguments. */
1306 && ipa_is_param_used (info
, i
))
1307 || (!ipa_param_cannot_devirtualize_p (info
, i
)
1308 && !ipa_param_types_vec_empty (info
, i
)))
1314 /* Given that a formal parameter of NODE given by INDEX is known to be constant
1315 CST, try to find any indirect edges that can be made direct and make them
1316 so. Note that INDEX is the number the parameter at the time of analyzing
1317 parameter uses and parameter removals should not be considered for it. (In
1318 fact, the parameter itself has just been removed.) */
1321 ipcp_discover_new_direct_edges (struct cgraph_node
*node
, int index
, tree cst
)
1323 struct cgraph_edge
*ie
, *next_ie
;
1325 for (ie
= node
->indirect_calls
; ie
; ie
= next_ie
)
1327 struct cgraph_indirect_call_info
*ici
= ie
->indirect_info
;
1329 next_ie
= ie
->next_callee
;
1330 if (ici
->param_index
!= index
1331 || ici
->polymorphic
)
1334 ipa_make_edge_direct_to_target (ie
, cst
, NULL_TREE
);
1339 /* Propagate the constant parameters found by ipcp_iterate_stage()
1340 to the function's code. */
1342 ipcp_insert_stage (void)
1344 struct cgraph_node
*node
, *node1
= NULL
;
1346 VEC (cgraph_edge_p
, heap
) * redirect_callers
;
1347 VEC (ipa_replace_map_p
,gc
)* replace_trees
;
1348 int node_callers
, count
;
1350 struct ipa_replace_map
*replace_param
;
1352 long overall_size
= 0, new_size
= 0;
1355 ipa_check_create_node_params ();
1356 ipa_check_create_edge_args ();
1358 fprintf (dump_file
, "\nIPA insert stage:\n\n");
1360 dead_nodes
= BITMAP_ALLOC (NULL
);
1362 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1365 if (node
->count
> max_count
)
1366 max_count
= node
->count
;
1367 overall_size
+= node
->local
.inline_summary
.self_size
;
1370 max_new_size
= overall_size
;
1371 if (max_new_size
< PARAM_VALUE (PARAM_LARGE_UNIT_INSNS
))
1372 max_new_size
= PARAM_VALUE (PARAM_LARGE_UNIT_INSNS
);
1373 max_new_size
= max_new_size
* PARAM_VALUE (PARAM_IPCP_UNIT_GROWTH
) / 100 + 1;
1375 /* First collect all functions we proved to have constant arguments to
1377 heap
= fibheap_new ();
1378 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1380 struct ipa_node_params
*info
;
1381 /* Propagation of the constant is forbidden in certain conditions. */
1382 if (!node
->analyzed
|| !ipcp_node_modifiable_p (node
))
1384 info
= IPA_NODE_REF (node
);
1385 if (ipa_is_called_with_var_arguments (info
))
1387 if (ipcp_const_param_count (node
))
1388 node
->aux
= fibheap_insert (heap
, ipcp_estimate_cloning_cost (node
),
1392 /* Now clone in priority order until code size growth limits are met or
1394 while (!fibheap_empty (heap
))
1396 struct ipa_node_params
*info
;
1398 bitmap args_to_skip
;
1399 struct cgraph_edge
*cs
;
1401 node
= (struct cgraph_node
*)fibheap_extract_min (heap
);
1404 fprintf (dump_file
, "considering function %s\n",
1405 cgraph_node_name (node
));
1407 growth
= ipcp_estimate_growth (node
);
1409 if (new_size
+ growth
> max_new_size
)
1412 && optimize_function_for_size_p (DECL_STRUCT_FUNCTION (node
->decl
)))
1415 fprintf (dump_file
, "Not versioning, cold code would grow");
1419 info
= IPA_NODE_REF (node
);
1420 count
= ipa_get_param_count (info
);
1422 replace_trees
= VEC_alloc (ipa_replace_map_p
, gc
, 1);
1424 if (node
->local
.can_change_signature
)
1425 args_to_skip
= BITMAP_GGC_ALLOC ();
1427 args_to_skip
= NULL
;
1428 for (i
= 0; i
< count
; i
++)
1430 struct ipcp_lattice
*lat
= ipcp_get_lattice (info
, i
);
1431 parm_tree
= ipa_get_param (info
, i
);
1433 /* We can proactively remove obviously unused arguments. */
1434 if (!ipa_is_param_used (info
, i
))
1437 bitmap_set_bit (args_to_skip
, i
);
1441 if (lat
->type
== IPA_CONST_VALUE
)
1444 ipcp_create_replace_map (parm_tree
, lat
);
1445 if (replace_param
== NULL
)
1447 VEC_safe_push (ipa_replace_map_p
, gc
, replace_trees
, replace_param
);
1449 bitmap_set_bit (args_to_skip
, i
);
1455 fprintf (dump_file
, "Not versioning, some parameters couldn't be replaced");
1461 /* Look if original function becomes dead after cloning. */
1462 for (cs
= node
->callers
; cs
!= NULL
; cs
= cs
->next_caller
)
1463 if (cs
->caller
== node
|| ipcp_need_redirect_p (cs
))
1465 if (!cs
&& cgraph_will_be_removed_from_program_if_no_direct_calls (node
))
1466 bitmap_set_bit (dead_nodes
, node
->uid
);
1468 /* Compute how many callers node has. */
1470 for (cs
= node
->callers
; cs
!= NULL
; cs
= cs
->next_caller
)
1472 redirect_callers
= VEC_alloc (cgraph_edge_p
, heap
, node_callers
);
1473 for (cs
= node
->callers
; cs
!= NULL
; cs
= cs
->next_caller
)
1474 if (!cs
->indirect_inlining_edge
)
1475 VEC_quick_push (cgraph_edge_p
, redirect_callers
, cs
);
1477 /* Redirecting all the callers of the node to the
1478 new versioned node. */
1480 cgraph_create_virtual_clone (node
, redirect_callers
, replace_trees
,
1481 args_to_skip
, "constprop");
1482 args_to_skip
= NULL
;
1483 VEC_free (cgraph_edge_p
, heap
, redirect_callers
);
1484 replace_trees
= NULL
;
1488 ipcp_process_devirtualization_opportunities (node1
);
1491 fprintf (dump_file
, "versioned function %s with growth %i, overall %i\n",
1492 cgraph_node_name (node
), (int)growth
, (int)new_size
);
1493 ipcp_init_cloned_node (node
, node1
);
1495 info
= IPA_NODE_REF (node
);
1496 for (i
= 0; i
< count
; i
++)
1498 struct ipcp_lattice
*lat
= ipcp_get_lattice (info
, i
);
1499 if (lat
->type
== IPA_CONST_VALUE
)
1500 ipcp_discover_new_direct_edges (node1
, i
, lat
->constant
);
1504 dump_function_to_file (node1
->decl
, dump_file
, dump_flags
);
1506 for (cs
= node
->callees
; cs
; cs
= cs
->next_callee
)
1507 if (cs
->callee
->aux
)
1509 fibheap_delete_node (heap
, (fibnode_t
) cs
->callee
->aux
);
1510 cs
->callee
->aux
= fibheap_insert (heap
,
1511 ipcp_estimate_cloning_cost (cs
->callee
),
1516 while (!fibheap_empty (heap
))
1519 fprintf (dump_file
, "skipping function %s\n",
1520 cgraph_node_name (node
));
1521 node
= (struct cgraph_node
*) fibheap_extract_min (heap
);
1524 fibheap_delete (heap
);
1525 BITMAP_FREE (dead_nodes
);
1526 ipcp_update_callgraph ();
1527 ipcp_update_profiling ();
1530 /* The IPCP driver. */
1534 cgraph_remove_unreachable_nodes (true,dump_file
);
1537 fprintf (dump_file
, "\nIPA structures before propagation:\n");
1538 if (dump_flags
& TDF_DETAILS
)
1539 ipa_print_all_params (dump_file
);
1540 ipa_print_all_jump_functions (dump_file
);
1542 /* 2. Do the interprocedural propagation. */
1543 ipcp_iterate_stage ();
1544 /* 3. Insert the constants found to the functions. */
1545 ipcp_insert_stage ();
1546 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1548 fprintf (dump_file
, "\nProfiling info after insert stage:\n");
1549 ipcp_print_profile_data (dump_file
);
1551 /* Free all IPCP structures. */
1552 ipa_free_all_structures_after_ipa_cp ();
1554 fprintf (dump_file
, "\nIPA constant propagation end\n");
1558 /* Initialization and computation of IPCP data structures. This is the initial
1559 intraprocedural analysis of functions, which gathers information to be
1560 propagated later on. */
1563 ipcp_generate_summary (void)
1565 struct cgraph_node
*node
;
1568 fprintf (dump_file
, "\nIPA constant propagation start:\n");
1569 ipa_check_create_node_params ();
1570 ipa_check_create_edge_args ();
1571 ipa_register_cgraph_hooks ();
1573 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1576 /* Unreachable nodes should have been eliminated before ipcp. */
1577 gcc_assert (node
->needed
|| node
->reachable
);
1579 node
->local
.versionable
= tree_versionable_function_p (node
->decl
);
1580 ipa_analyze_node (node
);
1584 /* Write ipcp summary for nodes in SET. */
1586 ipcp_write_summary (cgraph_node_set set
,
1587 varpool_node_set vset ATTRIBUTE_UNUSED
)
1589 ipa_prop_write_jump_functions (set
);
1592 /* Read ipcp summary. */
1594 ipcp_read_summary (void)
1596 ipa_prop_read_jump_functions ();
1599 /* Gate for IPCP optimization. */
1601 cgraph_gate_cp (void)
1603 /* FIXME: We should remove the optimize check after we ensure we never run
1604 IPA passes when not optimizing. */
1605 return flag_ipa_cp
&& optimize
;
1608 struct ipa_opt_pass_d pass_ipa_cp
=
1613 cgraph_gate_cp
, /* gate */
1614 ipcp_driver
, /* execute */
1617 0, /* static_pass_number */
1618 TV_IPA_CONSTANT_PROP
, /* tv_id */
1619 0, /* properties_required */
1620 0, /* properties_provided */
1621 0, /* properties_destroyed */
1622 0, /* todo_flags_start */
1623 TODO_dump_cgraph
| TODO_dump_func
|
1624 TODO_remove_functions
| TODO_ggc_collect
/* todo_flags_finish */
1626 ipcp_generate_summary
, /* generate_summary */
1627 ipcp_write_summary
, /* write_summary */
1628 ipcp_read_summary
, /* read_summary */
1629 NULL
, /* write_optimization_summary */
1630 NULL
, /* read_optimization_summary */
1631 NULL
, /* stmt_fixup */
1633 NULL
, /* function_transform */
1634 NULL
, /* variable_transform */