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 }; |