Mercurial > hg > CbC > CbC_gcc
annotate gcc/tree-tailcall.c @ 96:506ac5e3963a
modify expand_call
author | Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp> |
---|---|
date | Tue, 17 Jan 2012 06:11:37 +0900 |
parents | f6334be47118 |
children | 04ced10e8804 |
rev | line source |
---|---|
0 | 1 /* Tail call optimization on trees. |
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, 2005, 2006, 2007, 2008, 2009, 2010 |
0 | 3 Free Software Foundation, Inc. |
4 | |
5 This file is part of GCC. | |
6 | |
7 GCC is free software; you can redistribute it and/or modify | |
8 it under the terms of the GNU General Public License as published by | |
9 the Free Software Foundation; either version 3, or (at your option) | |
10 any later version. | |
11 | |
12 GCC is distributed in the hope that it will be useful, | |
13 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 GNU General Public License for more details. | |
16 | |
17 You should have received a copy of the GNU General Public License | |
18 along with GCC; see the file COPYING3. If not see | |
19 <http://www.gnu.org/licenses/>. */ | |
20 | |
21 #include "config.h" | |
22 #include "system.h" | |
23 #include "coretypes.h" | |
24 #include "tm.h" | |
25 #include "tree.h" | |
26 #include "tm_p.h" | |
27 #include "basic-block.h" | |
28 #include "function.h" | |
29 #include "tree-flow.h" | |
30 #include "tree-dump.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
|
31 #include "gimple-pretty-print.h" |
0 | 32 #include "except.h" |
33 #include "tree-pass.h" | |
34 #include "flags.h" | |
35 #include "langhooks.h" | |
36 #include "dbgcnt.h" | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
37 #include "target.h" |
0 | 38 |
39 /* The file implements the tail recursion elimination. It is also used to | |
40 analyze the tail calls in general, passing the results to the rtl level | |
41 where they are used for sibcall optimization. | |
42 | |
43 In addition to the standard tail recursion elimination, we handle the most | |
44 trivial cases of making the call tail recursive by creating accumulators. | |
45 For example the following function | |
46 | |
47 int sum (int n) | |
48 { | |
49 if (n > 0) | |
50 return n + sum (n - 1); | |
51 else | |
52 return 0; | |
53 } | |
54 | |
55 is transformed into | |
56 | |
57 int sum (int n) | |
58 { | |
59 int acc = 0; | |
60 | |
61 while (n > 0) | |
62 acc += n--; | |
63 | |
64 return acc; | |
65 } | |
66 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
67 To do this, we maintain two accumulators (a_acc and m_acc) that indicate |
0 | 68 when we reach the return x statement, we should return a_acc + x * m_acc |
69 instead. They are initially initialized to 0 and 1, respectively, | |
70 so the semantics of the function is obviously preserved. If we are | |
71 guaranteed that the value of the accumulator never change, we | |
72 omit the accumulator. | |
73 | |
74 There are three cases how the function may exit. The first one is | |
75 handled in adjust_return_value, the other two in adjust_accumulator_values | |
76 (the second case is actually a special case of the third one and we | |
77 present it separately just for clarity): | |
78 | |
79 1) Just return x, where x is not in any of the remaining special shapes. | |
80 We rewrite this to a gimple equivalent of return m_acc * x + a_acc. | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
81 |
0 | 82 2) return f (...), where f is the current function, is rewritten in a |
83 classical tail-recursion elimination way, into assignment of arguments | |
84 and jump to the start of the function. Values of the accumulators | |
85 are unchanged. | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
86 |
0 | 87 3) return a + m * f(...), where a and m do not depend on call to f. |
88 To preserve the semantics described before we want this to be rewritten | |
89 in such a way that we finally return | |
90 | |
91 a_acc + (a + m * f(...)) * m_acc = (a_acc + a * m_acc) + (m * m_acc) * f(...). | |
92 | |
93 I.e. we increase a_acc by a * m_acc, multiply m_acc by m and | |
94 eliminate the tail call to f. Special cases when the value is just | |
95 added or just multiplied are obtained by setting a = 0 or m = 1. | |
96 | |
97 TODO -- it is possible to do similar tricks for other operations. */ | |
98 | |
99 /* A structure that describes the tailcall. */ | |
100 | |
101 struct tailcall | |
102 { | |
103 /* The iterator pointing to the call statement. */ | |
104 gimple_stmt_iterator call_gsi; | |
105 | |
106 /* True if it is a call to the current function. */ | |
107 bool tail_recursion; | |
108 | |
109 /* The return value of the caller is mult * f + add, where f is the return | |
110 value of the call. */ | |
111 tree mult, add; | |
112 | |
113 /* Next tailcall in the chain. */ | |
114 struct tailcall *next; | |
115 }; | |
116 | |
117 /* The variables holding the value of multiplicative and additive | |
118 accumulator. */ | |
119 static tree m_acc, a_acc; | |
120 | |
121 static bool suitable_for_tail_opt_p (void); | |
122 static bool optimize_tail_call (struct tailcall *, bool); | |
123 static void eliminate_tail_call (struct tailcall *); | |
124 static void find_tail_calls (basic_block, struct tailcall **); | |
125 | |
126 /* Returns false when the function is not suitable for tail call optimization | |
127 from some reason (e.g. if it takes variable number of arguments). */ | |
128 | |
129 static bool | |
130 suitable_for_tail_opt_p (void) | |
131 { | |
132 if (cfun->stdarg) | |
133 return false; | |
134 | |
135 return true; | |
136 } | |
137 /* Returns false when the function is not suitable for tail call optimization | |
138 from some reason (e.g. if it takes variable number of arguments). | |
139 This test must pass in addition to suitable_for_tail_opt_p in order to make | |
140 tail call discovery happen. */ | |
141 | |
142 static bool | |
143 suitable_for_tail_call_opt_p (void) | |
144 { | |
145 tree param; | |
146 | |
147 /* alloca (until we have stack slot life analysis) inhibits | |
148 sibling call optimizations, but not tail recursion. */ | |
149 if (cfun->calls_alloca) | |
150 return false; | |
151 | |
152 /* If we are using sjlj exceptions, we may need to add a call to | |
153 _Unwind_SjLj_Unregister at exit of the function. Which means | |
154 that we cannot do any sibcall transformations. */ | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
155 if (targetm.except_unwind_info (&global_options) == UI_SJLJ |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
156 && current_function_has_exception_handlers ()) |
0 | 157 return false; |
158 | |
159 /* Any function that calls setjmp might have longjmp called from | |
160 any called function. ??? We really should represent this | |
161 properly in the CFG so that this needn't be special cased. */ | |
162 if (cfun->calls_setjmp) | |
163 return false; | |
164 | |
165 /* ??? It is OK if the argument of a function is taken in some cases, | |
166 but not in all cases. See PR15387 and PR19616. Revisit for 4.1. */ | |
167 for (param = DECL_ARGUMENTS (current_function_decl); | |
168 param; | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
169 param = DECL_CHAIN (param)) |
0 | 170 if (TREE_ADDRESSABLE (param)) |
171 return false; | |
172 | |
173 return true; | |
174 } | |
175 | |
176 /* Checks whether the expression EXPR in stmt AT is independent of the | |
177 statement pointed to by GSI (in a sense that we already know EXPR's value | |
178 at GSI). We use the fact that we are only called from the chain of | |
179 basic blocks that have only single successor. Returns the expression | |
180 containing the value of EXPR at GSI. */ | |
181 | |
182 static tree | |
183 independent_of_stmt_p (tree expr, gimple at, gimple_stmt_iterator gsi) | |
184 { | |
185 basic_block bb, call_bb, at_bb; | |
186 edge e; | |
187 edge_iterator ei; | |
188 | |
189 if (is_gimple_min_invariant (expr)) | |
190 return expr; | |
191 | |
192 if (TREE_CODE (expr) != SSA_NAME) | |
193 return NULL_TREE; | |
194 | |
195 /* Mark the blocks in the chain leading to the end. */ | |
196 at_bb = gimple_bb (at); | |
197 call_bb = gimple_bb (gsi_stmt (gsi)); | |
198 for (bb = call_bb; bb != at_bb; bb = single_succ (bb)) | |
199 bb->aux = &bb->aux; | |
200 bb->aux = &bb->aux; | |
201 | |
202 while (1) | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
203 { |
0 | 204 at = SSA_NAME_DEF_STMT (expr); |
205 bb = gimple_bb (at); | |
206 | |
207 /* The default definition or defined before the chain. */ | |
208 if (!bb || !bb->aux) | |
209 break; | |
210 | |
211 if (bb == call_bb) | |
212 { | |
213 for (; !gsi_end_p (gsi); gsi_next (&gsi)) | |
214 if (gsi_stmt (gsi) == at) | |
215 break; | |
216 | |
217 if (!gsi_end_p (gsi)) | |
218 expr = NULL_TREE; | |
219 break; | |
220 } | |
221 | |
222 if (gimple_code (at) != GIMPLE_PHI) | |
223 { | |
224 expr = NULL_TREE; | |
225 break; | |
226 } | |
227 | |
228 FOR_EACH_EDGE (e, ei, bb->preds) | |
229 if (e->src->aux) | |
230 break; | |
231 gcc_assert (e); | |
232 | |
233 expr = PHI_ARG_DEF_FROM_EDGE (at, e); | |
234 if (TREE_CODE (expr) != SSA_NAME) | |
235 { | |
236 /* The value is a constant. */ | |
237 break; | |
238 } | |
239 } | |
240 | |
241 /* Unmark the blocks. */ | |
242 for (bb = call_bb; bb != at_bb; bb = single_succ (bb)) | |
243 bb->aux = NULL; | |
244 bb->aux = NULL; | |
245 | |
246 return expr; | |
247 } | |
248 | |
249 /* Simulates the effect of an assignment STMT on the return value of the tail | |
250 recursive CALL passed in ASS_VAR. M and A are the multiplicative and the | |
251 additive factor for the real return value. */ | |
252 | |
253 static bool | |
254 process_assignment (gimple stmt, gimple_stmt_iterator call, tree *m, | |
255 tree *a, tree *ass_var) | |
256 { | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
257 tree op0, op1 = NULL_TREE, non_ass_var = NULL_TREE; |
0 | 258 tree dest = gimple_assign_lhs (stmt); |
259 enum tree_code code = gimple_assign_rhs_code (stmt); | |
260 enum gimple_rhs_class rhs_class = get_gimple_rhs_class (code); | |
261 tree src_var = gimple_assign_rhs1 (stmt); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
262 |
0 | 263 /* See if this is a simple copy operation of an SSA name to the function |
264 result. In that case we may have a simple tail call. Ignore type | |
265 conversions that can never produce extra code between the function | |
266 call and the function return. */ | |
267 if ((rhs_class == GIMPLE_SINGLE_RHS || gimple_assign_cast_p (stmt)) | |
268 && (TREE_CODE (src_var) == SSA_NAME)) | |
269 { | |
270 /* Reject a tailcall if the type conversion might need | |
271 additional code. */ | |
272 if (gimple_assign_cast_p (stmt) | |
273 && TYPE_MODE (TREE_TYPE (dest)) != TYPE_MODE (TREE_TYPE (src_var))) | |
274 return false; | |
275 | |
276 if (src_var != *ass_var) | |
277 return false; | |
278 | |
279 *ass_var = dest; | |
280 return true; | |
281 } | |
282 | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
283 switch (rhs_class) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
284 { |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
285 case GIMPLE_BINARY_RHS: |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
286 op1 = gimple_assign_rhs2 (stmt); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
287 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
288 /* Fall through. */ |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
289 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
290 case GIMPLE_UNARY_RHS: |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
291 op0 = gimple_assign_rhs1 (stmt); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
292 break; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
293 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
294 default: |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
295 return false; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
296 } |
0 | 297 |
298 /* Accumulator optimizations will reverse the order of operations. | |
299 We can only do that for floating-point types if we're assuming | |
300 that addition and multiplication are associative. */ | |
301 if (!flag_associative_math) | |
302 if (FLOAT_TYPE_P (TREE_TYPE (DECL_RESULT (current_function_decl)))) | |
303 return false; | |
304 | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
305 if (rhs_class == GIMPLE_UNARY_RHS) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
306 ; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
307 else if (op0 == *ass_var |
0 | 308 && (non_ass_var = independent_of_stmt_p (op1, stmt, call))) |
309 ; | |
310 else if (op1 == *ass_var | |
311 && (non_ass_var = independent_of_stmt_p (op0, stmt, call))) | |
312 ; | |
313 else | |
314 return false; | |
315 | |
316 switch (code) | |
317 { | |
318 case PLUS_EXPR: | |
319 *a = non_ass_var; | |
320 *ass_var = dest; | |
321 return true; | |
322 | |
323 case MULT_EXPR: | |
324 *m = non_ass_var; | |
325 *ass_var = dest; | |
326 return true; | |
327 | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
328 case NEGATE_EXPR: |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
329 if (FLOAT_TYPE_P (TREE_TYPE (op0))) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
330 *m = build_real (TREE_TYPE (op0), dconstm1); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
331 else |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
332 *m = build_int_cst (TREE_TYPE (op0), -1); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
333 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
334 *ass_var = dest; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
335 return true; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
336 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
337 case MINUS_EXPR: |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
338 if (*ass_var == op0) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
339 *a = fold_build1 (NEGATE_EXPR, TREE_TYPE (non_ass_var), non_ass_var); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
340 else |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
341 { |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
342 if (FLOAT_TYPE_P (TREE_TYPE (non_ass_var))) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
343 *m = build_real (TREE_TYPE (non_ass_var), dconstm1); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
344 else |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
345 *m = build_int_cst (TREE_TYPE (non_ass_var), -1); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
346 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
347 *a = fold_build1 (NEGATE_EXPR, TREE_TYPE (non_ass_var), non_ass_var); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
348 } |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
349 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
350 *ass_var = dest; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
351 return true; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
352 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
353 /* TODO -- Handle POINTER_PLUS_EXPR. */ |
0 | 354 |
355 default: | |
356 return false; | |
357 } | |
358 } | |
359 | |
360 /* Propagate VAR through phis on edge E. */ | |
361 | |
362 static tree | |
363 propagate_through_phis (tree var, edge e) | |
364 { | |
365 basic_block dest = e->dest; | |
366 gimple_stmt_iterator gsi; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
367 |
0 | 368 for (gsi = gsi_start_phis (dest); !gsi_end_p (gsi); gsi_next (&gsi)) |
369 { | |
370 gimple phi = gsi_stmt (gsi); | |
371 if (PHI_ARG_DEF_FROM_EDGE (phi, e) == var) | |
372 return PHI_RESULT (phi); | |
373 } | |
374 return var; | |
375 } | |
376 | |
377 /* Finds tailcalls falling into basic block BB. The list of found tailcalls is | |
378 added to the start of RET. */ | |
379 | |
380 static void | |
381 find_tail_calls (basic_block bb, struct tailcall **ret) | |
382 { | |
383 tree ass_var = NULL_TREE, ret_var, func, param; | |
384 gimple stmt, call = NULL; | |
385 gimple_stmt_iterator gsi, agsi; | |
386 bool tail_recursion; | |
387 struct tailcall *nw; | |
388 edge e; | |
389 tree m, a; | |
390 basic_block abb; | |
391 size_t idx; | |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
392 tree var; |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
393 referenced_var_iterator rvi; |
0 | 394 |
395 if (!single_succ_p (bb)) | |
396 return; | |
397 | |
398 for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi); gsi_prev (&gsi)) | |
399 { | |
400 stmt = gsi_stmt (gsi); | |
401 | |
402 /* Ignore labels. */ | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
403 if (gimple_code (stmt) == GIMPLE_LABEL || is_gimple_debug (stmt)) |
0 | 404 continue; |
405 | |
406 /* Check for a call. */ | |
407 if (is_gimple_call (stmt)) | |
408 { | |
409 call = stmt; | |
410 ass_var = gimple_call_lhs (stmt); | |
411 break; | |
412 } | |
413 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
414 /* If the statement references memory or volatile operands, fail. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
415 if (gimple_references_memory_p (stmt) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
416 || gimple_has_volatile_ops (stmt)) |
0 | 417 return; |
418 } | |
419 | |
420 if (gsi_end_p (gsi)) | |
421 { | |
422 edge_iterator ei; | |
423 /* Recurse to the predecessors. */ | |
424 FOR_EACH_EDGE (e, ei, bb->preds) | |
425 find_tail_calls (e->src, ret); | |
426 | |
427 return; | |
428 } | |
429 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
430 /* If the LHS of our call is not just a simple register, we can't |
0 | 431 transform this into a tail or sibling call. This situation happens, |
432 in (e.g.) "*p = foo()" where foo returns a struct. In this case | |
433 we won't have a temporary here, but we need to carry out the side | |
434 effect anyway, so tailcall is impossible. | |
435 | |
436 ??? In some situations (when the struct is returned in memory via | |
437 invisible argument) we could deal with this, e.g. by passing 'p' | |
438 itself as that argument to foo, but it's too early to do this here, | |
439 and expand_call() will not handle it anyway. If it ever can, then | |
440 we need to revisit this here, to allow that situation. */ | |
441 if (ass_var && !is_gimple_reg (ass_var)) | |
442 return; | |
443 | |
444 /* We found the call, check whether it is suitable. */ | |
445 tail_recursion = false; | |
446 func = gimple_call_fndecl (call); | |
447 if (func == current_function_decl) | |
448 { | |
449 tree arg; | |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
450 |
0 | 451 for (param = DECL_ARGUMENTS (func), idx = 0; |
452 param && idx < gimple_call_num_args (call); | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
453 param = DECL_CHAIN (param), idx ++) |
0 | 454 { |
455 arg = gimple_call_arg (call, idx); | |
456 if (param != arg) | |
457 { | |
458 /* Make sure there are no problems with copying. The parameter | |
459 have a copyable type and the two arguments must have reasonably | |
460 equivalent types. The latter requirement could be relaxed if | |
461 we emitted a suitable type conversion statement. */ | |
462 if (!is_gimple_reg_type (TREE_TYPE (param)) | |
463 || !useless_type_conversion_p (TREE_TYPE (param), | |
464 TREE_TYPE (arg))) | |
465 break; | |
466 | |
467 /* The parameter should be a real operand, so that phi node | |
468 created for it at the start of the function has the meaning | |
469 of copying the value. This test implies is_gimple_reg_type | |
470 from the previous condition, however this one could be | |
471 relaxed by being more careful with copying the new value | |
472 of the parameter (emitting appropriate GIMPLE_ASSIGN and | |
473 updating the virtual operands). */ | |
474 if (!is_gimple_reg (param)) | |
475 break; | |
476 } | |
477 } | |
478 if (idx == gimple_call_num_args (call) && !param) | |
479 tail_recursion = true; | |
480 } | |
481 | |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
482 /* Make sure the tail invocation of this function does not refer |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
483 to local variables. */ |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
484 FOR_EACH_REFERENCED_VAR (cfun, var, rvi) |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
485 { |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
486 if (TREE_CODE (var) != PARM_DECL |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
487 && auto_var_in_fn_p (var, cfun->decl) |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
488 && (ref_maybe_used_by_stmt_p (call, var) |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
489 || call_may_clobber_ref_p (call, var))) |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
490 return; |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
491 } |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
492 |
0 | 493 /* Now check the statements after the call. None of them has virtual |
494 operands, so they may only depend on the call through its return | |
495 value. The return value should also be dependent on each of them, | |
496 since we are running after dce. */ | |
497 m = NULL_TREE; | |
498 a = NULL_TREE; | |
499 | |
500 abb = bb; | |
501 agsi = gsi; | |
502 while (1) | |
503 { | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
504 tree tmp_a = NULL_TREE; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
505 tree tmp_m = NULL_TREE; |
0 | 506 gsi_next (&agsi); |
507 | |
508 while (gsi_end_p (agsi)) | |
509 { | |
510 ass_var = propagate_through_phis (ass_var, single_succ_edge (abb)); | |
511 abb = single_succ (abb); | |
512 agsi = gsi_start_bb (abb); | |
513 } | |
514 | |
515 stmt = gsi_stmt (agsi); | |
516 | |
517 if (gimple_code (stmt) == GIMPLE_LABEL) | |
518 continue; | |
519 | |
520 if (gimple_code (stmt) == GIMPLE_RETURN) | |
521 break; | |
522 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
523 if (is_gimple_debug (stmt)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
524 continue; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
525 |
0 | 526 if (gimple_code (stmt) != GIMPLE_ASSIGN) |
527 return; | |
528 | |
529 /* This is a gimple assign. */ | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
530 if (! process_assignment (stmt, gsi, &tmp_m, &tmp_a, &ass_var)) |
0 | 531 return; |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
532 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
533 if (tmp_a) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
534 { |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
535 tree type = TREE_TYPE (tmp_a); |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
536 if (a) |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
537 a = fold_build2 (PLUS_EXPR, type, fold_convert (type, a), tmp_a); |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
538 else |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
539 a = tmp_a; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
540 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
541 if (tmp_m) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
542 { |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
543 tree type = TREE_TYPE (tmp_m); |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
544 if (m) |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
545 m = fold_build2 (MULT_EXPR, type, fold_convert (type, m), tmp_m); |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
546 else |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
547 m = tmp_m; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
548 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
549 if (a) |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
550 a = fold_build2 (MULT_EXPR, type, fold_convert (type, a), tmp_m); |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
551 } |
0 | 552 } |
553 | |
554 /* See if this is a tail call we can handle. */ | |
555 ret_var = gimple_return_retval (stmt); | |
556 | |
557 /* We may proceed if there either is no return value, or the return value | |
558 is identical to the call's return. */ | |
559 if (ret_var | |
560 && (ret_var != ass_var)) | |
561 return; | |
562 | |
563 /* If this is not a tail recursive call, we cannot handle addends or | |
564 multiplicands. */ | |
565 if (!tail_recursion && (m || a)) | |
566 return; | |
567 | |
568 nw = XNEW (struct tailcall); | |
569 | |
570 nw->call_gsi = gsi; | |
571 | |
572 nw->tail_recursion = tail_recursion; | |
573 | |
574 nw->mult = m; | |
575 nw->add = a; | |
576 | |
577 nw->next = *ret; | |
578 *ret = nw; | |
579 } | |
580 | |
581 /* Helper to insert PHI_ARGH to the phi of VAR in the destination of edge E. */ | |
582 | |
583 static void | |
584 add_successor_phi_arg (edge e, tree var, tree phi_arg) | |
585 { | |
586 gimple_stmt_iterator gsi; | |
587 | |
588 for (gsi = gsi_start_phis (e->dest); !gsi_end_p (gsi); gsi_next (&gsi)) | |
589 if (PHI_RESULT (gsi_stmt (gsi)) == var) | |
590 break; | |
591 | |
592 gcc_assert (!gsi_end_p (gsi)); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
593 add_phi_arg (gsi_stmt (gsi), phi_arg, e, UNKNOWN_LOCATION); |
0 | 594 } |
595 | |
596 /* Creates a GIMPLE statement which computes the operation specified by | |
597 CODE, OP0 and OP1 to a new variable with name LABEL and inserts the | |
598 statement in the position specified by GSI and UPDATE. Returns the | |
599 tree node of the statement's result. */ | |
600 | |
601 static tree | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
602 adjust_return_value_with_ops (enum tree_code code, const char *label, |
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 tree acc, tree op1, gimple_stmt_iterator gsi) |
0 | 604 { |
605 | |
606 tree ret_type = TREE_TYPE (DECL_RESULT (current_function_decl)); | |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
607 tree tmp = create_tmp_reg (ret_type, label); |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
608 gimple stmt; |
0 | 609 tree result; |
610 | |
611 add_referenced_var (tmp); | |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
612 |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
613 if (types_compatible_p (TREE_TYPE (acc), TREE_TYPE (op1))) |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
614 stmt = gimple_build_assign_with_ops (code, tmp, acc, op1); |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
615 else |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
616 { |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
617 tree rhs = fold_convert (TREE_TYPE (acc), |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
618 fold_build2 (code, |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
619 TREE_TYPE (op1), |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
620 fold_convert (TREE_TYPE (op1), acc), |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
621 op1)); |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
622 rhs = force_gimple_operand_gsi (&gsi, rhs, |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
623 false, NULL, true, GSI_CONTINUE_LINKING); |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
624 stmt = gimple_build_assign (NULL_TREE, rhs); |
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 |
0 | 627 result = make_ssa_name (tmp, stmt); |
628 gimple_assign_set_lhs (stmt, result); | |
629 update_stmt (stmt); | |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
630 gsi_insert_before (&gsi, stmt, GSI_NEW_STMT); |
0 | 631 return result; |
632 } | |
633 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
634 /* Creates a new GIMPLE statement that adjusts the value of accumulator ACC by |
0 | 635 the computation specified by CODE and OP1 and insert the statement |
636 at the position specified by GSI as a new statement. Returns new SSA name | |
637 of updated accumulator. */ | |
638 | |
639 static tree | |
640 update_accumulator_with_ops (enum tree_code code, tree acc, tree op1, | |
641 gimple_stmt_iterator gsi) | |
642 { | |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
643 gimple stmt; |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
644 tree var; |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
645 if (types_compatible_p (TREE_TYPE (acc), TREE_TYPE (op1))) |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
646 stmt = gimple_build_assign_with_ops (code, SSA_NAME_VAR (acc), acc, op1); |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
647 else |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
648 { |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
649 tree rhs = fold_convert (TREE_TYPE (acc), |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
650 fold_build2 (code, |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
651 TREE_TYPE (op1), |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
652 fold_convert (TREE_TYPE (op1), acc), |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
653 op1)); |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
654 rhs = force_gimple_operand_gsi (&gsi, rhs, |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
655 false, NULL, false, GSI_CONTINUE_LINKING); |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
656 stmt = gimple_build_assign (NULL_TREE, rhs); |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
657 } |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
658 var = make_ssa_name (SSA_NAME_VAR (acc), stmt); |
0 | 659 gimple_assign_set_lhs (stmt, var); |
660 update_stmt (stmt); | |
661 gsi_insert_after (&gsi, stmt, GSI_NEW_STMT); | |
662 return var; | |
663 } | |
664 | |
665 /* Adjust the accumulator values according to A and M after GSI, and update | |
666 the phi nodes on edge BACK. */ | |
667 | |
668 static void | |
669 adjust_accumulator_values (gimple_stmt_iterator gsi, tree m, tree a, edge back) | |
670 { | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
671 tree var, a_acc_arg, m_acc_arg; |
0 | 672 |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
673 if (m) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
674 m = force_gimple_operand_gsi (&gsi, m, true, NULL, true, GSI_SAME_STMT); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
675 if (a) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
676 a = force_gimple_operand_gsi (&gsi, a, true, NULL, true, GSI_SAME_STMT); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
677 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
678 a_acc_arg = a_acc; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
679 m_acc_arg = m_acc; |
0 | 680 if (a) |
681 { | |
682 if (m_acc) | |
683 { | |
684 if (integer_onep (a)) | |
685 var = m_acc; | |
686 else | |
687 var = adjust_return_value_with_ops (MULT_EXPR, "acc_tmp", m_acc, | |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
688 a, gsi); |
0 | 689 } |
690 else | |
691 var = a; | |
692 | |
693 a_acc_arg = update_accumulator_with_ops (PLUS_EXPR, a_acc, var, gsi); | |
694 } | |
695 | |
696 if (m) | |
697 m_acc_arg = update_accumulator_with_ops (MULT_EXPR, m_acc, m, gsi); | |
698 | |
699 if (a_acc) | |
700 add_successor_phi_arg (back, a_acc, a_acc_arg); | |
701 | |
702 if (m_acc) | |
703 add_successor_phi_arg (back, m_acc, m_acc_arg); | |
704 } | |
705 | |
706 /* Adjust value of the return at the end of BB according to M and A | |
707 accumulators. */ | |
708 | |
709 static void | |
710 adjust_return_value (basic_block bb, tree m, tree a) | |
711 { | |
712 tree retval; | |
713 gimple ret_stmt = gimple_seq_last_stmt (bb_seq (bb)); | |
714 gimple_stmt_iterator gsi = gsi_last_bb (bb); | |
715 | |
716 gcc_assert (gimple_code (ret_stmt) == GIMPLE_RETURN); | |
717 | |
718 retval = gimple_return_retval (ret_stmt); | |
719 if (!retval || retval == error_mark_node) | |
720 return; | |
721 | |
722 if (m) | |
723 retval = adjust_return_value_with_ops (MULT_EXPR, "mul_tmp", m_acc, retval, | |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
724 gsi); |
0 | 725 if (a) |
726 retval = adjust_return_value_with_ops (PLUS_EXPR, "acc_tmp", a_acc, retval, | |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
727 gsi); |
0 | 728 gimple_return_set_retval (ret_stmt, retval); |
729 update_stmt (ret_stmt); | |
730 } | |
731 | |
732 /* Subtract COUNT and FREQUENCY from the basic block and it's | |
733 outgoing edge. */ | |
734 static void | |
735 decrease_profile (basic_block bb, gcov_type count, int frequency) | |
736 { | |
737 edge e; | |
738 bb->count -= count; | |
739 if (bb->count < 0) | |
740 bb->count = 0; | |
741 bb->frequency -= frequency; | |
742 if (bb->frequency < 0) | |
743 bb->frequency = 0; | |
744 if (!single_succ_p (bb)) | |
745 { | |
746 gcc_assert (!EDGE_COUNT (bb->succs)); | |
747 return; | |
748 } | |
749 e = single_succ_edge (bb); | |
750 e->count -= count; | |
751 if (e->count < 0) | |
752 e->count = 0; | |
753 } | |
754 | |
755 /* Returns true if argument PARAM of the tail recursive call needs to be copied | |
756 when the call is eliminated. */ | |
757 | |
758 static bool | |
759 arg_needs_copy_p (tree param) | |
760 { | |
761 tree def; | |
762 | |
763 if (!is_gimple_reg (param) || !var_ann (param)) | |
764 return false; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
765 |
0 | 766 /* Parameters that are only defined but never used need not be copied. */ |
767 def = gimple_default_def (cfun, param); | |
768 if (!def) | |
769 return false; | |
770 | |
771 return true; | |
772 } | |
773 | |
774 /* Eliminates tail call described by T. TMP_VARS is a list of | |
775 temporary variables used to copy the function arguments. */ | |
776 | |
777 static void | |
778 eliminate_tail_call (struct tailcall *t) | |
779 { | |
780 tree param, rslt; | |
781 gimple stmt, call; | |
782 tree arg; | |
783 size_t idx; | |
784 basic_block bb, first; | |
785 edge e; | |
786 gimple phi; | |
787 gimple_stmt_iterator gsi; | |
788 gimple orig_stmt; | |
789 | |
790 stmt = orig_stmt = gsi_stmt (t->call_gsi); | |
791 bb = gsi_bb (t->call_gsi); | |
792 | |
793 if (dump_file && (dump_flags & TDF_DETAILS)) | |
794 { | |
795 fprintf (dump_file, "Eliminated tail recursion in bb %d : ", | |
796 bb->index); | |
797 print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM); | |
798 fprintf (dump_file, "\n"); | |
799 } | |
800 | |
801 gcc_assert (is_gimple_call (stmt)); | |
802 | |
803 first = single_succ (ENTRY_BLOCK_PTR); | |
804 | |
805 /* Remove the code after call_gsi that will become unreachable. The | |
806 possibly unreachable code in other blocks is removed later in | |
807 cfg cleanup. */ | |
808 gsi = t->call_gsi; | |
809 gsi_next (&gsi); | |
810 while (!gsi_end_p (gsi)) | |
811 { | |
812 gimple t = gsi_stmt (gsi); | |
813 /* Do not remove the return statement, so that redirect_edge_and_branch | |
814 sees how the block ends. */ | |
815 if (gimple_code (t) == GIMPLE_RETURN) | |
816 break; | |
817 | |
818 gsi_remove (&gsi, true); | |
819 release_defs (t); | |
820 } | |
821 | |
822 /* Number of executions of function has reduced by the tailcall. */ | |
823 e = single_succ_edge (gsi_bb (t->call_gsi)); | |
824 decrease_profile (EXIT_BLOCK_PTR, e->count, EDGE_FREQUENCY (e)); | |
825 decrease_profile (ENTRY_BLOCK_PTR, e->count, EDGE_FREQUENCY (e)); | |
826 if (e->dest != EXIT_BLOCK_PTR) | |
827 decrease_profile (e->dest, e->count, EDGE_FREQUENCY (e)); | |
828 | |
829 /* Replace the call by a jump to the start of function. */ | |
830 e = redirect_edge_and_branch (single_succ_edge (gsi_bb (t->call_gsi)), | |
831 first); | |
832 gcc_assert (e); | |
833 PENDING_STMT (e) = NULL; | |
834 | |
835 /* Add phi node entries for arguments. The ordering of the phi nodes should | |
836 be the same as the ordering of the arguments. */ | |
837 for (param = DECL_ARGUMENTS (current_function_decl), | |
838 idx = 0, gsi = gsi_start_phis (first); | |
839 param; | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
840 param = DECL_CHAIN (param), idx++) |
0 | 841 { |
842 if (!arg_needs_copy_p (param)) | |
843 continue; | |
844 | |
845 arg = gimple_call_arg (stmt, idx); | |
846 phi = gsi_stmt (gsi); | |
847 gcc_assert (param == SSA_NAME_VAR (PHI_RESULT (phi))); | |
848 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
849 add_phi_arg (phi, arg, e, gimple_location (stmt)); |
0 | 850 gsi_next (&gsi); |
851 } | |
852 | |
853 /* Update the values of accumulators. */ | |
854 adjust_accumulator_values (t->call_gsi, t->mult, t->add, e); | |
855 | |
856 call = gsi_stmt (t->call_gsi); | |
857 rslt = gimple_call_lhs (call); | |
858 if (rslt != NULL_TREE) | |
859 { | |
860 /* Result of the call will no longer be defined. So adjust the | |
861 SSA_NAME_DEF_STMT accordingly. */ | |
862 SSA_NAME_DEF_STMT (rslt) = gimple_build_nop (); | |
863 } | |
864 | |
865 gsi_remove (&t->call_gsi, true); | |
866 release_defs (call); | |
867 } | |
868 | |
869 /* Add phi nodes for the virtual operands defined in the function to the | |
870 header of the loop created by tail recursion elimination. | |
871 | |
872 Originally, we used to add phi nodes only for call clobbered variables, | |
873 as the value of the non-call clobbered ones obviously cannot be used | |
874 or changed within the recursive call. However, the local variables | |
875 from multiple calls now share the same location, so the virtual ssa form | |
876 requires us to say that the location dies on further iterations of the loop, | |
877 which requires adding phi nodes. | |
878 */ | |
879 static void | |
880 add_virtual_phis (void) | |
881 { | |
882 referenced_var_iterator rvi; | |
883 tree var; | |
884 | |
885 /* The problematic part is that there is no way how to know what | |
886 to put into phi nodes (there in fact does not have to be such | |
887 ssa name available). A solution would be to have an artificial | |
888 use/kill for all virtual operands in EXIT node. Unless we have | |
889 this, we cannot do much better than to rebuild the ssa form for | |
890 possibly affected virtual ssa names from scratch. */ | |
891 | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
892 FOR_EACH_REFERENCED_VAR (cfun, var, rvi) |
0 | 893 { |
894 if (!is_gimple_reg (var) && gimple_default_def (cfun, var) != NULL_TREE) | |
895 mark_sym_for_renaming (var); | |
896 } | |
897 } | |
898 | |
899 /* Optimizes the tailcall described by T. If OPT_TAILCALLS is true, also | |
900 mark the tailcalls for the sibcall optimization. */ | |
901 | |
902 static bool | |
903 optimize_tail_call (struct tailcall *t, bool opt_tailcalls) | |
904 { | |
905 if (t->tail_recursion) | |
906 { | |
907 eliminate_tail_call (t); | |
908 return true; | |
909 } | |
910 | |
911 if (opt_tailcalls) | |
912 { | |
913 gimple stmt = gsi_stmt (t->call_gsi); | |
914 | |
915 gimple_call_set_tail (stmt, true); | |
916 if (dump_file && (dump_flags & TDF_DETAILS)) | |
917 { | |
918 fprintf (dump_file, "Found tail call "); | |
919 print_gimple_stmt (dump_file, stmt, 0, dump_flags); | |
920 fprintf (dump_file, " in bb %i\n", (gsi_bb (t->call_gsi))->index); | |
921 } | |
922 } | |
923 | |
924 return false; | |
925 } | |
926 | |
927 /* Creates a tail-call accumulator of the same type as the return type of the | |
928 current function. LABEL is the name used to creating the temporary | |
929 variable for the accumulator. The accumulator will be inserted in the | |
930 phis of a basic block BB with single predecessor with an initial value | |
931 INIT converted to the current function return type. */ | |
932 | |
933 static tree | |
934 create_tailcall_accumulator (const char *label, basic_block bb, tree init) | |
935 { | |
936 tree ret_type = TREE_TYPE (DECL_RESULT (current_function_decl)); | |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
937 tree tmp = create_tmp_reg (ret_type, label); |
0 | 938 gimple phi; |
939 | |
940 add_referenced_var (tmp); | |
941 phi = create_phi_node (tmp, bb); | |
942 /* RET_TYPE can be a float when -ffast-maths is enabled. */ | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
943 add_phi_arg (phi, fold_convert (ret_type, init), single_pred_edge (bb), |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
944 UNKNOWN_LOCATION); |
0 | 945 return PHI_RESULT (phi); |
946 } | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
947 |
0 | 948 /* Optimizes tail calls in the function, turning the tail recursion |
949 into iteration. */ | |
950 | |
951 static unsigned int | |
952 tree_optimize_tail_calls_1 (bool opt_tailcalls) | |
953 { | |
954 edge e; | |
955 bool phis_constructed = false; | |
956 struct tailcall *tailcalls = NULL, *act, *next; | |
957 bool changed = false; | |
958 basic_block first = single_succ (ENTRY_BLOCK_PTR); | |
959 tree param; | |
960 gimple stmt; | |
961 edge_iterator ei; | |
962 | |
963 if (!suitable_for_tail_opt_p ()) | |
964 return 0; | |
965 if (opt_tailcalls) | |
966 opt_tailcalls = suitable_for_tail_call_opt_p (); | |
967 | |
968 FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds) | |
969 { | |
970 /* Only traverse the normal exits, i.e. those that end with return | |
971 statement. */ | |
972 stmt = last_stmt (e->src); | |
973 | |
974 if (stmt | |
975 && gimple_code (stmt) == GIMPLE_RETURN) | |
976 find_tail_calls (e->src, &tailcalls); | |
977 } | |
978 | |
979 /* Construct the phi nodes and accumulators if necessary. */ | |
980 a_acc = m_acc = NULL_TREE; | |
981 for (act = tailcalls; act; act = act->next) | |
982 { | |
983 if (!act->tail_recursion) | |
984 continue; | |
985 | |
986 if (!phis_constructed) | |
987 { | |
47
3bfb6c00c1e0
update it from 4.4.2 to 4.4.3.
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
988 /* Ensure that there is only one predecessor of the block |
3bfb6c00c1e0
update it from 4.4.2 to 4.4.3.
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
989 or if there are existing degenerate PHI nodes. */ |
3bfb6c00c1e0
update it from 4.4.2 to 4.4.3.
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
990 if (!single_pred_p (first) |
3bfb6c00c1e0
update it from 4.4.2 to 4.4.3.
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
19
diff
changeset
|
991 || !gimple_seq_empty_p (phi_nodes (first))) |
0 | 992 first = split_edge (single_succ_edge (ENTRY_BLOCK_PTR)); |
993 | |
994 /* Copy the args if needed. */ | |
995 for (param = DECL_ARGUMENTS (current_function_decl); | |
996 param; | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
997 param = DECL_CHAIN (param)) |
0 | 998 if (arg_needs_copy_p (param)) |
999 { | |
1000 tree name = gimple_default_def (cfun, param); | |
1001 tree new_name = make_ssa_name (param, SSA_NAME_DEF_STMT (name)); | |
1002 gimple phi; | |
1003 | |
1004 set_default_def (param, new_name); | |
1005 phi = create_phi_node (name, first); | |
1006 SSA_NAME_DEF_STMT (name) = phi; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1007 add_phi_arg (phi, new_name, single_pred_edge (first), |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1008 EXPR_LOCATION (param)); |
0 | 1009 } |
1010 phis_constructed = true; | |
1011 } | |
1012 | |
1013 if (act->add && !a_acc) | |
1014 a_acc = create_tailcall_accumulator ("add_acc", first, | |
1015 integer_zero_node); | |
1016 | |
1017 if (act->mult && !m_acc) | |
1018 m_acc = create_tailcall_accumulator ("mult_acc", first, | |
1019 integer_one_node); | |
1020 } | |
1021 | |
1022 for (; tailcalls; tailcalls = next) | |
1023 { | |
1024 next = tailcalls->next; | |
1025 changed |= optimize_tail_call (tailcalls, opt_tailcalls); | |
1026 free (tailcalls); | |
1027 } | |
1028 | |
1029 if (a_acc || m_acc) | |
1030 { | |
1031 /* Modify the remaining return statements. */ | |
1032 FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds) | |
1033 { | |
1034 stmt = last_stmt (e->src); | |
1035 | |
1036 if (stmt | |
1037 && gimple_code (stmt) == GIMPLE_RETURN) | |
1038 adjust_return_value (e->src, m_acc, a_acc); | |
1039 } | |
1040 } | |
1041 | |
1042 if (changed) | |
1043 free_dominance_info (CDI_DOMINATORS); | |
1044 | |
1045 if (phis_constructed) | |
1046 add_virtual_phis (); | |
1047 if (changed) | |
1048 return TODO_cleanup_cfg | TODO_update_ssa_only_virtuals; | |
1049 return 0; | |
1050 } | |
1051 | |
1052 static unsigned int | |
1053 execute_tail_recursion (void) | |
1054 { | |
1055 return tree_optimize_tail_calls_1 (false); | |
1056 } | |
1057 | |
1058 static bool | |
1059 gate_tail_calls (void) | |
1060 { | |
1061 return flag_optimize_sibling_calls != 0 && dbg_cnt (tail_call); | |
1062 } | |
1063 | |
1064 static unsigned int | |
1065 execute_tail_calls (void) | |
1066 { | |
1067 return tree_optimize_tail_calls_1 (true); | |
1068 } | |
1069 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1070 struct gimple_opt_pass pass_tail_recursion = |
0 | 1071 { |
1072 { | |
1073 GIMPLE_PASS, | |
1074 "tailr", /* name */ | |
1075 gate_tail_calls, /* gate */ | |
1076 execute_tail_recursion, /* execute */ | |
1077 NULL, /* sub */ | |
1078 NULL, /* next */ | |
1079 0, /* static_pass_number */ | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1080 TV_NONE, /* tv_id */ |
0 | 1081 PROP_cfg | PROP_ssa, /* properties_required */ |
1082 0, /* properties_provided */ | |
1083 0, /* properties_destroyed */ | |
1084 0, /* todo_flags_start */ | |
1085 TODO_dump_func | TODO_verify_ssa /* todo_flags_finish */ | |
1086 } | |
1087 }; | |
1088 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1089 struct gimple_opt_pass pass_tail_calls = |
0 | 1090 { |
1091 { | |
1092 GIMPLE_PASS, | |
1093 "tailc", /* name */ | |
1094 gate_tail_calls, /* gate */ | |
1095 execute_tail_calls, /* execute */ | |
1096 NULL, /* sub */ | |
1097 NULL, /* next */ | |
1098 0, /* static_pass_number */ | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1099 TV_NONE, /* tv_id */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
47
diff
changeset
|
1100 PROP_cfg | PROP_ssa, /* properties_required */ |
0 | 1101 0, /* properties_provided */ |
1102 0, /* properties_destroyed */ | |
1103 0, /* todo_flags_start */ | |
1104 TODO_dump_func | TODO_verify_ssa /* todo_flags_finish */ | |
1105 } | |
1106 }; |