Mercurial > hg > CbC > CbC_gcc
annotate gcc/ipa-cp.c @ 55:77e2b8dfacca gcc-4.4.5
update it from 4.4.3 to 4.5.0
author | ryoma <e075725@ie.u-ryukyu.ac.jp> |
---|---|
date | Fri, 12 Feb 2010 23:39:51 +0900 |
parents | 3bfb6c00c1e0 |
children | b7f97abdc517 |
rev | line source |
---|---|
0 | 1 /* Interprocedural constant propagation |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
2 Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. |
0 | 3 Contributed by Razya Ladelsky <RAZYA@il.ibm.com> |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
4 |
0 | 5 This file is part of GCC. |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
6 |
0 | 7 GCC is free software; you can redistribute it and/or modify it under |
8 the terms of the GNU General Public License as published by the Free | |
9 Software Foundation; either version 3, or (at your option) any later | |
10 version. | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
11 |
0 | 12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
15 for more details. | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
16 |
0 | 17 You should have received a copy of the GNU General Public License |
18 along with GCC; see the file COPYING3. If not see | |
19 <http://www.gnu.org/licenses/>. */ | |
20 | |
21 /* Interprocedural constant propagation. The aim of interprocedural constant | |
22 propagation (IPCP) is to find which function's argument has the same | |
23 constant value in each invocation throughout the whole program. For example, | |
24 consider the following program: | |
25 | |
26 int g (int y) | |
27 { | |
28 printf ("value is %d",y); | |
29 } | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
30 |
0 | 31 int f (int x) |
32 { | |
33 g (x); | |
34 } | |
35 | |
36 int h (int y) | |
37 { | |
38 g (y); | |
39 } | |
40 | |
41 void main (void) | |
42 { | |
43 f (3); | |
44 h (3); | |
45 } | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
46 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
47 |
0 | 48 The IPCP algorithm will find that g's formal argument y is always called |
49 with the value 3. | |
50 | |
51 The algorithm used is based on "Interprocedural Constant Propagation", by | |
52 Challahan David, Keith D Cooper, Ken Kennedy, Linda Torczon, Comp86, pg | |
53 152-161 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
54 |
0 | 55 The optimization is divided into three stages: |
56 | |
57 First stage - intraprocedural analysis | |
58 ======================================= | |
59 This phase computes jump_function and modification flags. | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
60 |
0 | 61 A jump function for a callsite represents the values passed as an actual |
62 arguments of a given callsite. There are three types of values: | |
63 Pass through - the caller's formal parameter is passed as an actual argument. | |
64 Constant - a constant is passed as an actual argument. | |
65 Unknown - neither of the above. | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
66 |
0 | 67 The jump function info, ipa_jump_func, is stored in ipa_edge_args |
68 structure (defined in ipa_prop.h and pointed to by cgraph_node->aux) | |
69 modified_flags are defined in ipa_node_params structure | |
70 (defined in ipa_prop.h and pointed to by cgraph_edge->aux). | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
71 |
0 | 72 -ipcp_init_stage() is the first stage driver. |
73 | |
74 Second stage - interprocedural analysis | |
75 ======================================== | |
76 This phase does the interprocedural constant propagation. | |
77 It computes lattices for all formal parameters in the program | |
78 and their value that may be: | |
79 TOP - unknown. | |
80 BOTTOM - non constant. | |
81 CONSTANT - constant value. | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
82 |
0 | 83 Lattice describing a formal parameter p will have a constant value if all |
84 callsites invoking this function have the same constant value passed to p. | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
85 |
0 | 86 The lattices are stored in ipcp_lattice which is itself in ipa_node_params |
87 structure (defined in ipa_prop.h and pointed to by cgraph_edge->aux). | |
88 | |
89 -ipcp_iterate_stage() is the second stage driver. | |
90 | |
91 Third phase - transformation of function code | |
92 ============================================ | |
93 Propagates the constant-valued formals into the function. | |
94 For each function whose parameters are constants, we create its clone. | |
95 | |
96 Then we process the clone in two ways: | |
97 1. We insert an assignment statement 'parameter = const' at the beginning | |
98 of the cloned function. | |
99 2. For read-only parameters that do not live in memory, we replace all their | |
100 uses with the constant. | |
101 | |
102 We also need to modify some callsites to call the cloned functions instead | |
103 of the original ones. For a callsite passing an argument found to be a | |
104 constant by IPCP, there are two different cases to handle: | |
105 1. A constant is passed as an argument. In this case the callsite in the | |
106 should be redirected to call the cloned callee. | |
107 2. A parameter (of the caller) passed as an argument (pass through | |
108 argument). In such cases both the caller and the callee have clones and | |
109 only the callsite in the cloned caller is redirected to call to the | |
110 cloned callee. | |
111 | |
112 This update is done in two steps: First all cloned functions are created | |
113 during a traversal of the call graph, during which all callsites are | |
114 redirected to call the cloned function. Then the callsites are traversed | |
115 and many calls redirected back to fit the description above. | |
116 | |
117 -ipcp_insert_stage() is the third phase driver. | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
118 |
0 | 119 */ |
120 | |
121 #include "config.h" | |
122 #include "system.h" | |
123 #include "coretypes.h" | |
124 #include "tree.h" | |
125 #include "target.h" | |
126 #include "cgraph.h" | |
127 #include "ipa-prop.h" | |
128 #include "tree-flow.h" | |
129 #include "tree-pass.h" | |
130 #include "flags.h" | |
131 #include "timevar.h" | |
132 #include "diagnostic.h" | |
133 #include "tree-dump.h" | |
134 #include "tree-inline.h" | |
135 #include "fibheap.h" | |
136 #include "params.h" | |
137 | |
138 /* Number of functions identified as candidates for cloning. When not cloning | |
139 we can simplify iterate stage not forcing it to go through the decision | |
140 on what is profitable and what not. */ | |
141 static int n_cloning_candidates; | |
142 | |
143 /* Maximal count found in program. */ | |
144 static gcov_type max_count; | |
145 | |
146 /* Cgraph nodes that has been completely replaced by cloning during iterate | |
147 * stage and will be removed after ipcp is finished. */ | |
148 static bitmap dead_nodes; | |
149 | |
150 static void ipcp_print_profile_data (FILE *); | |
151 static void ipcp_function_scale_print (FILE *); | |
152 | |
153 /* Get the original node field of ipa_node_params associated with node NODE. */ | |
154 static inline struct cgraph_node * | |
155 ipcp_get_orig_node (struct cgraph_node *node) | |
156 { | |
157 return IPA_NODE_REF (node)->ipcp_orig_node; | |
158 } | |
159 | |
160 /* Return true if NODE describes a cloned/versioned function. */ | |
161 static inline bool | |
162 ipcp_node_is_clone (struct cgraph_node *node) | |
163 { | |
164 return (ipcp_get_orig_node (node) != NULL); | |
165 } | |
166 | |
167 /* Create ipa_node_params and its data structures for NEW_NODE. Set ORIG_NODE | |
168 as the ipcp_orig_node field in ipa_node_params. */ | |
169 static void | |
170 ipcp_init_cloned_node (struct cgraph_node *orig_node, | |
171 struct cgraph_node *new_node) | |
172 { | |
173 ipa_check_create_node_params (); | |
174 ipa_initialize_node_params (new_node); | |
175 IPA_NODE_REF (new_node)->ipcp_orig_node = orig_node; | |
176 } | |
177 | |
178 /* Perform intraprocedrual analysis needed for ipcp. */ | |
179 static void | |
180 ipcp_analyze_node (struct cgraph_node *node) | |
181 { | |
182 /* Unreachable nodes should have been eliminated before ipcp. */ | |
183 gcc_assert (node->needed || node->reachable); | |
184 | |
185 ipa_initialize_node_params (node); | |
186 ipa_detect_param_modifications (node); | |
187 } | |
188 | |
189 /* Return scale for NODE. */ | |
190 static inline gcov_type | |
191 ipcp_get_node_scale (struct cgraph_node *node) | |
192 { | |
193 return IPA_NODE_REF (node)->count_scale; | |
194 } | |
195 | |
196 /* Set COUNT as scale for NODE. */ | |
197 static inline void | |
198 ipcp_set_node_scale (struct cgraph_node *node, gcov_type count) | |
199 { | |
200 IPA_NODE_REF (node)->count_scale = count; | |
201 } | |
202 | |
203 /* Return whether LAT is a constant lattice. */ | |
204 static inline bool | |
205 ipcp_lat_is_const (struct ipcp_lattice *lat) | |
206 { | |
207 if (lat->type == IPA_CONST_VALUE) | |
208 return true; | |
209 else | |
210 return false; | |
211 } | |
212 | |
213 /* Return whether LAT is a constant lattice that ipa-cp can actually insert | |
214 into the code (i.e. constants excluding member pointers and pointers). */ | |
215 static inline bool | |
216 ipcp_lat_is_insertable (struct ipcp_lattice *lat) | |
217 { | |
218 return lat->type == IPA_CONST_VALUE; | |
219 } | |
220 | |
221 /* Return true if LAT1 and LAT2 are equal. */ | |
222 static inline bool | |
223 ipcp_lats_are_equal (struct ipcp_lattice *lat1, struct ipcp_lattice *lat2) | |
224 { | |
225 gcc_assert (ipcp_lat_is_const (lat1) && ipcp_lat_is_const (lat2)); | |
226 if (lat1->type != lat2->type) | |
227 return false; | |
228 | |
229 if (operand_equal_p (lat1->constant, lat2->constant, 0)) | |
230 return true; | |
231 | |
232 return false; | |
233 } | |
234 | |
235 /* Compute Meet arithmetics: | |
236 Meet (IPA_BOTTOM, x) = IPA_BOTTOM | |
237 Meet (IPA_TOP,x) = x | |
238 Meet (const_a,const_b) = IPA_BOTTOM, if const_a != const_b. | |
239 MEET (const_a,const_b) = const_a, if const_a == const_b.*/ | |
240 static void | |
241 ipa_lattice_meet (struct ipcp_lattice *res, struct ipcp_lattice *lat1, | |
242 struct ipcp_lattice *lat2) | |
243 { | |
244 if (lat1->type == IPA_BOTTOM || lat2->type == IPA_BOTTOM) | |
245 { | |
246 res->type = IPA_BOTTOM; | |
247 return; | |
248 } | |
249 if (lat1->type == IPA_TOP) | |
250 { | |
251 res->type = lat2->type; | |
252 res->constant = lat2->constant; | |
253 return; | |
254 } | |
255 if (lat2->type == IPA_TOP) | |
256 { | |
257 res->type = lat1->type; | |
258 res->constant = lat1->constant; | |
259 return; | |
260 } | |
261 if (!ipcp_lats_are_equal (lat1, lat2)) | |
262 { | |
263 res->type = IPA_BOTTOM; | |
264 return; | |
265 } | |
266 res->type = lat1->type; | |
267 res->constant = lat1->constant; | |
268 } | |
269 | |
270 /* Return the lattice corresponding to the Ith formal parameter of the function | |
271 described by INFO. */ | |
272 static inline struct ipcp_lattice * | |
273 ipcp_get_lattice (struct ipa_node_params *info, int i) | |
274 { | |
275 return &(info->params[i].ipcp_lattice); | |
276 } | |
277 | |
278 /* Given the jump function JFUNC, compute the lattice LAT that describes the | |
279 value coming down the callsite. INFO describes the caller node so that | |
280 pass-through jump functions can be evaluated. */ | |
281 static void | |
282 ipcp_lattice_from_jfunc (struct ipa_node_params *info, struct ipcp_lattice *lat, | |
283 struct ipa_jump_func *jfunc) | |
284 { | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
285 if (jfunc->type == IPA_JF_CONST) |
0 | 286 { |
287 lat->type = IPA_CONST_VALUE; | |
288 lat->constant = jfunc->value.constant; | |
289 } | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
290 else if (jfunc->type == IPA_JF_PASS_THROUGH) |
0 | 291 { |
292 struct ipcp_lattice *caller_lat; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
293 tree cst; |
0 | 294 |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
295 caller_lat = ipcp_get_lattice (info, jfunc->value.pass_through.formal_id); |
0 | 296 lat->type = caller_lat->type; |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
297 if (caller_lat->type != IPA_CONST_VALUE) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
298 return; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
299 cst = caller_lat->constant; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
300 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
301 if (jfunc->value.pass_through.operation != NOP_EXPR) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
302 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
303 tree restype; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
304 if (TREE_CODE_CLASS (jfunc->value.pass_through.operation) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
305 == tcc_comparison) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
306 restype = boolean_type_node; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
307 else |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
308 restype = TREE_TYPE (cst); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
309 cst = fold_binary (jfunc->value.pass_through.operation, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
310 restype, cst, jfunc->value.pass_through.operand); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
311 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
312 if (!cst || !is_gimple_ip_invariant (cst)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
313 lat->type = IPA_BOTTOM; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
314 lat->constant = cst; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
315 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
316 else if (jfunc->type == IPA_JF_ANCESTOR) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
317 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
318 struct ipcp_lattice *caller_lat; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
319 tree t; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
320 bool ok; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
321 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
322 caller_lat = ipcp_get_lattice (info, jfunc->value.ancestor.formal_id); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
323 lat->type = caller_lat->type; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
324 if (caller_lat->type != IPA_CONST_VALUE) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
325 return; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
326 if (TREE_CODE (caller_lat->constant) != ADDR_EXPR) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
327 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
328 /* This can happen when the constant is a NULL pointer. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
329 lat->type = IPA_BOTTOM; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
330 return; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
331 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
332 t = TREE_OPERAND (caller_lat->constant, 0); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
333 ok = build_ref_for_offset (&t, TREE_TYPE (t), |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
334 jfunc->value.ancestor.offset, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
335 jfunc->value.ancestor.type, false); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
336 if (!ok) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
337 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
338 lat->type = IPA_BOTTOM; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
339 lat->constant = NULL_TREE; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
340 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
341 else |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
342 lat->constant = build_fold_addr_expr (t); |
0 | 343 } |
344 else | |
345 lat->type = IPA_BOTTOM; | |
346 } | |
347 | |
348 /* True when OLD_LAT and NEW_LAT values are not the same. */ | |
349 | |
350 static bool | |
351 ipcp_lattice_changed (struct ipcp_lattice *old_lat, | |
352 struct ipcp_lattice *new_lat) | |
353 { | |
354 if (old_lat->type == new_lat->type) | |
355 { | |
356 if (!ipcp_lat_is_const (old_lat)) | |
357 return false; | |
358 if (ipcp_lats_are_equal (old_lat, new_lat)) | |
359 return false; | |
360 } | |
361 return true; | |
362 } | |
363 | |
364 /* Print all ipcp_lattices of all functions to F. */ | |
365 static void | |
366 ipcp_print_all_lattices (FILE * f) | |
367 { | |
368 struct cgraph_node *node; | |
369 int i, count; | |
370 | |
371 fprintf (f, "\nLattice:\n"); | |
372 for (node = cgraph_nodes; node; node = node->next) | |
373 { | |
374 struct ipa_node_params *info; | |
375 | |
376 if (!node->analyzed) | |
377 continue; | |
378 info = IPA_NODE_REF (node); | |
379 fprintf (f, " Node: %s:\n", cgraph_node_name (node)); | |
380 count = ipa_get_param_count (info); | |
381 for (i = 0; i < count; i++) | |
382 { | |
383 struct ipcp_lattice *lat = ipcp_get_lattice (info, i); | |
384 | |
385 fprintf (f, " param [%d]: ", i); | |
386 if (lat->type == IPA_CONST_VALUE) | |
387 { | |
388 fprintf (f, "type is CONST "); | |
389 print_generic_expr (f, lat->constant, 0); | |
390 fprintf (f, "\n"); | |
391 } | |
392 else if (lat->type == IPA_TOP) | |
393 fprintf (f, "type is TOP\n"); | |
394 else | |
395 fprintf (f, "type is BOTTOM\n"); | |
396 } | |
397 } | |
398 } | |
399 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
400 /* Return true if ipcp algorithms would allow cloning NODE. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
401 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
402 static bool |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
403 ipcp_versionable_function_p (struct cgraph_node *node) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
404 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
405 tree decl = node->decl; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
406 basic_block bb; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
407 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
408 /* There are a number of generic reasons functions cannot be versioned. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
409 if (!tree_versionable_function_p (decl)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
410 return false; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
411 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
412 /* Removing arguments doesn't work if the function takes varargs. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
413 if (DECL_STRUCT_FUNCTION (decl)->stdarg) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
414 return false; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
415 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
416 /* Removing arguments doesn't work if we use __builtin_apply_args. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
417 FOR_EACH_BB_FN (bb, DECL_STRUCT_FUNCTION (decl)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
418 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
419 gimple_stmt_iterator gsi; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
420 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
421 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
422 const_gimple stmt = gsi_stmt (gsi); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
423 tree t; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
424 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
425 if (!is_gimple_call (stmt)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
426 continue; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
427 t = gimple_call_fndecl (stmt); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
428 if (t == NULL_TREE) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
429 continue; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
430 if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
431 && DECL_FUNCTION_CODE (t) == BUILT_IN_APPLY_ARGS) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
432 return false; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
433 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
434 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
435 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
436 return true; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
437 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
438 |
0 | 439 /* Return true if this NODE is viable candidate for cloning. */ |
440 static bool | |
441 ipcp_cloning_candidate_p (struct cgraph_node *node) | |
442 { | |
443 int n_calls = 0; | |
444 int n_hot_calls = 0; | |
445 gcov_type direct_call_sum = 0; | |
446 struct cgraph_edge *e; | |
447 | |
448 /* We never clone functions that are not visible from outside. | |
449 FIXME: in future we should clone such functions when they are called with | |
450 different constants, but current ipcp implementation is not good on this. | |
451 */ | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
452 if (cgraph_only_called_directly_p (node) || !node->analyzed) |
0 | 453 return false; |
454 | |
455 if (cgraph_function_body_availability (node) <= AVAIL_OVERWRITABLE) | |
456 { | |
457 if (dump_file) | |
458 fprintf (dump_file, "Not considering %s for cloning; body is overwrittable.\n", | |
459 cgraph_node_name (node)); | |
460 return false; | |
461 } | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
462 if (!ipcp_versionable_function_p (node)) |
0 | 463 { |
464 if (dump_file) | |
465 fprintf (dump_file, "Not considering %s for cloning; body is not versionable.\n", | |
466 cgraph_node_name (node)); | |
467 return false; | |
468 } | |
469 for (e = node->callers; e; e = e->next_caller) | |
470 { | |
471 direct_call_sum += e->count; | |
472 n_calls ++; | |
473 if (cgraph_maybe_hot_edge_p (e)) | |
474 n_hot_calls ++; | |
475 } | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
476 |
0 | 477 if (!n_calls) |
478 { | |
479 if (dump_file) | |
480 fprintf (dump_file, "Not considering %s for cloning; no direct calls.\n", | |
481 cgraph_node_name (node)); | |
482 return false; | |
483 } | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
484 if (node->local.inline_summary.self_size < n_calls) |
0 | 485 { |
486 if (dump_file) | |
487 fprintf (dump_file, "Considering %s for cloning; code would shrink.\n", | |
488 cgraph_node_name (node)); | |
489 return true; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
490 } |
0 | 491 |
492 if (!flag_ipa_cp_clone) | |
493 { | |
494 if (dump_file) | |
495 fprintf (dump_file, "Not considering %s for cloning; -fipa-cp-clone disabled.\n", | |
496 cgraph_node_name (node)); | |
497 return false; | |
498 } | |
499 | |
500 if (!optimize_function_for_speed_p (DECL_STRUCT_FUNCTION (node->decl))) | |
501 { | |
502 if (dump_file) | |
503 fprintf (dump_file, "Not considering %s for cloning; optimizing it for size.\n", | |
504 cgraph_node_name (node)); | |
505 return false; | |
506 } | |
507 | |
508 /* When profile is available and function is hot, propagate into it even if | |
509 calls seems cold; constant propagation can improve function's speed | |
510 significandly. */ | |
511 if (max_count) | |
512 { | |
513 if (direct_call_sum > node->count * 90 / 100) | |
514 { | |
515 if (dump_file) | |
516 fprintf (dump_file, "Considering %s for cloning; usually called directly.\n", | |
517 cgraph_node_name (node)); | |
518 return true; | |
519 } | |
520 } | |
521 if (!n_hot_calls) | |
522 { | |
523 if (dump_file) | |
524 fprintf (dump_file, "Not considering %s for cloning; no hot calls.\n", | |
525 cgraph_node_name (node)); | |
19
58ad6c70ea60
update gcc from 4.4.0 to 4.4.1.
kent@firefly.cr.ie.u-ryukyu.ac.jp
parents:
0
diff
changeset
|
526 return false; |
0 | 527 } |
528 if (dump_file) | |
529 fprintf (dump_file, "Considering %s for cloning.\n", | |
530 cgraph_node_name (node)); | |
531 return true; | |
532 } | |
533 | |
534 /* Initialize ipcp_lattices array. The lattices corresponding to supported | |
535 types (integers, real types and Fortran constants defined as const_decls) | |
536 are initialized to IPA_TOP, the rest of them to IPA_BOTTOM. */ | |
537 static void | |
538 ipcp_initialize_node_lattices (struct cgraph_node *node) | |
539 { | |
540 int i; | |
541 struct ipa_node_params *info = IPA_NODE_REF (node); | |
542 enum ipa_lattice_type type; | |
543 | |
544 if (ipa_is_called_with_var_arguments (info)) | |
545 type = IPA_BOTTOM; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
546 else if (cgraph_only_called_directly_p (node)) |
0 | 547 type = IPA_TOP; |
548 /* When cloning is allowed, we can assume that externally visible functions | |
549 are not called. We will compensate this by cloning later. */ | |
550 else if (ipcp_cloning_candidate_p (node)) | |
551 type = IPA_TOP, n_cloning_candidates ++; | |
552 else | |
553 type = IPA_BOTTOM; | |
554 | |
555 for (i = 0; i < ipa_get_param_count (info) ; i++) | |
556 ipcp_get_lattice (info, i)->type = type; | |
557 } | |
558 | |
559 /* build INTEGER_CST tree with type TREE_TYPE and value according to LAT. | |
560 Return the tree. */ | |
561 static tree | |
562 build_const_val (struct ipcp_lattice *lat, tree tree_type) | |
563 { | |
564 tree val; | |
565 | |
566 gcc_assert (ipcp_lat_is_const (lat)); | |
567 val = lat->constant; | |
568 | |
569 if (!useless_type_conversion_p (tree_type, TREE_TYPE (val))) | |
570 { | |
571 if (fold_convertible_p (tree_type, val)) | |
572 return fold_build1 (NOP_EXPR, tree_type, val); | |
573 else | |
574 return fold_build1 (VIEW_CONVERT_EXPR, tree_type, val); | |
575 } | |
576 return val; | |
577 } | |
578 | |
579 /* Compute the proper scale for NODE. It is the ratio between the number of | |
580 direct calls (represented on the incoming cgraph_edges) and sum of all | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
581 invocations of NODE (represented as count in cgraph_node). |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
582 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
583 FIXME: This code is wrong. Since the callers can be also clones and |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
584 the clones are not scaled yet, the sums gets unrealistically high. |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
585 To properly compute the counts, we would need to do propagation across |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
586 callgraph (as external call to A might imply call to non-clonned B |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
587 if A's clone calls clonned B). */ |
0 | 588 static void |
589 ipcp_compute_node_scale (struct cgraph_node *node) | |
590 { | |
591 gcov_type sum; | |
592 struct cgraph_edge *cs; | |
593 | |
594 sum = 0; | |
595 /* Compute sum of all counts of callers. */ | |
596 for (cs = node->callers; cs != NULL; cs = cs->next_caller) | |
597 sum += cs->count; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
598 /* Work around the unrealistically high sum problem. We just don't want |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
599 the non-cloned body to have negative or very low frequency. Since |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
600 majority of execution time will be spent in clones anyway, this should |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
601 give good enough profile. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
602 if (sum > node->count * 9 / 10) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
603 sum = node->count * 9 / 10; |
0 | 604 if (node->count == 0) |
605 ipcp_set_node_scale (node, 0); | |
606 else | |
607 ipcp_set_node_scale (node, sum * REG_BR_PROB_BASE / node->count); | |
608 } | |
609 | |
610 /* Initialization and computation of IPCP data structures. This is the initial | |
611 intraprocedural analysis of functions, which gathers information to be | |
612 propagated later on. */ | |
613 static void | |
614 ipcp_init_stage (void) | |
615 { | |
616 struct cgraph_node *node; | |
617 struct cgraph_edge *cs; | |
618 | |
619 for (node = cgraph_nodes; node; node = node->next) | |
620 if (node->analyzed) | |
621 ipcp_analyze_node (node); | |
622 for (node = cgraph_nodes; node; node = node->next) | |
623 { | |
624 if (!node->analyzed) | |
625 continue; | |
626 /* building jump functions */ | |
627 for (cs = node->callees; cs; cs = cs->next_callee) | |
628 { | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
629 /* We do not need to bother analyzing calls to unknown |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
630 functions unless they may become known during lto/whopr. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
631 if (!cs->callee->analyzed && !flag_lto && !flag_whopr) |
0 | 632 continue; |
633 ipa_count_arguments (cs); | |
634 if (ipa_get_cs_argument_count (IPA_EDGE_REF (cs)) | |
635 != ipa_get_param_count (IPA_NODE_REF (cs->callee))) | |
636 { | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
637 /* Handle cases of functions with |
0 | 638 a variable number of parameters. */ |
639 ipa_set_called_with_variable_arg (IPA_NODE_REF (cs->callee)); | |
640 if (flag_indirect_inlining) | |
641 ipa_compute_jump_functions (cs); | |
642 } | |
643 else | |
644 ipa_compute_jump_functions (cs); | |
645 } | |
646 } | |
647 } | |
648 | |
649 /* Return true if there are some formal parameters whose value is IPA_TOP (in | |
650 the whole compilation unit). Change their values to IPA_BOTTOM, since they | |
651 most probably get their values from outside of this compilation unit. */ | |
652 static bool | |
653 ipcp_change_tops_to_bottom (void) | |
654 { | |
655 int i, count; | |
656 struct cgraph_node *node; | |
657 bool prop_again; | |
658 | |
659 prop_again = false; | |
660 for (node = cgraph_nodes; node; node = node->next) | |
661 { | |
662 struct ipa_node_params *info = IPA_NODE_REF (node); | |
663 count = ipa_get_param_count (info); | |
664 for (i = 0; i < count; i++) | |
665 { | |
666 struct ipcp_lattice *lat = ipcp_get_lattice (info, i); | |
667 if (lat->type == IPA_TOP) | |
668 { | |
669 prop_again = true; | |
670 if (dump_file) | |
671 { | |
672 fprintf (dump_file, "Forcing param "); | |
673 print_generic_expr (dump_file, ipa_get_param (info, i), 0); | |
674 fprintf (dump_file, " of node %s to bottom.\n", | |
675 cgraph_node_name (node)); | |
676 } | |
677 lat->type = IPA_BOTTOM; | |
678 } | |
679 } | |
680 } | |
681 return prop_again; | |
682 } | |
683 | |
684 /* Interprocedural analysis. The algorithm propagates constants from the | |
685 caller's parameters to the callee's arguments. */ | |
686 static void | |
687 ipcp_propagate_stage (void) | |
688 { | |
689 int i; | |
690 struct ipcp_lattice inc_lat = { IPA_BOTTOM, NULL }; | |
691 struct ipcp_lattice new_lat = { IPA_BOTTOM, NULL }; | |
692 struct ipcp_lattice *dest_lat; | |
693 struct cgraph_edge *cs; | |
694 struct ipa_jump_func *jump_func; | |
695 struct ipa_func_list *wl; | |
696 int count; | |
697 | |
698 ipa_check_create_node_params (); | |
699 ipa_check_create_edge_args (); | |
700 | |
701 /* Initialize worklist to contain all functions. */ | |
702 wl = ipa_init_func_list (); | |
703 while (wl) | |
704 { | |
705 struct cgraph_node *node = ipa_pop_func_from_list (&wl); | |
706 struct ipa_node_params *info = IPA_NODE_REF (node); | |
707 | |
708 for (cs = node->callees; cs; cs = cs->next_callee) | |
709 { | |
710 struct ipa_node_params *callee_info = IPA_NODE_REF (cs->callee); | |
711 struct ipa_edge_args *args = IPA_EDGE_REF (cs); | |
712 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
713 if (ipa_is_called_with_var_arguments (callee_info) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
714 || !cs->callee->analyzed |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
715 || ipa_is_called_with_var_arguments (callee_info)) |
0 | 716 continue; |
717 | |
718 count = ipa_get_cs_argument_count (args); | |
719 for (i = 0; i < count; i++) | |
720 { | |
721 jump_func = ipa_get_ith_jump_func (args, i); | |
722 ipcp_lattice_from_jfunc (info, &inc_lat, jump_func); | |
723 dest_lat = ipcp_get_lattice (callee_info, i); | |
724 ipa_lattice_meet (&new_lat, &inc_lat, dest_lat); | |
725 if (ipcp_lattice_changed (&new_lat, dest_lat)) | |
726 { | |
727 dest_lat->type = new_lat.type; | |
728 dest_lat->constant = new_lat.constant; | |
729 ipa_push_func_to_list (&wl, cs->callee); | |
730 } | |
731 } | |
732 } | |
733 } | |
734 } | |
735 | |
736 /* Call the constant propagation algorithm and re-call it if necessary | |
737 (if there are undetermined values left). */ | |
738 static void | |
739 ipcp_iterate_stage (void) | |
740 { | |
741 struct cgraph_node *node; | |
742 n_cloning_candidates = 0; | |
743 | |
744 if (dump_file) | |
745 fprintf (dump_file, "\nIPA iterate stage:\n\n"); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
746 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
747 if (in_lto_p) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
748 ipa_update_after_lto_read (); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
749 |
0 | 750 for (node = cgraph_nodes; node; node = node->next) |
751 { | |
752 ipcp_initialize_node_lattices (node); | |
753 ipcp_compute_node_scale (node); | |
754 } | |
755 if (dump_file && (dump_flags & TDF_DETAILS)) | |
756 { | |
757 ipcp_print_all_lattices (dump_file); | |
758 ipcp_function_scale_print (dump_file); | |
759 } | |
760 | |
761 ipcp_propagate_stage (); | |
762 if (ipcp_change_tops_to_bottom ()) | |
763 /* Some lattices have changed from IPA_TOP to IPA_BOTTOM. | |
764 This change should be propagated. */ | |
765 { | |
766 gcc_assert (n_cloning_candidates); | |
767 ipcp_propagate_stage (); | |
768 } | |
769 if (dump_file) | |
770 { | |
771 fprintf (dump_file, "\nIPA lattices after propagation:\n"); | |
772 ipcp_print_all_lattices (dump_file); | |
773 if (dump_flags & TDF_DETAILS) | |
774 ipcp_print_profile_data (dump_file); | |
775 } | |
776 } | |
777 | |
778 /* Check conditions to forbid constant insertion to function described by | |
779 NODE. */ | |
780 static inline bool | |
781 ipcp_node_modifiable_p (struct cgraph_node *node) | |
782 { | |
783 /* Once we will be able to do in-place replacement, we can be more | |
784 lax here. */ | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
785 return ipcp_versionable_function_p (node); |
0 | 786 } |
787 | |
788 /* Print count scale data structures. */ | |
789 static void | |
790 ipcp_function_scale_print (FILE * f) | |
791 { | |
792 struct cgraph_node *node; | |
793 | |
794 for (node = cgraph_nodes; node; node = node->next) | |
795 { | |
796 if (!node->analyzed) | |
797 continue; | |
798 fprintf (f, "printing scale for %s: ", cgraph_node_name (node)); | |
799 fprintf (f, "value is " HOST_WIDE_INT_PRINT_DEC | |
800 " \n", (HOST_WIDE_INT) ipcp_get_node_scale (node)); | |
801 } | |
802 } | |
803 | |
804 /* Print counts of all cgraph nodes. */ | |
805 static void | |
806 ipcp_print_func_profile_counts (FILE * f) | |
807 { | |
808 struct cgraph_node *node; | |
809 | |
810 for (node = cgraph_nodes; node; node = node->next) | |
811 { | |
812 fprintf (f, "function %s: ", cgraph_node_name (node)); | |
813 fprintf (f, "count is " HOST_WIDE_INT_PRINT_DEC | |
814 " \n", (HOST_WIDE_INT) node->count); | |
815 } | |
816 } | |
817 | |
818 /* Print counts of all cgraph edges. */ | |
819 static void | |
820 ipcp_print_call_profile_counts (FILE * f) | |
821 { | |
822 struct cgraph_node *node; | |
823 struct cgraph_edge *cs; | |
824 | |
825 for (node = cgraph_nodes; node; node = node->next) | |
826 { | |
827 for (cs = node->callees; cs; cs = cs->next_callee) | |
828 { | |
829 fprintf (f, "%s -> %s ", cgraph_node_name (cs->caller), | |
830 cgraph_node_name (cs->callee)); | |
831 fprintf (f, "count is " HOST_WIDE_INT_PRINT_DEC " \n", | |
832 (HOST_WIDE_INT) cs->count); | |
833 } | |
834 } | |
835 } | |
836 | |
837 /* Print profile info for all functions. */ | |
838 static void | |
839 ipcp_print_profile_data (FILE * f) | |
840 { | |
841 fprintf (f, "\nNODE COUNTS :\n"); | |
842 ipcp_print_func_profile_counts (f); | |
843 fprintf (f, "\nCS COUNTS stage:\n"); | |
844 ipcp_print_call_profile_counts (f); | |
845 } | |
846 | |
847 /* Build and initialize ipa_replace_map struct according to LAT. This struct is | |
848 processed by versioning, which operates according to the flags set. | |
849 PARM_TREE is the formal parameter found to be constant. LAT represents the | |
850 constant. */ | |
851 static struct ipa_replace_map * | |
852 ipcp_create_replace_map (tree parm_tree, struct ipcp_lattice *lat) | |
853 { | |
854 struct ipa_replace_map *replace_map; | |
855 tree const_val; | |
856 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
857 replace_map = GGC_NEW (struct ipa_replace_map); |
0 | 858 const_val = build_const_val (lat, TREE_TYPE (parm_tree)); |
859 if (dump_file) | |
860 { | |
861 fprintf (dump_file, " replacing param "); | |
862 print_generic_expr (dump_file, parm_tree, 0); | |
863 fprintf (dump_file, " with const "); | |
864 print_generic_expr (dump_file, const_val, 0); | |
865 fprintf (dump_file, "\n"); | |
866 } | |
867 replace_map->old_tree = parm_tree; | |
868 replace_map->new_tree = const_val; | |
869 replace_map->replace_p = true; | |
870 replace_map->ref_p = false; | |
871 | |
872 return replace_map; | |
873 } | |
874 | |
875 /* Return true if this callsite should be redirected to the original callee | |
876 (instead of the cloned one). */ | |
877 static bool | |
878 ipcp_need_redirect_p (struct cgraph_edge *cs) | |
879 { | |
880 struct ipa_node_params *orig_callee_info; | |
881 int i, count; | |
882 struct ipa_jump_func *jump_func; | |
883 struct cgraph_node *node = cs->callee, *orig; | |
884 | |
885 if (!n_cloning_candidates) | |
886 return false; | |
887 | |
888 if ((orig = ipcp_get_orig_node (node)) != NULL) | |
889 node = orig; | |
890 if (ipcp_get_orig_node (cs->caller)) | |
891 return false; | |
892 | |
893 orig_callee_info = IPA_NODE_REF (node); | |
894 count = ipa_get_param_count (orig_callee_info); | |
895 for (i = 0; i < count; i++) | |
896 { | |
897 struct ipcp_lattice *lat = ipcp_get_lattice (orig_callee_info, i); | |
898 if (ipcp_lat_is_const (lat)) | |
899 { | |
900 jump_func = ipa_get_ith_jump_func (IPA_EDGE_REF (cs), i); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
901 if (jump_func->type != IPA_JF_CONST) |
0 | 902 return true; |
903 } | |
904 } | |
905 | |
906 return false; | |
907 } | |
908 | |
909 /* Fix the callsites and the call graph after function cloning was done. */ | |
910 static void | |
911 ipcp_update_callgraph (void) | |
912 { | |
913 struct cgraph_node *node; | |
914 | |
915 for (node = cgraph_nodes; node; node = node->next) | |
916 if (node->analyzed && ipcp_node_is_clone (node)) | |
917 { | |
918 bitmap args_to_skip = BITMAP_ALLOC (NULL); | |
919 struct cgraph_node *orig_node = ipcp_get_orig_node (node); | |
920 struct ipa_node_params *info = IPA_NODE_REF (orig_node); | |
921 int i, count = ipa_get_param_count (info); | |
922 struct cgraph_edge *cs, *next; | |
923 | |
924 for (i = 0; i < count; i++) | |
925 { | |
926 struct ipcp_lattice *lat = ipcp_get_lattice (info, i); | |
927 tree parm_tree = ipa_get_param (info, i); | |
928 | |
929 /* We can proactively remove obviously unused arguments. */ | |
930 if (is_gimple_reg (parm_tree) | |
931 && !gimple_default_def (DECL_STRUCT_FUNCTION (orig_node->decl), | |
932 parm_tree)) | |
933 { | |
934 bitmap_set_bit (args_to_skip, i); | |
935 continue; | |
936 } | |
937 | |
938 if (lat->type == IPA_CONST_VALUE) | |
939 bitmap_set_bit (args_to_skip, i); | |
940 } | |
941 for (cs = node->callers; cs; cs = next) | |
942 { | |
943 next = cs->next_caller; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
944 if (!ipcp_node_is_clone (cs->caller) && ipcp_need_redirect_p (cs)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
945 cgraph_redirect_edge_callee (cs, orig_node); |
0 | 946 } |
947 } | |
948 } | |
949 | |
950 /* Update profiling info for versioned functions and the functions they were | |
951 versioned from. */ | |
952 static void | |
953 ipcp_update_profiling (void) | |
954 { | |
955 struct cgraph_node *node, *orig_node; | |
956 gcov_type scale, scale_complement; | |
957 struct cgraph_edge *cs; | |
958 | |
959 for (node = cgraph_nodes; node; node = node->next) | |
960 { | |
961 if (ipcp_node_is_clone (node)) | |
962 { | |
963 orig_node = ipcp_get_orig_node (node); | |
964 scale = ipcp_get_node_scale (orig_node); | |
965 node->count = orig_node->count * scale / REG_BR_PROB_BASE; | |
966 scale_complement = REG_BR_PROB_BASE - scale; | |
967 orig_node->count = | |
968 orig_node->count * scale_complement / REG_BR_PROB_BASE; | |
969 for (cs = node->callees; cs; cs = cs->next_callee) | |
970 cs->count = cs->count * scale / REG_BR_PROB_BASE; | |
971 for (cs = orig_node->callees; cs; cs = cs->next_callee) | |
972 cs->count = cs->count * scale_complement / REG_BR_PROB_BASE; | |
973 } | |
974 } | |
975 } | |
976 | |
977 /* If NODE was cloned, how much would program grow? */ | |
978 static long | |
979 ipcp_estimate_growth (struct cgraph_node *node) | |
980 { | |
981 struct cgraph_edge *cs; | |
982 int redirectable_node_callers = 0; | |
983 int removable_args = 0; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
984 bool need_original = !cgraph_only_called_directly_p (node); |
0 | 985 struct ipa_node_params *info; |
986 int i, count; | |
987 int growth; | |
988 | |
989 for (cs = node->callers; cs != NULL; cs = cs->next_caller) | |
990 if (cs->caller == node || !ipcp_need_redirect_p (cs)) | |
991 redirectable_node_callers++; | |
992 else | |
993 need_original = true; | |
994 | |
995 /* If we will be able to fully replace orignal node, we never increase | |
996 program size. */ | |
997 if (!need_original) | |
998 return 0; | |
999 | |
1000 info = IPA_NODE_REF (node); | |
1001 count = ipa_get_param_count (info); | |
1002 for (i = 0; i < count; i++) | |
1003 { | |
1004 struct ipcp_lattice *lat = ipcp_get_lattice (info, i); | |
1005 tree parm_tree = ipa_get_param (info, i); | |
1006 | |
1007 /* We can proactively remove obviously unused arguments. */ | |
1008 if (is_gimple_reg (parm_tree) | |
1009 && !gimple_default_def (DECL_STRUCT_FUNCTION (node->decl), | |
1010 parm_tree)) | |
1011 removable_args++; | |
1012 | |
1013 if (lat->type == IPA_CONST_VALUE) | |
1014 removable_args++; | |
1015 } | |
1016 | |
1017 /* We make just very simple estimate of savings for removal of operand from | |
1018 call site. Precise cost is dificult to get, as our size metric counts | |
1019 constants and moves as free. Generally we are looking for cases that | |
1020 small function is called very many times. */ | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1021 growth = node->local.inline_summary.self_size |
0 | 1022 - removable_args * redirectable_node_callers; |
1023 if (growth < 0) | |
1024 return 0; | |
1025 return growth; | |
1026 } | |
1027 | |
1028 | |
1029 /* Estimate cost of cloning NODE. */ | |
1030 static long | |
1031 ipcp_estimate_cloning_cost (struct cgraph_node *node) | |
1032 { | |
1033 int freq_sum = 1; | |
1034 gcov_type count_sum = 1; | |
1035 struct cgraph_edge *e; | |
1036 int cost; | |
1037 | |
1038 cost = ipcp_estimate_growth (node) * 1000; | |
1039 if (!cost) | |
1040 { | |
1041 if (dump_file) | |
1042 fprintf (dump_file, "Versioning of %s will save code size\n", | |
1043 cgraph_node_name (node)); | |
1044 return 0; | |
1045 } | |
1046 | |
1047 for (e = node->callers; e; e = e->next_caller) | |
1048 if (!bitmap_bit_p (dead_nodes, e->caller->uid) | |
1049 && !ipcp_need_redirect_p (e)) | |
1050 { | |
1051 count_sum += e->count; | |
1052 freq_sum += e->frequency + 1; | |
1053 } | |
1054 | |
1055 if (max_count) | |
1056 cost /= count_sum * 1000 / max_count + 1; | |
1057 else | |
1058 cost /= freq_sum * 1000 / REG_BR_PROB_BASE + 1; | |
1059 if (dump_file) | |
1060 fprintf (dump_file, "Cost of versioning %s is %i, (size: %i, freq: %i)\n", | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1061 cgraph_node_name (node), cost, node->local.inline_summary.self_size, |
0 | 1062 freq_sum); |
1063 return cost + 1; | |
1064 } | |
1065 | |
1066 /* Return number of live constant parameters. */ | |
1067 static int | |
1068 ipcp_const_param_count (struct cgraph_node *node) | |
1069 { | |
1070 int const_param = 0; | |
1071 struct ipa_node_params *info = IPA_NODE_REF (node); | |
1072 int count = ipa_get_param_count (info); | |
1073 int i; | |
1074 | |
1075 for (i = 0; i < count; i++) | |
1076 { | |
1077 struct ipcp_lattice *lat = ipcp_get_lattice (info, i); | |
1078 tree parm_tree = ipa_get_param (info, i); | |
1079 if (ipcp_lat_is_insertable (lat) | |
1080 /* Do not count obviously unused arguments. */ | |
1081 && (!is_gimple_reg (parm_tree) | |
1082 || gimple_default_def (DECL_STRUCT_FUNCTION (node->decl), | |
1083 parm_tree))) | |
1084 const_param++; | |
1085 } | |
1086 return const_param; | |
1087 } | |
1088 | |
1089 /* Propagate the constant parameters found by ipcp_iterate_stage() | |
1090 to the function's code. */ | |
1091 static void | |
1092 ipcp_insert_stage (void) | |
1093 { | |
1094 struct cgraph_node *node, *node1 = NULL; | |
1095 int i; | |
1096 VEC (cgraph_edge_p, heap) * redirect_callers; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1097 VEC (ipa_replace_map_p,gc)* replace_trees; |
0 | 1098 int node_callers, count; |
1099 tree parm_tree; | |
1100 struct ipa_replace_map *replace_param; | |
1101 fibheap_t heap; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1102 long overall_size = 0, new_size = 0; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1103 long max_new_size; |
0 | 1104 |
1105 ipa_check_create_node_params (); | |
1106 ipa_check_create_edge_args (); | |
1107 if (dump_file) | |
1108 fprintf (dump_file, "\nIPA insert stage:\n\n"); | |
1109 | |
1110 dead_nodes = BITMAP_ALLOC (NULL); | |
1111 | |
1112 for (node = cgraph_nodes; node; node = node->next) | |
1113 if (node->analyzed) | |
1114 { | |
1115 if (node->count > max_count) | |
1116 max_count = node->count; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1117 overall_size += node->local.inline_summary.self_size; |
0 | 1118 } |
1119 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1120 max_new_size = overall_size; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1121 if (max_new_size < PARAM_VALUE (PARAM_LARGE_UNIT_INSNS)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1122 max_new_size = PARAM_VALUE (PARAM_LARGE_UNIT_INSNS); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1123 max_new_size = max_new_size * PARAM_VALUE (PARAM_IPCP_UNIT_GROWTH) / 100 + 1; |
0 | 1124 |
1125 /* First collect all functions we proved to have constant arguments to heap. */ | |
1126 heap = fibheap_new (); | |
1127 for (node = cgraph_nodes; node; node = node->next) | |
1128 { | |
1129 struct ipa_node_params *info; | |
1130 /* Propagation of the constant is forbidden in certain conditions. */ | |
1131 if (!node->analyzed || !ipcp_node_modifiable_p (node)) | |
1132 continue; | |
1133 info = IPA_NODE_REF (node); | |
1134 if (ipa_is_called_with_var_arguments (info)) | |
1135 continue; | |
1136 if (ipcp_const_param_count (node)) | |
1137 node->aux = fibheap_insert (heap, ipcp_estimate_cloning_cost (node), node); | |
1138 } | |
1139 | |
1140 /* Now clone in priority order until code size growth limits are met or | |
1141 heap is emptied. */ | |
1142 while (!fibheap_empty (heap)) | |
1143 { | |
1144 struct ipa_node_params *info; | |
1145 int growth = 0; | |
1146 bitmap args_to_skip; | |
1147 struct cgraph_edge *cs; | |
1148 | |
1149 node = (struct cgraph_node *)fibheap_extract_min (heap); | |
1150 node->aux = NULL; | |
1151 if (dump_file) | |
1152 fprintf (dump_file, "considering function %s\n", | |
1153 cgraph_node_name (node)); | |
1154 | |
1155 growth = ipcp_estimate_growth (node); | |
1156 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1157 if (new_size + growth > max_new_size) |
0 | 1158 break; |
1159 if (growth | |
1160 && optimize_function_for_size_p (DECL_STRUCT_FUNCTION (node->decl))) | |
1161 { | |
1162 if (dump_file) | |
1163 fprintf (dump_file, "Not versioning, cold code would grow"); | |
1164 continue; | |
1165 } | |
1166 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1167 new_size += growth; |
0 | 1168 |
1169 /* Look if original function becomes dead after clonning. */ | |
1170 for (cs = node->callers; cs != NULL; cs = cs->next_caller) | |
1171 if (cs->caller == node || ipcp_need_redirect_p (cs)) | |
1172 break; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1173 if (!cs && cgraph_only_called_directly_p (node)) |
0 | 1174 bitmap_set_bit (dead_nodes, node->uid); |
1175 | |
1176 info = IPA_NODE_REF (node); | |
1177 count = ipa_get_param_count (info); | |
1178 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1179 replace_trees = VEC_alloc (ipa_replace_map_p, gc, 1); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1180 args_to_skip = BITMAP_GGC_ALLOC (); |
0 | 1181 for (i = 0; i < count; i++) |
1182 { | |
1183 struct ipcp_lattice *lat = ipcp_get_lattice (info, i); | |
1184 parm_tree = ipa_get_param (info, i); | |
1185 | |
1186 /* We can proactively remove obviously unused arguments. */ | |
1187 if (is_gimple_reg (parm_tree) | |
1188 && !gimple_default_def (DECL_STRUCT_FUNCTION (node->decl), | |
1189 parm_tree)) | |
1190 { | |
1191 bitmap_set_bit (args_to_skip, i); | |
1192 continue; | |
1193 } | |
1194 | |
1195 if (lat->type == IPA_CONST_VALUE) | |
1196 { | |
1197 replace_param = | |
1198 ipcp_create_replace_map (parm_tree, lat); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1199 VEC_safe_push (ipa_replace_map_p, gc, replace_trees, replace_param); |
0 | 1200 bitmap_set_bit (args_to_skip, i); |
1201 } | |
1202 } | |
1203 | |
1204 /* Compute how many callers node has. */ | |
1205 node_callers = 0; | |
1206 for (cs = node->callers; cs != NULL; cs = cs->next_caller) | |
1207 node_callers++; | |
1208 redirect_callers = VEC_alloc (cgraph_edge_p, heap, node_callers); | |
1209 for (cs = node->callers; cs != NULL; cs = cs->next_caller) | |
1210 VEC_quick_push (cgraph_edge_p, redirect_callers, cs); | |
1211 | |
1212 /* Redirecting all the callers of the node to the | |
1213 new versioned node. */ | |
1214 node1 = | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1215 cgraph_create_virtual_clone (node, redirect_callers, replace_trees, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1216 args_to_skip); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1217 args_to_skip = NULL; |
0 | 1218 VEC_free (cgraph_edge_p, heap, redirect_callers); |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1219 replace_trees = NULL; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1220 |
0 | 1221 if (node1 == NULL) |
1222 continue; | |
1223 if (dump_file) | |
1224 fprintf (dump_file, "versioned function %s with growth %i, overall %i\n", | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1225 cgraph_node_name (node), (int)growth, (int)new_size); |
0 | 1226 ipcp_init_cloned_node (node, node1); |
1227 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1228 /* TODO: We can use indirect inlning info to produce new calls. */ |
0 | 1229 |
1230 if (dump_file) | |
1231 dump_function_to_file (node1->decl, dump_file, dump_flags); | |
1232 | |
1233 for (cs = node->callees; cs; cs = cs->next_callee) | |
1234 if (cs->callee->aux) | |
1235 { | |
1236 fibheap_delete_node (heap, (fibnode_t) cs->callee->aux); | |
1237 cs->callee->aux = fibheap_insert (heap, | |
1238 ipcp_estimate_cloning_cost (cs->callee), | |
1239 cs->callee); | |
1240 } | |
1241 } | |
1242 | |
1243 while (!fibheap_empty (heap)) | |
1244 { | |
1245 if (dump_file) | |
1246 fprintf (dump_file, "skipping function %s\n", | |
1247 cgraph_node_name (node)); | |
1248 node = (struct cgraph_node *) fibheap_extract_min (heap); | |
1249 node->aux = NULL; | |
1250 } | |
1251 fibheap_delete (heap); | |
1252 BITMAP_FREE (dead_nodes); | |
1253 ipcp_update_callgraph (); | |
1254 ipcp_update_profiling (); | |
1255 } | |
1256 | |
1257 /* The IPCP driver. */ | |
1258 static unsigned int | |
1259 ipcp_driver (void) | |
1260 { | |
1261 cgraph_remove_unreachable_nodes (true,dump_file); | |
1262 if (dump_file) | |
1263 { | |
1264 fprintf (dump_file, "\nIPA structures before propagation:\n"); | |
1265 if (dump_flags & TDF_DETAILS) | |
1266 ipa_print_all_params (dump_file); | |
1267 ipa_print_all_jump_functions (dump_file); | |
1268 } | |
1269 /* 2. Do the interprocedural propagation. */ | |
1270 ipcp_iterate_stage (); | |
1271 /* 3. Insert the constants found to the functions. */ | |
1272 ipcp_insert_stage (); | |
1273 if (dump_file && (dump_flags & TDF_DETAILS)) | |
1274 { | |
1275 fprintf (dump_file, "\nProfiling info after insert stage:\n"); | |
1276 ipcp_print_profile_data (dump_file); | |
1277 } | |
1278 /* Free all IPCP structures. */ | |
1279 free_all_ipa_structures_after_ipa_cp (); | |
1280 if (dump_file) | |
1281 fprintf (dump_file, "\nIPA constant propagation end\n"); | |
1282 return 0; | |
1283 } | |
1284 | |
1285 /* Note function body size. */ | |
1286 static void | |
1287 ipcp_generate_summary (void) | |
1288 { | |
1289 if (dump_file) | |
1290 fprintf (dump_file, "\nIPA constant propagation start:\n"); | |
1291 ipa_check_create_node_params (); | |
1292 ipa_check_create_edge_args (); | |
1293 ipa_register_cgraph_hooks (); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1294 /* 1. Call the init stage to initialize |
0 | 1295 the ipa_node_params and ipa_edge_args structures. */ |
1296 ipcp_init_stage (); | |
1297 } | |
1298 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1299 /* Write ipcp summary for nodes in SET. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1300 static void |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1301 ipcp_write_summary (cgraph_node_set set) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1302 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1303 ipa_prop_write_jump_functions (set); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1304 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1305 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1306 /* Read ipcp summary. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1307 static void |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1308 ipcp_read_summary (void) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1309 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1310 ipa_prop_read_jump_functions (); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1311 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1312 |
0 | 1313 /* Gate for IPCP optimization. */ |
1314 static bool | |
1315 cgraph_gate_cp (void) | |
1316 { | |
1317 return flag_ipa_cp; | |
1318 } | |
1319 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1320 struct ipa_opt_pass_d pass_ipa_cp = |
0 | 1321 { |
1322 { | |
1323 IPA_PASS, | |
1324 "cp", /* name */ | |
1325 cgraph_gate_cp, /* gate */ | |
1326 ipcp_driver, /* execute */ | |
1327 NULL, /* sub */ | |
1328 NULL, /* next */ | |
1329 0, /* static_pass_number */ | |
1330 TV_IPA_CONSTANT_PROP, /* tv_id */ | |
1331 0, /* properties_required */ | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1332 0, /* properties_provided */ |
0 | 1333 0, /* properties_destroyed */ |
1334 0, /* todo_flags_start */ | |
1335 TODO_dump_cgraph | TODO_dump_func | | |
1336 TODO_remove_functions /* todo_flags_finish */ | |
1337 }, | |
1338 ipcp_generate_summary, /* generate_summary */ | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1339 ipcp_write_summary, /* write_summary */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1340 ipcp_read_summary, /* read_summary */ |
0 | 1341 NULL, /* function_read_summary */ |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1342 lto_ipa_fixup_call_notes, /* stmt_fixup */ |
0 | 1343 0, /* TODOs */ |
1344 NULL, /* function_transform */ | |
1345 NULL, /* variable_transform */ | |
1346 }; |