Mercurial > hg > CbC > CbC_gcc
annotate gcc/ipa-inline.c @ 63:b7f97abdc517 gcc-4.6-20100522
update gcc from gcc-4.5.0 to gcc-4.6
| author | ryoma <e075725@ie.u-ryukyu.ac.jp> |
|---|---|
| date | Mon, 24 May 2010 12:47:05 +0900 |
| parents | 77e2b8dfacca |
| children | f6334be47118 |
| rev | line source |
|---|---|
| 0 | 1 /* Inlining decision heuristics. |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2 Copyright (C) 2003, 2004, 2007, 2008, 2009, 2010 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
3 Free Software Foundation, Inc. |
| 0 | 4 Contributed by Jan Hubicka |
| 5 | |
| 6 This file is part of GCC. | |
| 7 | |
| 8 GCC is free software; you can redistribute it and/or modify it under | |
| 9 the terms of the GNU General Public License as published by the Free | |
| 10 Software Foundation; either version 3, or (at your option) any later | |
| 11 version. | |
| 12 | |
| 13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
| 14 WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 16 for more details. | |
| 17 | |
| 18 You should have received a copy of the GNU General Public License | |
| 19 along with GCC; see the file COPYING3. If not see | |
| 20 <http://www.gnu.org/licenses/>. */ | |
| 21 | |
| 22 /* Inlining decision heuristics | |
| 23 | |
| 24 We separate inlining decisions from the inliner itself and store it | |
| 25 inside callgraph as so called inline plan. Refer to cgraph.c | |
| 26 documentation about particular representation of inline plans in the | |
| 27 callgraph. | |
| 28 | |
| 29 There are three major parts of this file: | |
| 30 | |
| 31 cgraph_mark_inline implementation | |
| 32 | |
| 33 This function allows to mark given call inline and performs necessary | |
| 34 modifications of cgraph (production of the clones and updating overall | |
| 35 statistics) | |
| 36 | |
| 37 inlining heuristics limits | |
| 38 | |
| 39 These functions allow to check that particular inlining is allowed | |
| 40 by the limits specified by user (allowed function growth, overall unit | |
| 41 growth and so on). | |
| 42 | |
| 43 inlining heuristics | |
| 44 | |
| 45 This is implementation of IPA pass aiming to get as much of benefit | |
| 46 from inlining obeying the limits checked above. | |
| 47 | |
| 48 The implementation of particular heuristics is separated from | |
| 49 the rest of code to make it easier to replace it with more complicated | |
| 50 implementation in the future. The rest of inlining code acts as a | |
| 51 library aimed to modify the callgraph and verify that the parameters | |
| 52 on code size growth fits. | |
| 53 | |
| 54 To mark given call inline, use cgraph_mark_inline function, the | |
| 55 verification is performed by cgraph_default_inline_p and | |
| 56 cgraph_check_inline_limits. | |
| 57 | |
| 58 The heuristics implements simple knapsack style algorithm ordering | |
| 59 all functions by their "profitability" (estimated by code size growth) | |
| 60 and inlining them in priority order. | |
| 61 | |
| 62 cgraph_decide_inlining implements heuristics taking whole callgraph | |
| 63 into account, while cgraph_decide_inlining_incrementally considers | |
| 64 only one function at a time and is used by early inliner. | |
| 65 | |
| 66 The inliner itself is split into several passes: | |
| 67 | |
| 68 pass_inline_parameters | |
| 69 | |
| 70 This pass computes local properties of functions that are used by inliner: | |
| 71 estimated function body size, whether function is inlinable at all and | |
| 72 stack frame consumption. | |
| 73 | |
| 74 Before executing any of inliner passes, this local pass has to be applied | |
| 75 to each function in the callgraph (ie run as subpass of some earlier | |
| 76 IPA pass). The results are made out of date by any optimization applied | |
| 77 on the function body. | |
| 78 | |
| 79 pass_early_inlining | |
| 80 | |
| 81 Simple local inlining pass inlining callees into current function. This | |
| 82 pass makes no global whole compilation unit analysis and this when allowed | |
| 83 to do inlining expanding code size it might result in unbounded growth of | |
| 84 whole unit. | |
| 85 | |
| 86 The pass is run during conversion into SSA form. Only functions already | |
| 87 converted into SSA form are inlined, so the conversion must happen in | |
| 88 topological order on the callgraph (that is maintained by pass manager). | |
| 89 The functions after inlining are early optimized so the early inliner sees | |
| 90 unoptimized function itself, but all considered callees are already | |
| 91 optimized allowing it to unfold abstraction penalty on C++ effectively and | |
| 92 cheaply. | |
| 93 | |
| 94 pass_ipa_early_inlining | |
| 95 | |
| 96 With profiling, the early inlining is also necessary to reduce | |
| 97 instrumentation costs on program with high abstraction penalty (doing | |
| 98 many redundant calls). This can't happen in parallel with early | |
| 99 optimization and profile instrumentation, because we would end up | |
| 100 re-instrumenting already instrumented function bodies we brought in via | |
| 101 inlining. | |
| 102 | |
| 103 To avoid this, this pass is executed as IPA pass before profiling. It is | |
| 104 simple wrapper to pass_early_inlining and ensures first inlining. | |
| 105 | |
| 106 pass_ipa_inline | |
| 107 | |
| 108 This is the main pass implementing simple greedy algorithm to do inlining | |
| 109 of small functions that results in overall growth of compilation unit and | |
| 110 inlining of functions called once. The pass compute just so called inline | |
| 111 plan (representation of inlining to be done in callgraph) and unlike early | |
| 112 inlining it is not performing the inlining itself. | |
| 113 | |
| 114 pass_apply_inline | |
| 115 | |
| 116 This pass performs actual inlining according to pass_ipa_inline on given | |
| 117 function. Possible the function body before inlining is saved when it is | |
| 118 needed for further inlining later. | |
| 119 */ | |
| 120 | |
| 121 #include "config.h" | |
| 122 #include "system.h" | |
| 123 #include "coretypes.h" | |
| 124 #include "tm.h" | |
| 125 #include "tree.h" | |
| 126 #include "tree-inline.h" | |
| 127 #include "langhooks.h" | |
| 128 #include "flags.h" | |
| 129 #include "cgraph.h" | |
| 130 #include "diagnostic.h" | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
131 #include "gimple-pretty-print.h" |
| 0 | 132 #include "timevar.h" |
| 133 #include "params.h" | |
| 134 #include "fibheap.h" | |
| 135 #include "intl.h" | |
| 136 #include "tree-pass.h" | |
| 137 #include "hashtab.h" | |
| 138 #include "coverage.h" | |
| 139 #include "ggc.h" | |
| 140 #include "tree-flow.h" | |
| 141 #include "rtl.h" | |
| 142 #include "ipa-prop.h" | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
143 #include "except.h" |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
144 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
145 #define MAX_TIME 1000000000 |
| 0 | 146 |
| 147 /* Mode incremental inliner operate on: | |
| 148 | |
| 149 In ALWAYS_INLINE only functions marked | |
| 150 always_inline are inlined. This mode is used after detecting cycle during | |
| 151 flattening. | |
| 152 | |
| 153 In SIZE mode, only functions that reduce function body size after inlining | |
| 154 are inlined, this is used during early inlining. | |
| 155 | |
| 156 in ALL mode, everything is inlined. This is used during flattening. */ | |
| 157 enum inlining_mode { | |
| 158 INLINE_NONE = 0, | |
| 159 INLINE_ALWAYS_INLINE, | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
160 INLINE_SIZE_NORECURSIVE, |
| 0 | 161 INLINE_SIZE, |
| 162 INLINE_ALL | |
| 163 }; | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
164 |
| 0 | 165 static bool |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
166 cgraph_decide_inlining_incrementally (struct cgraph_node *, enum inlining_mode); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
167 static void cgraph_flatten (struct cgraph_node *node); |
| 0 | 168 |
| 169 | |
| 170 /* Statistics we collect about inlining algorithm. */ | |
| 171 static int ncalls_inlined; | |
| 172 static int nfunctions_inlined; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
173 static int overall_size; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
174 static gcov_type max_count, max_benefit; |
| 0 | 175 |
| 176 /* Holders of ipa cgraph hooks: */ | |
| 177 static struct cgraph_node_hook_list *function_insertion_hook_holder; | |
| 178 | |
| 179 static inline struct inline_summary * | |
| 180 inline_summary (struct cgraph_node *node) | |
| 181 { | |
| 182 return &node->local.inline_summary; | |
| 183 } | |
| 184 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
185 /* Estimate self time of the function after inlining WHAT into TO. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
186 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
187 static int |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
188 cgraph_estimate_time_after_inlining (int frequency, struct cgraph_node *to, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
189 struct cgraph_node *what) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
190 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
191 gcov_type time = (((gcov_type)what->global.time |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
192 - inline_summary (what)->time_inlining_benefit) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
193 * frequency + CGRAPH_FREQ_BASE / 2) / CGRAPH_FREQ_BASE |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
194 + to->global.time; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
195 if (time < 0) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
196 time = 0; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
197 if (time > MAX_TIME) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
198 time = MAX_TIME; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
199 return time; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
200 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
201 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
202 /* Estimate self time of the function after inlining WHAT into TO. */ |
| 0 | 203 |
| 204 static int | |
| 205 cgraph_estimate_size_after_inlining (int times, struct cgraph_node *to, | |
| 206 struct cgraph_node *what) | |
| 207 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
208 int size = (what->global.size - inline_summary (what)->size_inlining_benefit) * times + to->global.size; |
| 0 | 209 gcc_assert (size >= 0); |
| 210 return size; | |
| 211 } | |
| 212 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
213 /* Scale frequency of NODE edges by FREQ_SCALE and increase loop nest |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
214 by NEST. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
215 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
216 static void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
217 update_noncloned_frequencies (struct cgraph_node *node, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
218 int freq_scale, int nest) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
219 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
220 struct cgraph_edge *e; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
221 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
222 /* We do not want to ignore high loop nest after freq drops to 0. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
223 if (!freq_scale) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
224 freq_scale = 1; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
225 for (e = node->callees; e; e = e->next_callee) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
226 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
227 e->loop_nest += nest; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
228 e->frequency = e->frequency * (gcov_type) freq_scale / CGRAPH_FREQ_BASE; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
229 if (e->frequency > CGRAPH_FREQ_MAX) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
230 e->frequency = CGRAPH_FREQ_MAX; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
231 if (!e->inline_failed) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
232 update_noncloned_frequencies (e->callee, freq_scale, nest); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
233 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
234 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
235 |
| 0 | 236 /* E is expected to be an edge being inlined. Clone destination node of |
| 237 the edge and redirect it to the new clone. | |
| 238 DUPLICATE is used for bookkeeping on whether we are actually creating new | |
| 239 clones or re-using node originally representing out-of-line function call. | |
| 240 */ | |
| 241 void | |
| 242 cgraph_clone_inlined_nodes (struct cgraph_edge *e, bool duplicate, | |
| 243 bool update_original) | |
| 244 { | |
| 245 HOST_WIDE_INT peak; | |
| 246 | |
| 247 if (duplicate) | |
| 248 { | |
| 249 /* We may eliminate the need for out-of-line copy to be output. | |
| 250 In that case just go ahead and re-use it. */ | |
| 251 if (!e->callee->callers->next_caller | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
252 && cgraph_can_remove_if_no_direct_calls_p (e->callee) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
253 /* Don't reuse if more than one function shares a comdat group. |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
254 If the other function(s) are needed, we need to emit even |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
255 this function out of line. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
256 && !e->callee->same_comdat_group |
| 0 | 257 && !cgraph_new_nodes) |
| 258 { | |
| 259 gcc_assert (!e->callee->global.inlined_to); | |
| 260 if (e->callee->analyzed) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
261 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
262 overall_size -= e->callee->global.size; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
263 nfunctions_inlined++; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
264 } |
| 0 | 265 duplicate = false; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
266 e->callee->local.externally_visible = false; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
267 update_noncloned_frequencies (e->callee, e->frequency, e->loop_nest); |
| 0 | 268 } |
| 269 else | |
| 270 { | |
| 271 struct cgraph_node *n; | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
272 n = cgraph_clone_node (e->callee, e->callee->decl, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
273 e->count, e->frequency, e->loop_nest, |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
274 update_original, NULL); |
| 0 | 275 cgraph_redirect_edge_callee (e, n); |
| 276 } | |
| 277 } | |
| 278 | |
| 279 if (e->caller->global.inlined_to) | |
| 280 e->callee->global.inlined_to = e->caller->global.inlined_to; | |
| 281 else | |
| 282 e->callee->global.inlined_to = e->caller; | |
| 283 e->callee->global.stack_frame_offset | |
| 284 = e->caller->global.stack_frame_offset | |
| 285 + inline_summary (e->caller)->estimated_self_stack_size; | |
| 286 peak = e->callee->global.stack_frame_offset | |
| 287 + inline_summary (e->callee)->estimated_self_stack_size; | |
| 288 if (e->callee->global.inlined_to->global.estimated_stack_size < peak) | |
| 289 e->callee->global.inlined_to->global.estimated_stack_size = peak; | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
290 cgraph_propagate_frequency (e->callee); |
| 0 | 291 |
| 292 /* Recursively clone all bodies. */ | |
| 293 for (e = e->callee->callees; e; e = e->next_callee) | |
| 294 if (!e->inline_failed) | |
| 295 cgraph_clone_inlined_nodes (e, duplicate, update_original); | |
| 296 } | |
| 297 | |
| 298 /* Mark edge E as inlined and update callgraph accordingly. UPDATE_ORIGINAL | |
| 299 specify whether profile of original function should be updated. If any new | |
| 300 indirect edges are discovered in the process, add them to NEW_EDGES, unless | |
| 301 it is NULL. Return true iff any new callgraph edges were discovered as a | |
| 302 result of inlining. */ | |
| 303 | |
| 304 static bool | |
| 305 cgraph_mark_inline_edge (struct cgraph_edge *e, bool update_original, | |
| 306 VEC (cgraph_edge_p, heap) **new_edges) | |
| 307 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
308 int old_size = 0, new_size = 0; |
| 0 | 309 struct cgraph_node *to = NULL, *what; |
| 310 struct cgraph_edge *curr = e; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
311 int freq; |
| 0 | 312 |
| 313 gcc_assert (e->inline_failed); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
314 e->inline_failed = CIF_OK; |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
315 DECL_POSSIBLY_INLINED (e->callee->decl) = true; |
| 0 | 316 |
| 317 cgraph_clone_inlined_nodes (e, true, update_original); | |
| 318 | |
| 319 what = e->callee; | |
| 320 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
321 freq = e->frequency; |
| 0 | 322 /* Now update size of caller and all functions caller is inlined into. */ |
| 323 for (;e && !e->inline_failed; e = e->caller->callers) | |
| 324 { | |
| 325 to = e->caller; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
326 old_size = e->caller->global.size; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
327 new_size = cgraph_estimate_size_after_inlining (1, to, what); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
328 to->global.size = new_size; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
329 to->global.time = cgraph_estimate_time_after_inlining (freq, to, what); |
| 0 | 330 } |
| 331 gcc_assert (what->global.inlined_to == to); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
332 if (new_size > old_size) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
333 overall_size += new_size - old_size; |
| 0 | 334 ncalls_inlined++; |
| 335 | |
| 336 if (flag_indirect_inlining) | |
| 337 return ipa_propagate_indirect_call_infos (curr, new_edges); | |
| 338 else | |
| 339 return false; | |
| 340 } | |
| 341 | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
342 /* Mark all calls of EDGE->CALLEE inlined into EDGE->CALLER. */ |
| 0 | 343 |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
344 static void |
| 0 | 345 cgraph_mark_inline (struct cgraph_edge *edge) |
| 346 { | |
| 347 struct cgraph_node *to = edge->caller; | |
| 348 struct cgraph_node *what = edge->callee; | |
| 349 struct cgraph_edge *e, *next; | |
| 350 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
351 gcc_assert (!edge->call_stmt_cannot_inline_p); |
| 0 | 352 /* Look for all calls, mark them inline and clone recursively |
| 353 all inlined functions. */ | |
| 354 for (e = what->callers; e; e = next) | |
| 355 { | |
| 356 next = e->next_caller; | |
| 357 if (e->caller == to && e->inline_failed) | |
| 358 { | |
| 359 cgraph_mark_inline_edge (e, true, NULL); | |
| 360 if (e == edge) | |
| 361 edge = next; | |
| 362 } | |
| 363 } | |
| 364 } | |
| 365 | |
| 366 /* Estimate the growth caused by inlining NODE into all callees. */ | |
| 367 | |
| 368 static int | |
| 369 cgraph_estimate_growth (struct cgraph_node *node) | |
| 370 { | |
| 371 int growth = 0; | |
| 372 struct cgraph_edge *e; | |
| 373 bool self_recursive = false; | |
| 374 | |
| 375 if (node->global.estimated_growth != INT_MIN) | |
| 376 return node->global.estimated_growth; | |
| 377 | |
| 378 for (e = node->callers; e; e = e->next_caller) | |
| 379 { | |
| 380 if (e->caller == node) | |
| 381 self_recursive = true; | |
| 382 if (e->inline_failed) | |
| 383 growth += (cgraph_estimate_size_after_inlining (1, e->caller, node) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
384 - e->caller->global.size); |
| 0 | 385 } |
| 386 | |
| 387 /* ??? Wrong for non-trivially self recursive functions or cases where | |
| 388 we decide to not inline for different reasons, but it is not big deal | |
| 389 as in that case we will keep the body around, but we will also avoid | |
| 390 some inlining. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
391 if (cgraph_only_called_directly_p (node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
392 && !DECL_EXTERNAL (node->decl) && !self_recursive) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
393 growth -= node->global.size; |
| 0 | 394 |
| 395 node->global.estimated_growth = growth; | |
| 396 return growth; | |
| 397 } | |
| 398 | |
| 399 /* Return false when inlining WHAT into TO is not good idea | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
400 as it would cause too large growth of function bodies. |
| 0 | 401 When ONE_ONLY is true, assume that only one call site is going |
| 402 to be inlined, otherwise figure out how many call sites in | |
| 403 TO calls WHAT and verify that all can be inlined. | |
| 404 */ | |
| 405 | |
| 406 static bool | |
| 407 cgraph_check_inline_limits (struct cgraph_node *to, struct cgraph_node *what, | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
408 cgraph_inline_failed_t *reason, bool one_only) |
| 0 | 409 { |
| 410 int times = 0; | |
| 411 struct cgraph_edge *e; | |
| 412 int newsize; | |
| 413 int limit; | |
| 414 HOST_WIDE_INT stack_size_limit, inlined_stack; | |
| 415 | |
| 416 if (one_only) | |
| 417 times = 1; | |
| 418 else | |
| 419 for (e = to->callees; e; e = e->next_callee) | |
| 420 if (e->callee == what) | |
| 421 times++; | |
| 422 | |
| 423 if (to->global.inlined_to) | |
| 424 to = to->global.inlined_to; | |
| 425 | |
| 426 /* When inlining large function body called once into small function, | |
| 427 take the inlined function as base for limiting the growth. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
428 if (inline_summary (to)->self_size > inline_summary(what)->self_size) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
429 limit = inline_summary (to)->self_size; |
| 0 | 430 else |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
431 limit = inline_summary (what)->self_size; |
| 0 | 432 |
| 433 limit += limit * PARAM_VALUE (PARAM_LARGE_FUNCTION_GROWTH) / 100; | |
| 434 | |
| 435 /* Check the size after inlining against the function limits. But allow | |
| 436 the function to shrink if it went over the limits by forced inlining. */ | |
| 437 newsize = cgraph_estimate_size_after_inlining (times, to, what); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
438 if (newsize >= to->global.size |
| 0 | 439 && newsize > PARAM_VALUE (PARAM_LARGE_FUNCTION_INSNS) |
| 440 && newsize > limit) | |
| 441 { | |
| 442 if (reason) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
443 *reason = CIF_LARGE_FUNCTION_GROWTH_LIMIT; |
| 0 | 444 return false; |
| 445 } | |
| 446 | |
| 447 stack_size_limit = inline_summary (to)->estimated_self_stack_size; | |
| 448 | |
| 449 stack_size_limit += stack_size_limit * PARAM_VALUE (PARAM_STACK_FRAME_GROWTH) / 100; | |
| 450 | |
| 451 inlined_stack = (to->global.stack_frame_offset | |
| 452 + inline_summary (to)->estimated_self_stack_size | |
| 453 + what->global.estimated_stack_size); | |
| 454 if (inlined_stack > stack_size_limit | |
| 455 && inlined_stack > PARAM_VALUE (PARAM_LARGE_STACK_FRAME)) | |
| 456 { | |
| 457 if (reason) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
458 *reason = CIF_LARGE_STACK_FRAME_GROWTH_LIMIT; |
| 0 | 459 return false; |
| 460 } | |
| 461 return true; | |
| 462 } | |
| 463 | |
| 464 /* Return true when function N is small enough to be inlined. */ | |
| 465 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
466 static bool |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
467 cgraph_default_inline_p (struct cgraph_node *n, cgraph_inline_failed_t *reason) |
| 0 | 468 { |
| 469 tree decl = n->decl; | |
| 470 | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
471 if (n->local.disregard_inline_limits) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
472 return true; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
473 |
| 0 | 474 if (!flag_inline_small_functions && !DECL_DECLARED_INLINE_P (decl)) |
| 475 { | |
| 476 if (reason) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
477 *reason = CIF_FUNCTION_NOT_INLINE_CANDIDATE; |
| 0 | 478 return false; |
| 479 } | |
| 480 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
481 if (!n->analyzed) |
| 0 | 482 { |
| 483 if (reason) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
484 *reason = CIF_BODY_NOT_AVAILABLE; |
| 0 | 485 return false; |
| 486 } | |
| 487 | |
| 488 if (DECL_DECLARED_INLINE_P (decl)) | |
| 489 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
490 if (n->global.size >= MAX_INLINE_INSNS_SINGLE) |
| 0 | 491 { |
| 492 if (reason) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
493 *reason = CIF_MAX_INLINE_INSNS_SINGLE_LIMIT; |
| 0 | 494 return false; |
| 495 } | |
| 496 } | |
| 497 else | |
| 498 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
499 if (n->global.size >= MAX_INLINE_INSNS_AUTO) |
| 0 | 500 { |
| 501 if (reason) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
502 *reason = CIF_MAX_INLINE_INSNS_AUTO_LIMIT; |
| 0 | 503 return false; |
| 504 } | |
| 505 } | |
| 506 | |
| 507 return true; | |
| 508 } | |
| 509 | |
| 510 /* Return true when inlining WHAT would create recursive inlining. | |
| 511 We call recursive inlining all cases where same function appears more than | |
| 512 once in the single recursion nest path in the inline graph. */ | |
| 513 | |
| 514 static bool | |
| 515 cgraph_recursive_inlining_p (struct cgraph_node *to, | |
| 516 struct cgraph_node *what, | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
517 cgraph_inline_failed_t *reason) |
| 0 | 518 { |
| 519 bool recursive; | |
| 520 if (to->global.inlined_to) | |
| 521 recursive = what->decl == to->global.inlined_to->decl; | |
| 522 else | |
| 523 recursive = what->decl == to->decl; | |
| 524 /* Marking recursive function inline has sane semantic and thus we should | |
| 525 not warn on it. */ | |
| 526 if (recursive && reason) | |
| 527 *reason = (what->local.disregard_inline_limits | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
528 ? CIF_RECURSIVE_INLINING : CIF_UNSPECIFIED); |
| 0 | 529 return recursive; |
| 530 } | |
| 531 | |
| 532 /* A cost model driving the inlining heuristics in a way so the edges with | |
| 533 smallest badness are inlined first. After each inlining is performed | |
| 534 the costs of all caller edges of nodes affected are recomputed so the | |
| 535 metrics may accurately depend on values such as number of inlinable callers | |
| 536 of the function or function body size. */ | |
| 537 | |
| 538 static int | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
539 cgraph_edge_badness (struct cgraph_edge *edge, bool dump) |
| 0 | 540 { |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
541 gcov_type badness; |
| 0 | 542 int growth = |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
543 (cgraph_estimate_size_after_inlining (1, edge->caller, edge->callee) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
544 - edge->caller->global.size); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
545 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
546 if (edge->callee->local.disregard_inline_limits) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
547 return INT_MIN; |
| 0 | 548 |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
549 if (dump) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
550 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
551 fprintf (dump_file, " Badness calculcation for %s -> %s\n", |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
552 cgraph_node_name (edge->caller), |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
553 cgraph_node_name (edge->callee)); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
554 fprintf (dump_file, " growth %i, time %i-%i, size %i-%i\n", |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
555 growth, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
556 edge->callee->global.time, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
557 inline_summary (edge->callee)->time_inlining_benefit, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
558 edge->callee->global.size, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
559 inline_summary (edge->callee)->size_inlining_benefit); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
560 } |
| 0 | 561 |
| 562 /* Always prefer inlining saving code size. */ | |
| 563 if (growth <= 0) | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
564 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
565 badness = INT_MIN - growth; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
566 if (dump) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
567 fprintf (dump_file, " %i: Growth %i < 0\n", (int) badness, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
568 growth); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
569 } |
| 0 | 570 |
| 571 /* When profiling is available, base priorities -(#calls / growth). | |
| 572 So we optimize for overall number of "executed" inlined calls. */ | |
| 573 else if (max_count) | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
574 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
575 badness = |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
576 ((int) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
577 ((double) edge->count * INT_MIN / max_count / (max_benefit + 1)) * |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
578 (inline_summary (edge->callee)->time_inlining_benefit + 1)) / growth; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
579 if (dump) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
580 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
581 fprintf (dump_file, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
582 " %i (relative %f): profile info. Relative count %f" |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
583 " * Relative benefit %f\n", |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
584 (int) badness, (double) badness / INT_MIN, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
585 (double) edge->count / max_count, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
586 (double) (inline_summary (edge->callee)-> |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
587 time_inlining_benefit + 1) / (max_benefit + 1)); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
588 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
589 } |
| 0 | 590 |
| 591 /* When function local profile is available, base priorities on | |
| 592 growth / frequency, so we optimize for overall frequency of inlined | |
| 593 calls. This is not too accurate since while the call might be frequent | |
| 594 within function, the function itself is infrequent. | |
| 595 | |
| 596 Other objective to optimize for is number of different calls inlined. | |
| 597 We add the estimated growth after inlining all functions to bias the | |
| 598 priorities slightly in this direction (so fewer times called functions | |
| 599 of the same size gets priority). */ | |
| 600 else if (flag_guess_branch_prob) | |
| 601 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
602 int div = edge->frequency * 100 / CGRAPH_FREQ_BASE + 1; |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
603 int benefitperc; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
604 int growth_for_all; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
605 badness = growth * 10000; |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
606 benefitperc = |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
607 MIN (100 * inline_summary (edge->callee)->time_inlining_benefit / |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
608 (edge->callee->global.time + 1) +1, 100); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
609 div *= benefitperc; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
610 |
| 0 | 611 |
| 612 /* Decrease badness if call is nested. */ | |
| 613 /* Compress the range so we don't overflow. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
614 if (div > 10000) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
615 div = 10000 + ceil_log2 (div) - 8; |
| 0 | 616 if (div < 1) |
| 617 div = 1; | |
| 618 if (badness > 0) | |
| 619 badness /= div; | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
620 growth_for_all = cgraph_estimate_growth (edge->callee); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
621 badness += growth_for_all; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
622 if (badness > INT_MAX) |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
623 badness = INT_MAX; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
624 if (dump) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
625 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
626 fprintf (dump_file, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
627 " %i: guessed profile. frequency %i, overall growth %i," |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
628 " benefit %i%%, divisor %i\n", |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
629 (int) badness, edge->frequency, growth_for_all, benefitperc, div); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
630 } |
| 0 | 631 } |
| 632 /* When function local profile is not available or it does not give | |
| 633 useful information (ie frequency is zero), base the cost on | |
| 634 loop nest and overall size growth, so we optimize for overall number | |
| 635 of functions fully inlined in program. */ | |
| 636 else | |
| 637 { | |
| 638 int nest = MIN (edge->loop_nest, 8); | |
| 639 badness = cgraph_estimate_growth (edge->callee) * 256; | |
| 640 | |
| 641 /* Decrease badness if call is nested. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
642 if (badness > 0) |
| 0 | 643 badness >>= nest; |
| 644 else | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
645 { |
| 0 | 646 badness <<= nest; |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
647 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
648 if (dump) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
649 fprintf (dump_file, " %i: no profile. nest %i\n", (int) badness, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
650 nest); |
| 0 | 651 } |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
652 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
653 /* Ensure that we did not overflow in all the fixed point math above. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
654 gcc_assert (badness >= INT_MIN); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
655 gcc_assert (badness <= INT_MAX - 1); |
| 0 | 656 /* Make recursive inlining happen always after other inlining is done. */ |
| 657 if (cgraph_recursive_inlining_p (edge->caller, edge->callee, NULL)) | |
| 658 return badness + 1; | |
| 659 else | |
| 660 return badness; | |
| 661 } | |
| 662 | |
| 663 /* Recompute heap nodes for each of caller edge. */ | |
| 664 | |
| 665 static void | |
| 666 update_caller_keys (fibheap_t heap, struct cgraph_node *node, | |
| 667 bitmap updated_nodes) | |
| 668 { | |
| 669 struct cgraph_edge *edge; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
670 cgraph_inline_failed_t failed_reason; |
| 0 | 671 |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
672 if (!node->local.inlinable |
| 0 | 673 || node->global.inlined_to) |
| 674 return; | |
| 675 if (bitmap_bit_p (updated_nodes, node->uid)) | |
| 676 return; | |
| 677 bitmap_set_bit (updated_nodes, node->uid); | |
| 678 node->global.estimated_growth = INT_MIN; | |
| 679 | |
| 680 if (!node->local.inlinable) | |
| 681 return; | |
| 682 /* Prune out edges we won't inline into anymore. */ | |
| 683 if (!cgraph_default_inline_p (node, &failed_reason)) | |
| 684 { | |
| 685 for (edge = node->callers; edge; edge = edge->next_caller) | |
| 686 if (edge->aux) | |
| 687 { | |
| 688 fibheap_delete_node (heap, (fibnode_t) edge->aux); | |
| 689 edge->aux = NULL; | |
| 690 if (edge->inline_failed) | |
| 691 edge->inline_failed = failed_reason; | |
| 692 } | |
| 693 return; | |
| 694 } | |
| 695 | |
| 696 for (edge = node->callers; edge; edge = edge->next_caller) | |
| 697 if (edge->inline_failed) | |
| 698 { | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
699 int badness = cgraph_edge_badness (edge, false); |
| 0 | 700 if (edge->aux) |
| 701 { | |
| 702 fibnode_t n = (fibnode_t) edge->aux; | |
| 703 gcc_assert (n->data == edge); | |
| 704 if (n->key == badness) | |
| 705 continue; | |
| 706 | |
| 707 /* fibheap_replace_key only increase the keys. */ | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
708 if (badness < n->key) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
709 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
710 fibheap_replace_key (heap, n, badness); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
711 gcc_assert (n->key == badness); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
712 continue; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
713 } |
| 0 | 714 fibheap_delete_node (heap, (fibnode_t) edge->aux); |
| 715 } | |
| 716 edge->aux = fibheap_insert (heap, badness, edge); | |
| 717 } | |
| 718 } | |
| 719 | |
| 720 /* Recompute heap nodes for each of caller edges of each of callees. */ | |
| 721 | |
| 722 static void | |
| 723 update_callee_keys (fibheap_t heap, struct cgraph_node *node, | |
| 724 bitmap updated_nodes) | |
| 725 { | |
| 726 struct cgraph_edge *e; | |
| 727 node->global.estimated_growth = INT_MIN; | |
| 728 | |
| 729 for (e = node->callees; e; e = e->next_callee) | |
| 730 if (e->inline_failed) | |
| 731 update_caller_keys (heap, e->callee, updated_nodes); | |
| 732 else if (!e->inline_failed) | |
| 733 update_callee_keys (heap, e->callee, updated_nodes); | |
| 734 } | |
| 735 | |
| 736 /* Enqueue all recursive calls from NODE into priority queue depending on | |
| 737 how likely we want to recursively inline the call. */ | |
| 738 | |
| 739 static void | |
| 740 lookup_recursive_calls (struct cgraph_node *node, struct cgraph_node *where, | |
| 741 fibheap_t heap) | |
| 742 { | |
| 743 static int priority; | |
| 744 struct cgraph_edge *e; | |
| 745 for (e = where->callees; e; e = e->next_callee) | |
| 746 if (e->callee == node) | |
| 747 { | |
| 748 /* When profile feedback is available, prioritize by expected number | |
| 749 of calls. Without profile feedback we maintain simple queue | |
| 750 to order candidates via recursive depths. */ | |
| 751 fibheap_insert (heap, | |
| 752 !max_count ? priority++ | |
| 753 : -(e->count / ((max_count + (1<<24) - 1) / (1<<24))), | |
| 754 e); | |
| 755 } | |
| 756 for (e = where->callees; e; e = e->next_callee) | |
| 757 if (!e->inline_failed) | |
| 758 lookup_recursive_calls (node, e->callee, heap); | |
| 759 } | |
| 760 | |
| 761 /* Decide on recursive inlining: in the case function has recursive calls, | |
| 762 inline until body size reaches given argument. If any new indirect edges | |
| 763 are discovered in the process, add them to *NEW_EDGES, unless NEW_EDGES | |
| 764 is NULL. */ | |
| 765 | |
| 766 static bool | |
| 767 cgraph_decide_recursive_inlining (struct cgraph_node *node, | |
| 768 VEC (cgraph_edge_p, heap) **new_edges) | |
| 769 { | |
| 770 int limit = PARAM_VALUE (PARAM_MAX_INLINE_INSNS_RECURSIVE_AUTO); | |
| 771 int max_depth = PARAM_VALUE (PARAM_MAX_INLINE_RECURSIVE_DEPTH_AUTO); | |
| 772 int probability = PARAM_VALUE (PARAM_MIN_INLINE_RECURSIVE_PROBABILITY); | |
| 773 fibheap_t heap; | |
| 774 struct cgraph_edge *e; | |
| 775 struct cgraph_node *master_clone, *next; | |
| 776 int depth = 0; | |
| 777 int n = 0; | |
| 778 | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
779 /* It does not make sense to recursively inline always-inline functions |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
780 as we are going to sorry() on the remaining calls anyway. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
781 if (node->local.disregard_inline_limits |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
782 && lookup_attribute ("always_inline", DECL_ATTRIBUTES (node->decl))) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
783 return false; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
784 |
| 0 | 785 if (optimize_function_for_size_p (DECL_STRUCT_FUNCTION (node->decl)) |
| 786 || (!flag_inline_functions && !DECL_DECLARED_INLINE_P (node->decl))) | |
| 787 return false; | |
| 788 | |
| 789 if (DECL_DECLARED_INLINE_P (node->decl)) | |
| 790 { | |
| 791 limit = PARAM_VALUE (PARAM_MAX_INLINE_INSNS_RECURSIVE); | |
| 792 max_depth = PARAM_VALUE (PARAM_MAX_INLINE_RECURSIVE_DEPTH); | |
| 793 } | |
| 794 | |
| 795 /* Make sure that function is small enough to be considered for inlining. */ | |
| 796 if (!max_depth | |
| 797 || cgraph_estimate_size_after_inlining (1, node, node) >= limit) | |
| 798 return false; | |
| 799 heap = fibheap_new (); | |
| 800 lookup_recursive_calls (node, node, heap); | |
| 801 if (fibheap_empty (heap)) | |
| 802 { | |
| 803 fibheap_delete (heap); | |
| 804 return false; | |
| 805 } | |
| 806 | |
| 807 if (dump_file) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
808 fprintf (dump_file, |
| 0 | 809 " Performing recursive inlining on %s\n", |
| 810 cgraph_node_name (node)); | |
| 811 | |
| 812 /* We need original clone to copy around. */ | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
813 master_clone = cgraph_clone_node (node, node->decl, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
814 node->count, CGRAPH_FREQ_BASE, 1, |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
815 false, NULL); |
| 0 | 816 master_clone->needed = true; |
| 817 for (e = master_clone->callees; e; e = e->next_callee) | |
| 818 if (!e->inline_failed) | |
| 819 cgraph_clone_inlined_nodes (e, true, false); | |
| 820 | |
| 821 /* Do the inlining and update list of recursive call during process. */ | |
| 822 while (!fibheap_empty (heap) | |
| 823 && (cgraph_estimate_size_after_inlining (1, node, master_clone) | |
| 824 <= limit)) | |
| 825 { | |
| 826 struct cgraph_edge *curr | |
| 827 = (struct cgraph_edge *) fibheap_extract_min (heap); | |
| 828 struct cgraph_node *cnode; | |
| 829 | |
| 830 depth = 1; | |
| 831 for (cnode = curr->caller; | |
| 832 cnode->global.inlined_to; cnode = cnode->callers->caller) | |
| 833 if (node->decl == curr->callee->decl) | |
| 834 depth++; | |
| 835 if (depth > max_depth) | |
| 836 { | |
| 837 if (dump_file) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
838 fprintf (dump_file, |
| 0 | 839 " maximal depth reached\n"); |
| 840 continue; | |
| 841 } | |
| 842 | |
| 843 if (max_count) | |
| 844 { | |
| 845 if (!cgraph_maybe_hot_edge_p (curr)) | |
| 846 { | |
| 847 if (dump_file) | |
| 848 fprintf (dump_file, " Not inlining cold call\n"); | |
| 849 continue; | |
| 850 } | |
| 851 if (curr->count * 100 / node->count < probability) | |
| 852 { | |
| 853 if (dump_file) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
854 fprintf (dump_file, |
| 0 | 855 " Probability of edge is too small\n"); |
| 856 continue; | |
| 857 } | |
| 858 } | |
| 859 | |
| 860 if (dump_file) | |
| 861 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
862 fprintf (dump_file, |
| 0 | 863 " Inlining call of depth %i", depth); |
| 864 if (node->count) | |
| 865 { | |
| 866 fprintf (dump_file, " called approx. %.2f times per call", | |
| 867 (double)curr->count / node->count); | |
| 868 } | |
| 869 fprintf (dump_file, "\n"); | |
| 870 } | |
| 871 cgraph_redirect_edge_callee (curr, master_clone); | |
| 872 cgraph_mark_inline_edge (curr, false, new_edges); | |
| 873 lookup_recursive_calls (node, curr->callee, heap); | |
| 874 n++; | |
| 875 } | |
| 876 if (!fibheap_empty (heap) && dump_file) | |
| 877 fprintf (dump_file, " Recursive inlining growth limit met.\n"); | |
| 878 | |
| 879 fibheap_delete (heap); | |
| 880 if (dump_file) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
881 fprintf (dump_file, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
882 "\n Inlined %i times, body grown from size %i to %i, time %i to %i\n", n, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
883 master_clone->global.size, node->global.size, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
884 master_clone->global.time, node->global.time); |
| 0 | 885 |
| 886 /* Remove master clone we used for inlining. We rely that clones inlined | |
| 887 into master clone gets queued just before master clone so we don't | |
| 888 need recursion. */ | |
| 889 for (node = cgraph_nodes; node != master_clone; | |
| 890 node = next) | |
| 891 { | |
| 892 next = node->next; | |
| 893 if (node->global.inlined_to == master_clone) | |
| 894 cgraph_remove_node (node); | |
| 895 } | |
| 896 cgraph_remove_node (master_clone); | |
| 897 /* FIXME: Recursive inlining actually reduces number of calls of the | |
| 898 function. At this place we should probably walk the function and | |
| 899 inline clones and compensate the counts accordingly. This probably | |
| 900 doesn't matter much in practice. */ | |
| 901 return n > 0; | |
| 902 } | |
| 903 | |
| 904 /* Set inline_failed for all callers of given function to REASON. */ | |
| 905 | |
| 906 static void | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
907 cgraph_set_inline_failed (struct cgraph_node *node, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
908 cgraph_inline_failed_t reason) |
| 0 | 909 { |
| 910 struct cgraph_edge *e; | |
| 911 | |
| 912 if (dump_file) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
913 fprintf (dump_file, "Inlining failed: %s\n", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
914 cgraph_inline_failed_string (reason)); |
| 0 | 915 for (e = node->callers; e; e = e->next_caller) |
| 916 if (e->inline_failed) | |
| 917 e->inline_failed = reason; | |
| 918 } | |
| 919 | |
| 920 /* Given whole compilation unit estimate of INSNS, compute how large we can | |
| 921 allow the unit to grow. */ | |
| 922 static int | |
| 923 compute_max_insns (int insns) | |
| 924 { | |
| 925 int max_insns = insns; | |
| 926 if (max_insns < PARAM_VALUE (PARAM_LARGE_UNIT_INSNS)) | |
| 927 max_insns = PARAM_VALUE (PARAM_LARGE_UNIT_INSNS); | |
| 928 | |
| 929 return ((HOST_WIDEST_INT) max_insns | |
| 930 * (100 + PARAM_VALUE (PARAM_INLINE_UNIT_GROWTH)) / 100); | |
| 931 } | |
| 932 | |
| 933 /* Compute badness of all edges in NEW_EDGES and add them to the HEAP. */ | |
| 934 static void | |
| 935 add_new_edges_to_heap (fibheap_t heap, VEC (cgraph_edge_p, heap) *new_edges) | |
| 936 { | |
| 937 while (VEC_length (cgraph_edge_p, new_edges) > 0) | |
| 938 { | |
| 939 struct cgraph_edge *edge = VEC_pop (cgraph_edge_p, new_edges); | |
| 940 | |
| 941 gcc_assert (!edge->aux); | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
942 edge->aux = fibheap_insert (heap, cgraph_edge_badness (edge, false), edge); |
| 0 | 943 } |
| 944 } | |
| 945 | |
| 946 | |
| 947 /* We use greedy algorithm for inlining of small functions: | |
| 948 All inline candidates are put into prioritized heap based on estimated | |
| 949 growth of the overall number of instructions and then update the estimates. | |
| 950 | |
| 951 INLINED and INLINED_CALEES are just pointers to arrays large enough | |
| 952 to be passed to cgraph_inlined_into and cgraph_inlined_callees. */ | |
| 953 | |
| 954 static void | |
| 955 cgraph_decide_inlining_of_small_functions (void) | |
| 956 { | |
| 957 struct cgraph_node *node; | |
| 958 struct cgraph_edge *edge; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
959 cgraph_inline_failed_t failed_reason; |
| 0 | 960 fibheap_t heap = fibheap_new (); |
| 961 bitmap updated_nodes = BITMAP_ALLOC (NULL); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
962 int min_size, max_size; |
| 0 | 963 VEC (cgraph_edge_p, heap) *new_indirect_edges = NULL; |
| 964 | |
| 965 if (flag_indirect_inlining) | |
| 966 new_indirect_edges = VEC_alloc (cgraph_edge_p, heap, 8); | |
| 967 | |
| 968 if (dump_file) | |
| 969 fprintf (dump_file, "\nDeciding on smaller functions:\n"); | |
| 970 | |
| 971 /* Put all inline candidates into the heap. */ | |
| 972 | |
| 973 for (node = cgraph_nodes; node; node = node->next) | |
| 974 { | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
975 if (!node->local.inlinable || !node->callers) |
| 0 | 976 continue; |
| 977 if (dump_file) | |
| 978 fprintf (dump_file, "Considering inline candidate %s.\n", cgraph_node_name (node)); | |
| 979 | |
| 980 node->global.estimated_growth = INT_MIN; | |
| 981 if (!cgraph_default_inline_p (node, &failed_reason)) | |
| 982 { | |
| 983 cgraph_set_inline_failed (node, failed_reason); | |
| 984 continue; | |
| 985 } | |
| 986 | |
| 987 for (edge = node->callers; edge; edge = edge->next_caller) | |
| 988 if (edge->inline_failed) | |
| 989 { | |
| 990 gcc_assert (!edge->aux); | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
991 edge->aux = fibheap_insert (heap, cgraph_edge_badness (edge, false), edge); |
| 0 | 992 } |
| 993 } | |
| 994 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
995 max_size = compute_max_insns (overall_size); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
996 min_size = overall_size; |
| 0 | 997 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
998 while (overall_size <= max_size |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
999 && !fibheap_empty (heap)) |
| 0 | 1000 { |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1001 int old_size = overall_size; |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1002 struct cgraph_node *where, *callee; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1003 int badness = fibheap_min_key (heap); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1004 int growth; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1005 cgraph_inline_failed_t not_good = CIF_OK; |
| 0 | 1006 |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1007 edge = (struct cgraph_edge *) fibheap_extract_min (heap); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1008 gcc_assert (edge->aux); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1009 edge->aux = NULL; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1010 if (!edge->inline_failed) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1011 continue; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1012 #ifdef ENABLE_CHECKING |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1013 gcc_assert (cgraph_edge_badness (edge, false) == badness); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1014 #endif |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1015 callee = edge->callee; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1016 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1017 growth = (cgraph_estimate_size_after_inlining (1, edge->caller, edge->callee) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1018 - edge->caller->global.size); |
| 0 | 1019 |
| 1020 if (dump_file) | |
| 1021 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1022 fprintf (dump_file, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1023 "\nConsidering %s with %i size\n", |
| 0 | 1024 cgraph_node_name (edge->callee), |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1025 edge->callee->global.size); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1026 fprintf (dump_file, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1027 " to be inlined into %s in %s:%i\n" |
| 0 | 1028 " Estimated growth after inlined into all callees is %+i insns.\n" |
| 1029 " Estimated badness is %i, frequency %.2f.\n", | |
| 1030 cgraph_node_name (edge->caller), | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1031 flag_wpa ? "unknown" |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1032 : gimple_filename ((const_gimple) edge->call_stmt), |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1033 flag_wpa ? -1 : gimple_lineno ((const_gimple) edge->call_stmt), |
| 0 | 1034 cgraph_estimate_growth (edge->callee), |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1035 badness, |
| 0 | 1036 edge->frequency / (double)CGRAPH_FREQ_BASE); |
| 1037 if (edge->count) | |
| 1038 fprintf (dump_file," Called "HOST_WIDEST_INT_PRINT_DEC"x\n", edge->count); | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1039 if (dump_flags & TDF_DETAILS) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1040 cgraph_edge_badness (edge, true); |
| 0 | 1041 } |
| 1042 | |
| 1043 /* When not having profile info ready we don't weight by any way the | |
| 1044 position of call in procedure itself. This means if call of | |
| 1045 function A from function B seems profitable to inline, the recursive | |
| 1046 call of function A in inline copy of A in B will look profitable too | |
| 1047 and we end up inlining until reaching maximal function growth. This | |
| 1048 is not good idea so prohibit the recursive inlining. | |
| 1049 | |
| 1050 ??? When the frequencies are taken into account we might not need this | |
| 1051 restriction. | |
| 1052 | |
| 1053 We need to be cureful here, in some testcases, e.g. directivec.c in | |
| 1054 libcpp, we can estimate self recursive function to have negative growth | |
| 1055 for inlining completely. | |
| 1056 */ | |
| 1057 if (!edge->count) | |
| 1058 { | |
| 1059 where = edge->caller; | |
| 1060 while (where->global.inlined_to) | |
| 1061 { | |
| 1062 if (where->decl == edge->callee->decl) | |
| 1063 break; | |
| 1064 where = where->callers->caller; | |
| 1065 } | |
| 1066 if (where->global.inlined_to) | |
| 1067 { | |
| 1068 edge->inline_failed | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1069 = (edge->callee->local.disregard_inline_limits |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1070 ? CIF_RECURSIVE_INLINING : CIF_UNSPECIFIED); |
| 0 | 1071 if (dump_file) |
| 1072 fprintf (dump_file, " inline_failed:Recursive inlining performed only for function itself.\n"); | |
| 1073 continue; | |
| 1074 } | |
| 1075 } | |
| 1076 | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1077 if (edge->callee->local.disregard_inline_limits) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1078 ; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1079 else if (!cgraph_maybe_hot_edge_p (edge)) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1080 not_good = CIF_UNLIKELY_CALL; |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1081 else if (!flag_inline_functions |
| 0 | 1082 && !DECL_DECLARED_INLINE_P (edge->callee->decl)) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1083 not_good = CIF_NOT_DECLARED_INLINED; |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1084 else if (optimize_function_for_size_p (DECL_STRUCT_FUNCTION(edge->caller->decl))) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1085 not_good = CIF_OPTIMIZING_FOR_SIZE; |
| 0 | 1086 if (not_good && growth > 0 && cgraph_estimate_growth (edge->callee) > 0) |
| 1087 { | |
| 1088 if (!cgraph_recursive_inlining_p (edge->caller, edge->callee, | |
| 1089 &edge->inline_failed)) | |
| 1090 { | |
| 1091 edge->inline_failed = not_good; | |
| 1092 if (dump_file) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1093 fprintf (dump_file, " inline_failed:%s.\n", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1094 cgraph_inline_failed_string (edge->inline_failed)); |
| 0 | 1095 } |
| 1096 continue; | |
| 1097 } | |
| 1098 if (!cgraph_default_inline_p (edge->callee, &edge->inline_failed)) | |
| 1099 { | |
| 1100 if (!cgraph_recursive_inlining_p (edge->caller, edge->callee, | |
| 1101 &edge->inline_failed)) | |
| 1102 { | |
| 1103 if (dump_file) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1104 fprintf (dump_file, " inline_failed:%s.\n", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1105 cgraph_inline_failed_string (edge->inline_failed)); |
| 0 | 1106 } |
| 1107 continue; | |
| 1108 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1109 if (!tree_can_inline_p (edge)) |
| 0 | 1110 { |
| 1111 if (dump_file) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1112 fprintf (dump_file, " inline_failed:%s.\n", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1113 cgraph_inline_failed_string (edge->inline_failed)); |
| 0 | 1114 continue; |
| 1115 } | |
| 1116 if (cgraph_recursive_inlining_p (edge->caller, edge->callee, | |
| 1117 &edge->inline_failed)) | |
| 1118 { | |
| 1119 where = edge->caller; | |
| 1120 if (where->global.inlined_to) | |
| 1121 where = where->global.inlined_to; | |
| 1122 if (!cgraph_decide_recursive_inlining (where, | |
| 1123 flag_indirect_inlining | |
| 1124 ? &new_indirect_edges : NULL)) | |
| 1125 continue; | |
| 1126 if (flag_indirect_inlining) | |
| 1127 add_new_edges_to_heap (heap, new_indirect_edges); | |
| 1128 update_callee_keys (heap, where, updated_nodes); | |
| 1129 } | |
| 1130 else | |
| 1131 { | |
| 1132 struct cgraph_node *callee; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1133 if (edge->call_stmt_cannot_inline_p |
| 0 | 1134 || !cgraph_check_inline_limits (edge->caller, edge->callee, |
| 1135 &edge->inline_failed, true)) | |
| 1136 { | |
| 1137 if (dump_file) | |
| 1138 fprintf (dump_file, " Not inlining into %s:%s.\n", | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1139 cgraph_node_name (edge->caller), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1140 cgraph_inline_failed_string (edge->inline_failed)); |
| 0 | 1141 continue; |
| 1142 } | |
| 1143 callee = edge->callee; | |
| 1144 cgraph_mark_inline_edge (edge, true, &new_indirect_edges); | |
| 1145 if (flag_indirect_inlining) | |
| 1146 add_new_edges_to_heap (heap, new_indirect_edges); | |
| 1147 | |
| 1148 update_callee_keys (heap, callee, updated_nodes); | |
| 1149 } | |
| 1150 where = edge->caller; | |
| 1151 if (where->global.inlined_to) | |
| 1152 where = where->global.inlined_to; | |
| 1153 | |
| 1154 /* Our profitability metric can depend on local properties | |
| 1155 such as number of inlinable calls and size of the function body. | |
| 1156 After inlining these properties might change for the function we | |
| 1157 inlined into (since it's body size changed) and for the functions | |
| 1158 called by function we inlined (since number of it inlinable callers | |
| 1159 might change). */ | |
| 1160 update_caller_keys (heap, where, updated_nodes); | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1161 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1162 /* We removed one call of the function we just inlined. If offline |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1163 copy is still needed, be sure to update the keys. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1164 if (callee != where && !callee->global.inlined_to) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1165 update_caller_keys (heap, callee, updated_nodes); |
| 0 | 1166 bitmap_clear (updated_nodes); |
| 1167 | |
| 1168 if (dump_file) | |
| 1169 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1170 fprintf (dump_file, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1171 " Inlined into %s which now has size %i and self time %i," |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1172 "net change of %+i.\n", |
| 0 | 1173 cgraph_node_name (edge->caller), |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1174 edge->caller->global.time, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1175 edge->caller->global.size, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1176 overall_size - old_size); |
| 0 | 1177 } |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1178 if (min_size > overall_size) |
| 0 | 1179 { |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1180 min_size = overall_size; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1181 max_size = compute_max_insns (min_size); |
| 0 | 1182 |
| 1183 if (dump_file) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1184 fprintf (dump_file, "New minimal size reached: %i\n", min_size); |
| 0 | 1185 } |
| 1186 } | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1187 while (!fibheap_empty (heap)) |
| 0 | 1188 { |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1189 int badness = fibheap_min_key (heap); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1190 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1191 edge = (struct cgraph_edge *) fibheap_extract_min (heap); |
| 0 | 1192 gcc_assert (edge->aux); |
| 1193 edge->aux = NULL; | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1194 if (!edge->inline_failed) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1195 continue; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1196 #ifdef ENABLE_CHECKING |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1197 gcc_assert (cgraph_edge_badness (edge, false) == badness); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1198 #endif |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1199 if (dump_file) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1200 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1201 fprintf (dump_file, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1202 "\nSkipping %s with %i size\n", |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1203 cgraph_node_name (edge->callee), |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1204 edge->callee->global.size); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1205 fprintf (dump_file, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1206 " called by %s in %s:%i\n" |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1207 " Estimated growth after inlined into all callees is %+i insns.\n" |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1208 " Estimated badness is %i, frequency %.2f.\n", |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1209 cgraph_node_name (edge->caller), |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1210 flag_wpa ? "unknown" |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1211 : gimple_filename ((const_gimple) edge->call_stmt), |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1212 flag_wpa ? -1 : gimple_lineno ((const_gimple) edge->call_stmt), |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1213 cgraph_estimate_growth (edge->callee), |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1214 badness, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1215 edge->frequency / (double)CGRAPH_FREQ_BASE); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1216 if (edge->count) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1217 fprintf (dump_file," Called "HOST_WIDEST_INT_PRINT_DEC"x\n", edge->count); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1218 if (dump_flags & TDF_DETAILS) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1219 cgraph_edge_badness (edge, true); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1220 } |
| 0 | 1221 if (!edge->callee->local.disregard_inline_limits && edge->inline_failed |
| 1222 && !cgraph_recursive_inlining_p (edge->caller, edge->callee, | |
| 1223 &edge->inline_failed)) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1224 edge->inline_failed = CIF_INLINE_UNIT_GROWTH_LIMIT; |
| 0 | 1225 } |
| 1226 | |
| 1227 if (new_indirect_edges) | |
| 1228 VEC_free (cgraph_edge_p, heap, new_indirect_edges); | |
| 1229 fibheap_delete (heap); | |
| 1230 BITMAP_FREE (updated_nodes); | |
| 1231 } | |
| 1232 | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1233 /* Flatten NODE from the IPA inliner. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1234 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1235 static void |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1236 cgraph_flatten (struct cgraph_node *node) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1237 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1238 struct cgraph_edge *e; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1239 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1240 /* We shouldn't be called recursively when we are being processed. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1241 gcc_assert (node->aux == NULL); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1242 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1243 node->aux = (void *)(size_t) INLINE_ALL; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1244 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1245 for (e = node->callees; e; e = e->next_callee) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1246 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1247 struct cgraph_node *orig_callee; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1248 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1249 if (e->call_stmt_cannot_inline_p) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1250 continue; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1251 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1252 if (!e->callee->analyzed) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1253 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1254 if (dump_file) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1255 fprintf (dump_file, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1256 "Not inlining: Function body not available.\n"); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1257 continue; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1258 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1259 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1260 /* We've hit cycle? It is time to give up. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1261 if (e->callee->aux) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1262 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1263 if (dump_file) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1264 fprintf (dump_file, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1265 "Not inlining %s into %s to avoid cycle.\n", |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1266 cgraph_node_name (e->callee), |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1267 cgraph_node_name (e->caller)); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1268 e->inline_failed = CIF_RECURSIVE_INLINING; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1269 continue; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1270 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1271 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1272 /* When the edge is already inlined, we just need to recurse into |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1273 it in order to fully flatten the leaves. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1274 if (!e->inline_failed) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1275 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1276 cgraph_flatten (e->callee); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1277 continue; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1278 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1279 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1280 if (cgraph_recursive_inlining_p (node, e->callee, &e->inline_failed)) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1281 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1282 if (dump_file) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1283 fprintf (dump_file, "Not inlining: recursive call.\n"); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1284 continue; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1285 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1286 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1287 if (!tree_can_inline_p (e)) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1288 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1289 if (dump_file) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1290 fprintf (dump_file, "Not inlining: %s", |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1291 cgraph_inline_failed_string (e->inline_failed)); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1292 continue; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1293 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1294 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1295 /* Inline the edge and flatten the inline clone. Avoid |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1296 recursing through the original node if the node was cloned. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1297 if (dump_file) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1298 fprintf (dump_file, " Inlining %s into %s.\n", |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1299 cgraph_node_name (e->callee), |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1300 cgraph_node_name (e->caller)); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1301 orig_callee = e->callee; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1302 cgraph_mark_inline_edge (e, true, NULL); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1303 if (e->callee != orig_callee) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1304 orig_callee->aux = (void *)(size_t) INLINE_ALL; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1305 cgraph_flatten (e->callee); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1306 if (e->callee != orig_callee) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1307 orig_callee->aux = NULL; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1308 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1309 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1310 node->aux = NULL; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1311 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1312 |
| 0 | 1313 /* Decide on the inlining. We do so in the topological order to avoid |
| 1314 expenses on updating data structures. */ | |
| 1315 | |
| 1316 static unsigned int | |
| 1317 cgraph_decide_inlining (void) | |
| 1318 { | |
| 1319 struct cgraph_node *node; | |
| 1320 int nnodes; | |
| 1321 struct cgraph_node **order = | |
| 1322 XCNEWVEC (struct cgraph_node *, cgraph_n_nodes); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1323 int old_size = 0; |
| 0 | 1324 int i; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1325 int initial_size = 0; |
| 0 | 1326 |
| 1327 cgraph_remove_function_insertion_hook (function_insertion_hook_holder); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1328 if (in_lto_p && flag_indirect_inlining) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1329 ipa_update_after_lto_read (); |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1330 if (flag_indirect_inlining) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1331 ipa_create_all_structures_for_iinln (); |
| 0 | 1332 |
| 1333 max_count = 0; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1334 max_benefit = 0; |
| 0 | 1335 for (node = cgraph_nodes; node; node = node->next) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1336 if (node->analyzed) |
| 0 | 1337 { |
| 1338 struct cgraph_edge *e; | |
| 1339 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1340 gcc_assert (inline_summary (node)->self_size == node->global.size); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1341 initial_size += node->global.size; |
| 0 | 1342 for (e = node->callees; e; e = e->next_callee) |
| 1343 if (max_count < e->count) | |
| 1344 max_count = e->count; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1345 if (max_benefit < inline_summary (node)->time_inlining_benefit) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1346 max_benefit = inline_summary (node)->time_inlining_benefit; |
| 0 | 1347 } |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1348 gcc_assert (in_lto_p |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1349 || !max_count |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1350 || (profile_info && flag_branch_probabilities)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1351 overall_size = initial_size; |
| 0 | 1352 |
| 1353 nnodes = cgraph_postorder (order); | |
| 1354 | |
| 1355 if (dump_file) | |
| 1356 fprintf (dump_file, | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1357 "\nDeciding on inlining. Starting with size %i.\n", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1358 initial_size); |
| 0 | 1359 |
| 1360 for (node = cgraph_nodes; node; node = node->next) | |
| 1361 node->aux = 0; | |
| 1362 | |
| 1363 if (dump_file) | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1364 fprintf (dump_file, "\nFlattening functions:\n"); |
| 0 | 1365 |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1366 /* In the first pass handle functions to be flattened. Do this with |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1367 a priority so none of our later choices will make this impossible. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1368 for (i = nnodes - 1; i >= 0; i--) |
| 0 | 1369 { |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1370 node = order[i]; |
| 0 | 1371 |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1372 /* Handle nodes to be flattened, but don't update overall unit |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1373 size. Calling the incremental inliner here is lame, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1374 a simple worklist should be enough. What should be left |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1375 here from the early inliner (if it runs) is cyclic cases. |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1376 Ideally when processing callees we stop inlining at the |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1377 entry of cycles, possibly cloning that entry point and |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1378 try to flatten itself turning it into a self-recursive |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1379 function. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1380 if (lookup_attribute ("flatten", |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1381 DECL_ATTRIBUTES (node->decl)) != NULL) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1382 { |
| 0 | 1383 if (dump_file) |
| 1384 fprintf (dump_file, | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1385 "Flattening %s\n", cgraph_node_name (node)); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1386 cgraph_flatten (node); |
| 0 | 1387 } |
| 1388 } | |
| 1389 | |
| 1390 cgraph_decide_inlining_of_small_functions (); | |
| 1391 | |
| 1392 if (flag_inline_functions_called_once) | |
| 1393 { | |
| 1394 if (dump_file) | |
| 1395 fprintf (dump_file, "\nDeciding on functions called once:\n"); | |
| 1396 | |
| 1397 /* And finally decide what functions are called once. */ | |
| 1398 for (i = nnodes - 1; i >= 0; i--) | |
| 1399 { | |
| 1400 node = order[i]; | |
| 1401 | |
| 1402 if (node->callers | |
| 1403 && !node->callers->next_caller | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1404 && cgraph_only_called_directly_p (node) |
| 0 | 1405 && node->local.inlinable |
| 1406 && node->callers->inline_failed | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1407 && node->callers->caller != node |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1408 && node->callers->caller->global.inlined_to != node |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1409 && !node->callers->call_stmt_cannot_inline_p |
| 0 | 1410 && !DECL_EXTERNAL (node->decl) |
| 1411 && !DECL_COMDAT (node->decl)) | |
| 1412 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1413 cgraph_inline_failed_t reason; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1414 old_size = overall_size; |
| 0 | 1415 if (dump_file) |
| 1416 { | |
| 1417 fprintf (dump_file, | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1418 "\nConsidering %s size %i.\n", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1419 cgraph_node_name (node), node->global.size); |
| 0 | 1420 fprintf (dump_file, |
| 1421 " Called once from %s %i insns.\n", | |
| 1422 cgraph_node_name (node->callers->caller), | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1423 node->callers->caller->global.size); |
| 0 | 1424 } |
| 1425 | |
| 1426 if (cgraph_check_inline_limits (node->callers->caller, node, | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1427 &reason, false)) |
| 0 | 1428 { |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1429 struct cgraph_node *caller = node->callers->caller; |
| 0 | 1430 cgraph_mark_inline (node->callers); |
| 1431 if (dump_file) | |
| 1432 fprintf (dump_file, | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1433 " Inlined into %s which now has %i size" |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1434 " for a net change of %+i size.\n", |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1435 cgraph_node_name (caller), |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1436 caller->global.size, |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1437 overall_size - old_size); |
| 0 | 1438 } |
| 1439 else | |
| 1440 { | |
| 1441 if (dump_file) | |
| 1442 fprintf (dump_file, | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1443 " Not inlining: %s.\n", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1444 cgraph_inline_failed_string (reason)); |
| 0 | 1445 } |
| 1446 } | |
| 1447 } | |
| 1448 } | |
| 1449 | |
| 1450 /* Free ipa-prop structures if they are no longer needed. */ | |
| 1451 if (flag_indirect_inlining) | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1452 ipa_free_all_structures_after_iinln (); |
| 0 | 1453 |
| 1454 if (dump_file) | |
| 1455 fprintf (dump_file, | |
| 1456 "\nInlined %i calls, eliminated %i functions, " | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1457 "size %i turned to %i size.\n\n", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1458 ncalls_inlined, nfunctions_inlined, initial_size, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1459 overall_size); |
| 0 | 1460 free (order); |
| 1461 return 0; | |
| 1462 } | |
| 1463 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1464 /* Return true when N is leaf function. Accept cheap (pure&const) builtins |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1465 in leaf functions. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1466 static bool |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1467 leaf_node_p (struct cgraph_node *n) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1468 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1469 struct cgraph_edge *e; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1470 for (e = n->callees; e; e = e->next_callee) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1471 if (!DECL_BUILT_IN (e->callee->decl) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1472 || (!TREE_READONLY (e->callee->decl) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1473 || DECL_PURE_P (e->callee->decl))) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1474 return false; |
| 0 | 1475 return true; |
| 1476 } | |
| 1477 | |
| 1478 /* Decide on the inlining. We do so in the topological order to avoid | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1479 expenses on updating data structures. */ |
| 0 | 1480 |
| 1481 static bool | |
| 1482 cgraph_decide_inlining_incrementally (struct cgraph_node *node, | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1483 enum inlining_mode mode) |
| 0 | 1484 { |
| 1485 struct cgraph_edge *e; | |
| 1486 bool inlined = false; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1487 cgraph_inline_failed_t failed_reason; |
| 0 | 1488 |
| 1489 #ifdef ENABLE_CHECKING | |
| 1490 verify_cgraph_node (node); | |
| 1491 #endif | |
| 1492 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1493 if (mode != INLINE_ALWAYS_INLINE && mode != INLINE_SIZE_NORECURSIVE |
| 0 | 1494 && lookup_attribute ("flatten", DECL_ATTRIBUTES (node->decl)) != NULL) |
| 1495 { | |
| 1496 if (dump_file) | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1497 fprintf (dump_file, "Incrementally flattening %s\n", |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1498 cgraph_node_name (node)); |
| 0 | 1499 mode = INLINE_ALL; |
| 1500 } | |
| 1501 | |
| 1502 /* First of all look for always inline functions. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1503 if (mode != INLINE_SIZE_NORECURSIVE) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1504 for (e = node->callees; e; e = e->next_callee) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1505 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1506 if (!e->callee->local.disregard_inline_limits |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1507 && (mode != INLINE_ALL || !e->callee->local.inlinable)) |
| 0 | 1508 continue; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1509 if (e->call_stmt_cannot_inline_p) |
| 0 | 1510 continue; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1511 if (dump_file) |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1512 fprintf (dump_file, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1513 "Considering to always inline inline candidate %s.\n", |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1514 cgraph_node_name (e->callee)); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1515 if (cgraph_recursive_inlining_p (node, e->callee, &e->inline_failed)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1516 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1517 if (dump_file) |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1518 fprintf (dump_file, "Not inlining: recursive call.\n"); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1519 continue; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1520 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1521 if (!tree_can_inline_p (e)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1522 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1523 if (dump_file) |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1524 fprintf (dump_file, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1525 "Not inlining: %s", |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1526 cgraph_inline_failed_string (e->inline_failed)); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1527 continue; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1528 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1529 if (gimple_in_ssa_p (DECL_STRUCT_FUNCTION (node->decl)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1530 != gimple_in_ssa_p (DECL_STRUCT_FUNCTION (e->callee->decl))) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1531 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1532 if (dump_file) |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1533 fprintf (dump_file, "Not inlining: SSA form does not match.\n"); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1534 continue; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1535 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1536 if (!e->callee->analyzed) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1537 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1538 if (dump_file) |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1539 fprintf (dump_file, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1540 "Not inlining: Function body no longer available.\n"); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1541 continue; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1542 } |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1543 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1544 if (dump_file) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1545 fprintf (dump_file, " Inlining %s into %s.\n", |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1546 cgraph_node_name (e->callee), |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1547 cgraph_node_name (e->caller)); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1548 cgraph_mark_inline (e); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1549 inlined = true; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1550 } |
| 0 | 1551 |
| 1552 /* Now do the automatic inlining. */ | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1553 if (mode != INLINE_ALL && mode != INLINE_ALWAYS_INLINE |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1554 /* Never inline regular functions into always-inline functions |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1555 during incremental inlining. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1556 && !node->local.disregard_inline_limits) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1557 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1558 bitmap visited = BITMAP_ALLOC (NULL); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1559 for (e = node->callees; e; e = e->next_callee) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1560 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1561 int allowed_growth = 0; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1562 if (!e->callee->local.inlinable |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1563 || !e->inline_failed |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1564 || e->callee->local.disregard_inline_limits) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1565 continue; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1566 /* We are inlining a function to all call-sites in node |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1567 or to none. So visit each candidate only once. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1568 if (!bitmap_set_bit (visited, e->callee->uid)) |
| 0 | 1569 continue; |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1570 if (dump_file) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1571 fprintf (dump_file, "Considering inline candidate %s.\n", |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1572 cgraph_node_name (e->callee)); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1573 if (cgraph_recursive_inlining_p (node, e->callee, &e->inline_failed)) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1574 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1575 if (dump_file) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1576 fprintf (dump_file, "Not inlining: recursive call.\n"); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1577 continue; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1578 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1579 if (gimple_in_ssa_p (DECL_STRUCT_FUNCTION (node->decl)) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1580 != gimple_in_ssa_p (DECL_STRUCT_FUNCTION (e->callee->decl))) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1581 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1582 if (dump_file) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1583 fprintf (dump_file, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1584 "Not inlining: SSA form does not match.\n"); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1585 continue; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1586 } |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1587 |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1588 if (cgraph_maybe_hot_edge_p (e) && leaf_node_p (e->callee) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1589 && optimize_function_for_speed_p (cfun)) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1590 allowed_growth = PARAM_VALUE (PARAM_EARLY_INLINING_INSNS); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1591 |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1592 /* When the function body would grow and inlining the function |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1593 won't eliminate the need for offline copy of the function, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1594 don't inline. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1595 if (((mode == INLINE_SIZE || mode == INLINE_SIZE_NORECURSIVE) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1596 || (!flag_inline_functions |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1597 && !DECL_DECLARED_INLINE_P (e->callee->decl))) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1598 && (cgraph_estimate_size_after_inlining (1, e->caller, e->callee) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1599 > e->caller->global.size + allowed_growth) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1600 && cgraph_estimate_growth (e->callee) > allowed_growth) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1601 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1602 if (dump_file) |
| 0 | 1603 fprintf (dump_file, |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1604 "Not inlining: code size would grow by %i.\n", |
| 0 | 1605 cgraph_estimate_size_after_inlining (1, e->caller, |
| 1606 e->callee) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1607 - e->caller->global.size); |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1608 continue; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1609 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1610 if (!cgraph_check_inline_limits (node, e->callee, &e->inline_failed, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1611 false) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1612 || e->call_stmt_cannot_inline_p) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1613 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1614 if (dump_file) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1615 fprintf (dump_file, "Not inlining: %s.\n", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1616 cgraph_inline_failed_string (e->inline_failed)); |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1617 continue; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1618 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1619 if (!e->callee->analyzed) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1620 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1621 if (dump_file) |
| 0 | 1622 fprintf (dump_file, |
| 1623 "Not inlining: Function body no longer available.\n"); | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1624 continue; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1625 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1626 if (!tree_can_inline_p (e)) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1627 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1628 if (dump_file) |
| 0 | 1629 fprintf (dump_file, |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1630 "Not inlining: %s.", |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1631 cgraph_inline_failed_string (e->inline_failed)); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1632 continue; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1633 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1634 if (cgraph_default_inline_p (e->callee, &failed_reason)) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1635 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1636 if (dump_file) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1637 fprintf (dump_file, " Inlining %s into %s.\n", |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1638 cgraph_node_name (e->callee), |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1639 cgraph_node_name (e->caller)); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1640 cgraph_mark_inline (e); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1641 inlined = true; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1642 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1643 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1644 BITMAP_FREE (visited); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1645 } |
| 0 | 1646 return inlined; |
| 1647 } | |
| 1648 | |
| 1649 /* Because inlining might remove no-longer reachable nodes, we need to | |
| 1650 keep the array visible to garbage collector to avoid reading collected | |
| 1651 out nodes. */ | |
| 1652 static int nnodes; | |
| 1653 static GTY ((length ("nnodes"))) struct cgraph_node **order; | |
| 1654 | |
| 1655 /* Do inlining of small functions. Doing so early helps profiling and other | |
| 1656 passes to be somewhat more effective and avoids some code duplication in | |
| 1657 later real inlining pass for testcases with very many function calls. */ | |
| 1658 static unsigned int | |
| 1659 cgraph_early_inlining (void) | |
| 1660 { | |
| 1661 struct cgraph_node *node = cgraph_node (current_function_decl); | |
| 1662 unsigned int todo = 0; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1663 int iterations = 0; |
| 0 | 1664 |
| 1665 if (sorrycount || errorcount) | |
| 1666 return 0; | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1667 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1668 if (!optimize |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1669 || flag_no_inline |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1670 || !flag_early_inlining) |
| 0 | 1671 { |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1672 /* When not optimizing or not inlining inline only always-inline |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1673 functions. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1674 cgraph_decide_inlining_incrementally (node, INLINE_ALWAYS_INLINE); |
| 0 | 1675 timevar_push (TV_INTEGRATION); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1676 todo |= optimize_inline_calls (current_function_decl); |
| 0 | 1677 timevar_pop (TV_INTEGRATION); |
| 1678 } | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1679 else |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1680 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1681 if (lookup_attribute ("flatten", |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1682 DECL_ATTRIBUTES (node->decl)) != NULL) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1683 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1684 if (dump_file) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1685 fprintf (dump_file, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1686 "Flattening %s\n", cgraph_node_name (node)); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1687 cgraph_flatten (node); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1688 timevar_push (TV_INTEGRATION); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1689 todo |= optimize_inline_calls (current_function_decl); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1690 timevar_pop (TV_INTEGRATION); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1691 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1692 /* We iterate incremental inlining to get trivial cases of indirect |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1693 inlining. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1694 while (iterations < PARAM_VALUE (PARAM_EARLY_INLINER_MAX_ITERATIONS) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1695 && cgraph_decide_inlining_incrementally (node, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1696 iterations |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1697 ? INLINE_SIZE_NORECURSIVE |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1698 : INLINE_SIZE)) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1699 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1700 timevar_push (TV_INTEGRATION); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1701 todo |= optimize_inline_calls (current_function_decl); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1702 iterations++; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1703 timevar_pop (TV_INTEGRATION); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1704 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1705 if (dump_file) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1706 fprintf (dump_file, "Iterations: %i\n", iterations); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1707 } |
| 0 | 1708 |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1709 cfun->always_inline_functions_inlined = true; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1710 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1711 return todo; |
| 0 | 1712 } |
| 1713 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1714 struct gimple_opt_pass pass_early_inline = |
| 0 | 1715 { |
| 1716 { | |
| 1717 GIMPLE_PASS, | |
| 1718 "einline", /* name */ | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1719 NULL, /* gate */ |
| 0 | 1720 cgraph_early_inlining, /* execute */ |
| 1721 NULL, /* sub */ | |
| 1722 NULL, /* next */ | |
| 1723 0, /* static_pass_number */ | |
| 1724 TV_INLINE_HEURISTICS, /* tv_id */ | |
| 1725 0, /* properties_required */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1726 0, /* properties_provided */ |
| 0 | 1727 0, /* properties_destroyed */ |
| 1728 0, /* todo_flags_start */ | |
| 1729 TODO_dump_func /* todo_flags_finish */ | |
| 1730 } | |
| 1731 }; | |
| 1732 | |
| 1733 /* When inlining shall be performed. */ | |
| 1734 static bool | |
| 1735 cgraph_gate_ipa_early_inlining (void) | |
| 1736 { | |
| 1737 return (flag_early_inlining | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1738 && !in_lto_p |
| 0 | 1739 && (flag_branch_probabilities || flag_test_coverage |
| 1740 || profile_arc_flag)); | |
| 1741 } | |
| 1742 | |
| 1743 /* IPA pass wrapper for early inlining pass. We need to run early inlining | |
| 1744 before tree profiling so we have stand alone IPA pass for doing so. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1745 struct simple_ipa_opt_pass pass_ipa_early_inline = |
| 0 | 1746 { |
| 1747 { | |
| 1748 SIMPLE_IPA_PASS, | |
| 1749 "einline_ipa", /* name */ | |
| 1750 cgraph_gate_ipa_early_inlining, /* gate */ | |
| 1751 NULL, /* execute */ | |
| 1752 NULL, /* sub */ | |
| 1753 NULL, /* next */ | |
| 1754 0, /* static_pass_number */ | |
| 1755 TV_INLINE_HEURISTICS, /* tv_id */ | |
| 1756 0, /* properties_required */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1757 0, /* properties_provided */ |
| 0 | 1758 0, /* properties_destroyed */ |
| 1759 0, /* todo_flags_start */ | |
| 1760 TODO_dump_cgraph /* todo_flags_finish */ | |
| 1761 } | |
| 1762 }; | |
| 1763 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1764 /* See if statement might disappear after inlining. We are not terribly |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1765 sophisficated, basically looking for simple abstraction penalty wrappers. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1766 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1767 static bool |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1768 likely_eliminated_by_inlining_p (gimple stmt) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1769 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1770 enum gimple_code code = gimple_code (stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1771 switch (code) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1772 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1773 case GIMPLE_RETURN: |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1774 return true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1775 case GIMPLE_ASSIGN: |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1776 if (gimple_num_ops (stmt) != 2) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1777 return false; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1778 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1779 /* Casts of parameters, loads from parameters passed by reference |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1780 and stores to return value or parameters are probably free after |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1781 inlining. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1782 if (gimple_assign_rhs_code (stmt) == CONVERT_EXPR |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1783 || gimple_assign_rhs_code (stmt) == NOP_EXPR |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1784 || gimple_assign_rhs_code (stmt) == VIEW_CONVERT_EXPR |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1785 || gimple_assign_rhs_class (stmt) == GIMPLE_SINGLE_RHS) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1786 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1787 tree rhs = gimple_assign_rhs1 (stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1788 tree lhs = gimple_assign_lhs (stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1789 tree inner_rhs = rhs; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1790 tree inner_lhs = lhs; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1791 bool rhs_free = false; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1792 bool lhs_free = false; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1793 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1794 while (handled_component_p (inner_lhs) || TREE_CODE (inner_lhs) == INDIRECT_REF) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1795 inner_lhs = TREE_OPERAND (inner_lhs, 0); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1796 while (handled_component_p (inner_rhs) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1797 || TREE_CODE (inner_rhs) == ADDR_EXPR || TREE_CODE (inner_rhs) == INDIRECT_REF) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1798 inner_rhs = TREE_OPERAND (inner_rhs, 0); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1799 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1800 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1801 if (TREE_CODE (inner_rhs) == PARM_DECL |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1802 || (TREE_CODE (inner_rhs) == SSA_NAME |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1803 && SSA_NAME_IS_DEFAULT_DEF (inner_rhs) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1804 && TREE_CODE (SSA_NAME_VAR (inner_rhs)) == PARM_DECL)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1805 rhs_free = true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1806 if (rhs_free && is_gimple_reg (lhs)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1807 lhs_free = true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1808 if (((TREE_CODE (inner_lhs) == PARM_DECL |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1809 || (TREE_CODE (inner_lhs) == SSA_NAME |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1810 && SSA_NAME_IS_DEFAULT_DEF (inner_lhs) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1811 && TREE_CODE (SSA_NAME_VAR (inner_lhs)) == PARM_DECL)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1812 && inner_lhs != lhs) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1813 || TREE_CODE (inner_lhs) == RESULT_DECL |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1814 || (TREE_CODE (inner_lhs) == SSA_NAME |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1815 && TREE_CODE (SSA_NAME_VAR (inner_lhs)) == RESULT_DECL)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1816 lhs_free = true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1817 if (lhs_free && (is_gimple_reg (rhs) || is_gimple_min_invariant (rhs))) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1818 rhs_free = true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1819 if (lhs_free && rhs_free) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1820 return true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1821 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1822 return false; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1823 default: |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1824 return false; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1825 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1826 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1827 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1828 /* Compute function body size parameters for NODE. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1829 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1830 static void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1831 estimate_function_body_sizes (struct cgraph_node *node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1832 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1833 gcov_type time = 0; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1834 gcov_type time_inlining_benefit = 0; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1835 int size = 0; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1836 int size_inlining_benefit = 0; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1837 basic_block bb; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1838 gimple_stmt_iterator bsi; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1839 struct function *my_function = DECL_STRUCT_FUNCTION (node->decl); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1840 tree arg; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1841 int freq; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1842 tree funtype = TREE_TYPE (node->decl); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1843 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1844 if (dump_file) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1845 fprintf (dump_file, "Analyzing function body size: %s\n", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1846 cgraph_node_name (node)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1847 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1848 gcc_assert (my_function && my_function->cfg); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1849 FOR_EACH_BB_FN (bb, my_function) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1850 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1851 freq = compute_call_stmt_bb_frequency (node->decl, bb); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1852 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1853 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1854 gimple stmt = gsi_stmt (bsi); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1855 int this_size = estimate_num_insns (stmt, &eni_size_weights); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1856 int this_time = estimate_num_insns (stmt, &eni_time_weights); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1857 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1858 if (dump_file && (dump_flags & TDF_DETAILS)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1859 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1860 fprintf (dump_file, " freq:%6i size:%3i time:%3i ", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1861 freq, this_size, this_time); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1862 print_gimple_stmt (dump_file, stmt, 0, 0); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1863 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1864 this_time *= freq; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1865 time += this_time; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1866 size += this_size; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1867 if (likely_eliminated_by_inlining_p (stmt)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1868 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1869 size_inlining_benefit += this_size; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1870 time_inlining_benefit += this_time; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1871 if (dump_file && (dump_flags & TDF_DETAILS)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1872 fprintf (dump_file, " Likely eliminated\n"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1873 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1874 gcc_assert (time >= 0); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1875 gcc_assert (size >= 0); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1876 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1877 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1878 time = (time + CGRAPH_FREQ_BASE / 2) / CGRAPH_FREQ_BASE; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1879 time_inlining_benefit = ((time_inlining_benefit + CGRAPH_FREQ_BASE / 2) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1880 / CGRAPH_FREQ_BASE); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1881 if (dump_file) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1882 fprintf (dump_file, "Overall function body time: %i-%i size: %i-%i\n", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1883 (int)time, (int)time_inlining_benefit, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1884 size, size_inlining_benefit); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1885 time_inlining_benefit += eni_time_weights.call_cost; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1886 size_inlining_benefit += eni_size_weights.call_cost; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1887 if (!VOID_TYPE_P (TREE_TYPE (funtype))) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1888 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1889 int cost = estimate_move_cost (TREE_TYPE (funtype)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1890 time_inlining_benefit += cost; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1891 size_inlining_benefit += cost; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1892 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1893 for (arg = DECL_ARGUMENTS (node->decl); arg; arg = TREE_CHAIN (arg)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1894 if (!VOID_TYPE_P (TREE_TYPE (arg))) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1895 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1896 int cost = estimate_move_cost (TREE_TYPE (arg)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1897 time_inlining_benefit += cost; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1898 size_inlining_benefit += cost; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1899 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1900 if (time_inlining_benefit > MAX_TIME) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1901 time_inlining_benefit = MAX_TIME; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1902 if (time > MAX_TIME) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1903 time = MAX_TIME; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1904 inline_summary (node)->self_time = time; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1905 inline_summary (node)->self_size = size; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1906 if (dump_file) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1907 fprintf (dump_file, "With function call overhead time: %i-%i size: %i-%i\n", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1908 (int)time, (int)time_inlining_benefit, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1909 size, size_inlining_benefit); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1910 inline_summary (node)->time_inlining_benefit = time_inlining_benefit; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1911 inline_summary (node)->size_inlining_benefit = size_inlining_benefit; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1912 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1913 |
| 0 | 1914 /* Compute parameters of functions used by inliner. */ |
| 1915 unsigned int | |
| 1916 compute_inline_parameters (struct cgraph_node *node) | |
| 1917 { | |
| 1918 HOST_WIDE_INT self_stack_size; | |
| 1919 | |
| 1920 gcc_assert (!node->global.inlined_to); | |
| 1921 | |
| 1922 /* Estimate the stack size for the function. But not at -O0 | |
| 1923 because estimated_stack_frame_size is a quadratic problem. */ | |
| 1924 self_stack_size = optimize ? estimated_stack_frame_size () : 0; | |
| 1925 inline_summary (node)->estimated_self_stack_size = self_stack_size; | |
| 1926 node->global.estimated_stack_size = self_stack_size; | |
| 1927 node->global.stack_frame_offset = 0; | |
| 1928 | |
| 1929 /* Can this function be inlined at all? */ | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1930 node->local.inlinable = tree_inlinable_function_p (node->decl); |
| 0 | 1931 if (node->local.inlinable && !node->local.disregard_inline_limits) |
| 1932 node->local.disregard_inline_limits | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1933 = DECL_DISREGARD_INLINE_LIMITS (node->decl); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1934 estimate_function_body_sizes (node); |
| 0 | 1935 /* Inlining characteristics are maintained by the cgraph_mark_inline. */ |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1936 node->global.time = inline_summary (node)->self_time; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1937 node->global.size = inline_summary (node)->self_size; |
| 0 | 1938 return 0; |
| 1939 } | |
| 1940 | |
| 1941 | |
| 1942 /* Compute parameters of functions used by inliner using | |
| 1943 current_function_decl. */ | |
| 1944 static unsigned int | |
| 1945 compute_inline_parameters_for_current (void) | |
| 1946 { | |
| 1947 compute_inline_parameters (cgraph_node (current_function_decl)); | |
| 1948 return 0; | |
| 1949 } | |
| 1950 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1951 struct gimple_opt_pass pass_inline_parameters = |
| 0 | 1952 { |
| 1953 { | |
| 1954 GIMPLE_PASS, | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1955 "inline_param", /* name */ |
| 0 | 1956 NULL, /* gate */ |
| 1957 compute_inline_parameters_for_current,/* execute */ | |
| 1958 NULL, /* sub */ | |
| 1959 NULL, /* next */ | |
| 1960 0, /* static_pass_number */ | |
| 1961 TV_INLINE_HEURISTICS, /* tv_id */ | |
| 1962 0, /* properties_required */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1963 0, /* properties_provided */ |
| 0 | 1964 0, /* properties_destroyed */ |
| 1965 0, /* todo_flags_start */ | |
| 1966 0 /* todo_flags_finish */ | |
| 1967 } | |
| 1968 }; | |
| 1969 | |
| 1970 /* This function performs intraprocedural analyzis in NODE that is required to | |
| 1971 inline indirect calls. */ | |
| 1972 static void | |
| 1973 inline_indirect_intraprocedural_analysis (struct cgraph_node *node) | |
| 1974 { | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1975 ipa_initialize_node_params (node); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1976 ipa_detect_param_modifications (node); |
| 0 | 1977 ipa_analyze_params_uses (node); |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1978 ipa_compute_jump_functions (node); |
| 0 | 1979 |
| 1980 if (dump_file) | |
| 1981 { | |
| 1982 ipa_print_node_params (dump_file, node); | |
| 1983 ipa_print_node_jump_functions (dump_file, node); | |
| 1984 } | |
| 1985 } | |
| 1986 | |
| 1987 /* Note function body size. */ | |
| 1988 static void | |
| 1989 analyze_function (struct cgraph_node *node) | |
| 1990 { | |
| 1991 push_cfun (DECL_STRUCT_FUNCTION (node->decl)); | |
| 1992 current_function_decl = node->decl; | |
| 1993 | |
| 1994 compute_inline_parameters (node); | |
| 1995 if (flag_indirect_inlining) | |
| 1996 inline_indirect_intraprocedural_analysis (node); | |
| 1997 | |
| 1998 current_function_decl = NULL; | |
| 1999 pop_cfun (); | |
| 2000 } | |
| 2001 | |
| 2002 /* Called when new function is inserted to callgraph late. */ | |
| 2003 static void | |
| 2004 add_new_function (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED) | |
| 2005 { | |
| 2006 analyze_function (node); | |
| 2007 } | |
| 2008 | |
| 2009 /* Note function body size. */ | |
| 2010 static void | |
| 2011 inline_generate_summary (void) | |
| 2012 { | |
| 2013 struct cgraph_node *node; | |
| 2014 | |
| 2015 function_insertion_hook_holder = | |
| 2016 cgraph_add_function_insertion_hook (&add_new_function, NULL); | |
| 2017 | |
| 2018 if (flag_indirect_inlining) | |
| 2019 { | |
| 2020 ipa_register_cgraph_hooks (); | |
| 2021 ipa_check_create_node_params (); | |
| 2022 ipa_check_create_edge_args (); | |
| 2023 } | |
| 2024 | |
| 2025 for (node = cgraph_nodes; node; node = node->next) | |
| 2026 if (node->analyzed) | |
| 2027 analyze_function (node); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2028 |
| 0 | 2029 return; |
| 2030 } | |
| 2031 | |
| 2032 /* Apply inline plan to function. */ | |
| 2033 static unsigned int | |
| 2034 inline_transform (struct cgraph_node *node) | |
| 2035 { | |
| 2036 unsigned int todo = 0; | |
| 2037 struct cgraph_edge *e; | |
| 2038 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2039 /* FIXME: Currently the passmanager is adding inline transform more than once to some |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2040 clones. This needs revisiting after WPA cleanups. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2041 if (cfun->after_inlining) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2042 return 0; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2043 |
| 0 | 2044 /* We might need the body of this function so that we can expand |
| 2045 it inline somewhere else. */ | |
| 2046 if (cgraph_preserve_function_body_p (node->decl)) | |
| 2047 save_inline_function_body (node); | |
| 2048 | |
| 2049 for (e = node->callees; e; e = e->next_callee) | |
| 2050 if (!e->inline_failed || warn_inline) | |
| 2051 break; | |
| 2052 | |
| 2053 if (e) | |
| 2054 { | |
| 2055 timevar_push (TV_INTEGRATION); | |
| 2056 todo = optimize_inline_calls (current_function_decl); | |
| 2057 timevar_pop (TV_INTEGRATION); | |
| 2058 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2059 cfun->always_inline_functions_inlined = true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2060 cfun->after_inlining = true; |
| 0 | 2061 return todo | execute_fixup_cfg (); |
| 2062 } | |
| 2063 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2064 /* Read inline summary. Jump functions are shared among ipa-cp |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2065 and inliner, so when ipa-cp is active, we don't need to write them |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2066 twice. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2067 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2068 static void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2069 inline_read_summary (void) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2070 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2071 if (flag_indirect_inlining) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2072 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2073 ipa_register_cgraph_hooks (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2074 if (!flag_ipa_cp) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2075 ipa_prop_read_jump_functions (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2076 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2077 function_insertion_hook_holder = |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2078 cgraph_add_function_insertion_hook (&add_new_function, NULL); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2079 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2080 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2081 /* Write inline summary for node in SET. |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2082 Jump functions are shared among ipa-cp and inliner, so when ipa-cp is |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2083 active, we don't need to write them twice. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2084 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2085 static void |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2086 inline_write_summary (cgraph_node_set set, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2087 varpool_node_set vset ATTRIBUTE_UNUSED) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2088 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2089 if (flag_indirect_inlining && !flag_ipa_cp) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2090 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:
0
diff
changeset
|
2091 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2092 |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2093 /* When to run IPA inlining. Inlining of always-inline functions |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2094 happens during early inlining. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2095 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2096 static bool |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2097 gate_cgraph_decide_inlining (void) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2098 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2099 /* ??? We'd like to skip this if not optimizing or not inlining as |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2100 all always-inline functions have been processed by early |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2101 inlining already. But this at least breaks EH with C++ as |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2102 we need to unconditionally run fixup_cfg even at -O0. |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2103 So leave it on unconditionally for now. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2104 return 1; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2105 } |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2106 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2107 struct ipa_opt_pass_d pass_ipa_inline = |
| 0 | 2108 { |
| 2109 { | |
| 2110 IPA_PASS, | |
| 2111 "inline", /* name */ | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2112 gate_cgraph_decide_inlining, /* gate */ |
| 0 | 2113 cgraph_decide_inlining, /* execute */ |
| 2114 NULL, /* sub */ | |
| 2115 NULL, /* next */ | |
| 2116 0, /* static_pass_number */ | |
| 2117 TV_INLINE_HEURISTICS, /* tv_id */ | |
| 2118 0, /* properties_required */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2119 0, /* properties_provided */ |
| 0 | 2120 0, /* properties_destroyed */ |
| 2121 TODO_remove_functions, /* todo_flags_finish */ | |
| 2122 TODO_dump_cgraph | TODO_dump_func | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2123 | TODO_remove_functions | TODO_ggc_collect /* todo_flags_finish */ |
| 0 | 2124 }, |
| 2125 inline_generate_summary, /* generate_summary */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2126 inline_write_summary, /* write_summary */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2127 inline_read_summary, /* read_summary */ |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2128 NULL, /* write_optimization_summary */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2129 NULL, /* read_optimization_summary */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2130 NULL, /* stmt_fixup */ |
| 0 | 2131 0, /* TODOs */ |
| 2132 inline_transform, /* function_transform */ | |
| 2133 NULL, /* variable_transform */ | |
| 2134 }; | |
| 2135 | |
| 2136 | |
| 2137 #include "gt-ipa-inline.h" |