|
0
|
1 /* Pass computing data for optimizing stdarg functions.
|
|
|
2 Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
|
|
|
3 Contributed by Jakub Jelinek <jakub@redhat.com>
|
|
|
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 "function.h"
|
|
|
27 #include "langhooks.h"
|
|
|
28 #include "diagnostic.h"
|
|
|
29 #include "target.h"
|
|
|
30 #include "tree-flow.h"
|
|
|
31 #include "tree-pass.h"
|
|
|
32 #include "tree-stdarg.h"
|
|
|
33
|
|
|
34 /* A simple pass that attempts to optimize stdarg functions on architectures
|
|
|
35 that need to save register arguments to stack on entry to stdarg functions.
|
|
|
36 If the function doesn't use any va_start macros, no registers need to
|
|
|
37 be saved. If va_start macros are used, the va_list variables don't escape
|
|
|
38 the function, it is only necessary to save registers that will be used
|
|
|
39 in va_arg macros. E.g. if va_arg is only used with integral types
|
|
|
40 in the function, floating point registers don't need to be saved, etc. */
|
|
|
41
|
|
|
42
|
|
|
43 /* Return true if basic block VA_ARG_BB is dominated by VA_START_BB and
|
|
|
44 is executed at most as many times as VA_START_BB. */
|
|
|
45
|
|
|
46 static bool
|
|
|
47 reachable_at_most_once (basic_block va_arg_bb, basic_block va_start_bb)
|
|
|
48 {
|
|
|
49 VEC (edge, heap) *stack = NULL;
|
|
|
50 edge e;
|
|
|
51 edge_iterator ei;
|
|
|
52 sbitmap visited;
|
|
|
53 bool ret;
|
|
|
54
|
|
|
55 if (va_arg_bb == va_start_bb)
|
|
|
56 return true;
|
|
|
57
|
|
|
58 if (! dominated_by_p (CDI_DOMINATORS, va_arg_bb, va_start_bb))
|
|
|
59 return false;
|
|
|
60
|
|
|
61 visited = sbitmap_alloc (last_basic_block);
|
|
|
62 sbitmap_zero (visited);
|
|
|
63 ret = true;
|
|
|
64
|
|
|
65 FOR_EACH_EDGE (e, ei, va_arg_bb->preds)
|
|
|
66 VEC_safe_push (edge, heap, stack, e);
|
|
|
67
|
|
|
68 while (! VEC_empty (edge, stack))
|
|
|
69 {
|
|
|
70 basic_block src;
|
|
|
71
|
|
|
72 e = VEC_pop (edge, stack);
|
|
|
73 src = e->src;
|
|
|
74
|
|
|
75 if (e->flags & EDGE_COMPLEX)
|
|
|
76 {
|
|
|
77 ret = false;
|
|
|
78 break;
|
|
|
79 }
|
|
|
80
|
|
|
81 if (src == va_start_bb)
|
|
|
82 continue;
|
|
|
83
|
|
|
84 /* va_arg_bb can be executed more times than va_start_bb. */
|
|
|
85 if (src == va_arg_bb)
|
|
|
86 {
|
|
|
87 ret = false;
|
|
|
88 break;
|
|
|
89 }
|
|
|
90
|
|
|
91 gcc_assert (src != ENTRY_BLOCK_PTR);
|
|
|
92
|
|
|
93 if (! TEST_BIT (visited, src->index))
|
|
|
94 {
|
|
|
95 SET_BIT (visited, src->index);
|
|
|
96 FOR_EACH_EDGE (e, ei, src->preds)
|
|
|
97 VEC_safe_push (edge, heap, stack, e);
|
|
|
98 }
|
|
|
99 }
|
|
|
100
|
|
|
101 VEC_free (edge, heap, stack);
|
|
|
102 sbitmap_free (visited);
|
|
|
103 return ret;
|
|
|
104 }
|
|
|
105
|
|
|
106
|
|
|
107 /* For statement COUNTER = RHS, if RHS is COUNTER + constant,
|
|
|
108 return constant, otherwise return (unsigned HOST_WIDE_INT) -1.
|
|
|
109 GPR_P is true if this is GPR counter. */
|
|
|
110
|
|
|
111 static unsigned HOST_WIDE_INT
|
|
|
112 va_list_counter_bump (struct stdarg_info *si, tree counter, tree rhs,
|
|
|
113 bool gpr_p)
|
|
|
114 {
|
|
|
115 tree lhs, orig_lhs;
|
|
|
116 gimple stmt;
|
|
|
117 unsigned HOST_WIDE_INT ret = 0, val, counter_val;
|
|
|
118 unsigned int max_size;
|
|
|
119
|
|
|
120 if (si->offsets == NULL)
|
|
|
121 {
|
|
|
122 unsigned int i;
|
|
|
123
|
|
|
124 si->offsets = XNEWVEC (int, num_ssa_names);
|
|
|
125 for (i = 0; i < num_ssa_names; ++i)
|
|
|
126 si->offsets[i] = -1;
|
|
|
127 }
|
|
|
128
|
|
|
129 counter_val = gpr_p ? cfun->va_list_gpr_size : cfun->va_list_fpr_size;
|
|
|
130 max_size = gpr_p ? VA_LIST_MAX_GPR_SIZE : VA_LIST_MAX_FPR_SIZE;
|
|
|
131 orig_lhs = lhs = rhs;
|
|
|
132 while (lhs)
|
|
|
133 {
|
|
|
134 enum tree_code rhs_code;
|
|
|
135
|
|
|
136 if (si->offsets[SSA_NAME_VERSION (lhs)] != -1)
|
|
|
137 {
|
|
|
138 if (counter_val >= max_size)
|
|
|
139 {
|
|
|
140 ret = max_size;
|
|
|
141 break;
|
|
|
142 }
|
|
|
143
|
|
|
144 ret -= counter_val - si->offsets[SSA_NAME_VERSION (lhs)];
|
|
|
145 break;
|
|
|
146 }
|
|
|
147
|
|
|
148 stmt = SSA_NAME_DEF_STMT (lhs);
|
|
|
149
|
|
|
150 if (!is_gimple_assign (stmt) || gimple_assign_lhs (stmt) != lhs)
|
|
|
151 return (unsigned HOST_WIDE_INT) -1;
|
|
|
152
|
|
|
153 rhs_code = gimple_assign_rhs_code (stmt);
|
|
|
154 if ((get_gimple_rhs_class (rhs_code) == GIMPLE_SINGLE_RHS
|
|
|
155 || gimple_assign_cast_p (stmt))
|
|
|
156 && TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME)
|
|
|
157 {
|
|
|
158 lhs = gimple_assign_rhs1 (stmt);
|
|
|
159 continue;
|
|
|
160 }
|
|
|
161
|
|
|
162 if ((rhs_code == POINTER_PLUS_EXPR
|
|
|
163 || rhs_code == PLUS_EXPR)
|
|
|
164 && TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME
|
|
|
165 && host_integerp (gimple_assign_rhs2 (stmt), 1))
|
|
|
166 {
|
|
|
167 ret += tree_low_cst (gimple_assign_rhs2 (stmt), 1);
|
|
|
168 lhs = gimple_assign_rhs1 (stmt);
|
|
|
169 continue;
|
|
|
170 }
|
|
|
171
|
|
|
172 if (get_gimple_rhs_class (rhs_code) != GIMPLE_SINGLE_RHS)
|
|
|
173 return (unsigned HOST_WIDE_INT) -1;
|
|
|
174
|
|
|
175 rhs = gimple_assign_rhs1 (stmt);
|
|
|
176 if (TREE_CODE (counter) != TREE_CODE (rhs))
|
|
|
177 return (unsigned HOST_WIDE_INT) -1;
|
|
|
178
|
|
|
179 if (TREE_CODE (counter) == COMPONENT_REF)
|
|
|
180 {
|
|
|
181 if (get_base_address (counter) != get_base_address (rhs)
|
|
|
182 || TREE_CODE (TREE_OPERAND (rhs, 1)) != FIELD_DECL
|
|
|
183 || TREE_OPERAND (counter, 1) != TREE_OPERAND (rhs, 1))
|
|
|
184 return (unsigned HOST_WIDE_INT) -1;
|
|
|
185 }
|
|
|
186 else if (counter != rhs)
|
|
|
187 return (unsigned HOST_WIDE_INT) -1;
|
|
|
188
|
|
|
189 lhs = NULL;
|
|
|
190 }
|
|
|
191
|
|
|
192 lhs = orig_lhs;
|
|
|
193 val = ret + counter_val;
|
|
|
194 while (lhs)
|
|
|
195 {
|
|
|
196 enum tree_code rhs_code;
|
|
|
197
|
|
|
198 if (si->offsets[SSA_NAME_VERSION (lhs)] != -1)
|
|
|
199 break;
|
|
|
200
|
|
|
201 if (val >= max_size)
|
|
|
202 si->offsets[SSA_NAME_VERSION (lhs)] = max_size;
|
|
|
203 else
|
|
|
204 si->offsets[SSA_NAME_VERSION (lhs)] = val;
|
|
|
205
|
|
|
206 stmt = SSA_NAME_DEF_STMT (lhs);
|
|
|
207
|
|
|
208 rhs_code = gimple_assign_rhs_code (stmt);
|
|
|
209 if ((get_gimple_rhs_class (rhs_code) == GIMPLE_SINGLE_RHS
|
|
|
210 || gimple_assign_cast_p (stmt))
|
|
|
211 && TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME)
|
|
|
212 {
|
|
|
213 lhs = gimple_assign_rhs1 (stmt);
|
|
|
214 continue;
|
|
|
215 }
|
|
|
216
|
|
|
217 if ((rhs_code == POINTER_PLUS_EXPR
|
|
|
218 || rhs_code == PLUS_EXPR)
|
|
|
219 && TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME
|
|
|
220 && host_integerp (gimple_assign_rhs2 (stmt), 1))
|
|
|
221 {
|
|
|
222 val -= tree_low_cst (gimple_assign_rhs2 (stmt), 1);
|
|
|
223 lhs = gimple_assign_rhs1 (stmt);
|
|
|
224 continue;
|
|
|
225 }
|
|
|
226
|
|
|
227 lhs = NULL;
|
|
|
228 }
|
|
|
229
|
|
|
230 return ret;
|
|
|
231 }
|
|
|
232
|
|
|
233
|
|
|
234 /* Called by walk_tree to look for references to va_list variables. */
|
|
|
235
|
|
|
236 static tree
|
|
|
237 find_va_list_reference (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
|
|
|
238 void *data)
|
|
|
239 {
|
|
|
240 bitmap va_list_vars = (bitmap) ((struct walk_stmt_info *) data)->info;
|
|
|
241 tree var = *tp;
|
|
|
242
|
|
|
243 if (TREE_CODE (var) == SSA_NAME)
|
|
|
244 var = SSA_NAME_VAR (var);
|
|
|
245
|
|
|
246 if (TREE_CODE (var) == VAR_DECL
|
|
|
247 && bitmap_bit_p (va_list_vars, DECL_UID (var)))
|
|
|
248 return var;
|
|
|
249
|
|
|
250 return NULL_TREE;
|
|
|
251 }
|
|
|
252
|
|
|
253
|
|
|
254 /* Helper function of va_list_counter_struct_op. Compute
|
|
|
255 cfun->va_list_{g,f}pr_size. AP is a va_list GPR/FPR counter,
|
|
|
256 if WRITE_P is true, seen in AP = VAR, otherwise seen in VAR = AP
|
|
|
257 statement. GPR_P is true if AP is a GPR counter, false if it is
|
|
|
258 a FPR counter. */
|
|
|
259
|
|
|
260 static void
|
|
|
261 va_list_counter_op (struct stdarg_info *si, tree ap, tree var, bool gpr_p,
|
|
|
262 bool write_p)
|
|
|
263 {
|
|
|
264 unsigned HOST_WIDE_INT increment;
|
|
|
265
|
|
|
266 if (si->compute_sizes < 0)
|
|
|
267 {
|
|
|
268 si->compute_sizes = 0;
|
|
|
269 if (si->va_start_count == 1
|
|
|
270 && reachable_at_most_once (si->bb, si->va_start_bb))
|
|
|
271 si->compute_sizes = 1;
|
|
|
272
|
|
|
273 if (dump_file && (dump_flags & TDF_DETAILS))
|
|
|
274 fprintf (dump_file,
|
|
|
275 "bb%d will %sbe executed at most once for each va_start "
|
|
|
276 "in bb%d\n", si->bb->index, si->compute_sizes ? "" : "not ",
|
|
|
277 si->va_start_bb->index);
|
|
|
278 }
|
|
|
279
|
|
|
280 if (write_p
|
|
|
281 && si->compute_sizes
|
|
|
282 && (increment = va_list_counter_bump (si, ap, var, gpr_p)) + 1 > 1)
|
|
|
283 {
|
|
|
284 if (gpr_p && cfun->va_list_gpr_size + increment < VA_LIST_MAX_GPR_SIZE)
|
|
|
285 {
|
|
|
286 cfun->va_list_gpr_size += increment;
|
|
|
287 return;
|
|
|
288 }
|
|
|
289
|
|
|
290 if (!gpr_p && cfun->va_list_fpr_size + increment < VA_LIST_MAX_FPR_SIZE)
|
|
|
291 {
|
|
|
292 cfun->va_list_fpr_size += increment;
|
|
|
293 return;
|
|
|
294 }
|
|
|
295 }
|
|
|
296
|
|
|
297 if (write_p || !si->compute_sizes)
|
|
|
298 {
|
|
|
299 if (gpr_p)
|
|
|
300 cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
|
|
|
301 else
|
|
|
302 cfun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;
|
|
|
303 }
|
|
|
304 }
|
|
|
305
|
|
|
306
|
|
|
307 /* If AP is a va_list GPR/FPR counter, compute cfun->va_list_{g,f}pr_size.
|
|
|
308 If WRITE_P is true, AP has been seen in AP = VAR assignment, if WRITE_P
|
|
|
309 is false, AP has been seen in VAR = AP assignment.
|
|
|
310 Return true if the AP = VAR (resp. VAR = AP) statement is a recognized
|
|
|
311 va_arg operation that doesn't cause the va_list variable to escape
|
|
|
312 current function. */
|
|
|
313
|
|
|
314 static bool
|
|
|
315 va_list_counter_struct_op (struct stdarg_info *si, tree ap, tree var,
|
|
|
316 bool write_p)
|
|
|
317 {
|
|
|
318 tree base;
|
|
|
319
|
|
|
320 if (TREE_CODE (ap) != COMPONENT_REF
|
|
|
321 || TREE_CODE (TREE_OPERAND (ap, 1)) != FIELD_DECL)
|
|
|
322 return false;
|
|
|
323
|
|
|
324 if (TREE_CODE (var) != SSA_NAME
|
|
|
325 || bitmap_bit_p (si->va_list_vars, DECL_UID (SSA_NAME_VAR (var))))
|
|
|
326 return false;
|
|
|
327
|
|
|
328 base = get_base_address (ap);
|
|
|
329 if (TREE_CODE (base) != VAR_DECL
|
|
|
330 || !bitmap_bit_p (si->va_list_vars, DECL_UID (base)))
|
|
|
331 return false;
|
|
|
332
|
|
|
333 if (TREE_OPERAND (ap, 1) == va_list_gpr_counter_field)
|
|
|
334 va_list_counter_op (si, ap, var, true, write_p);
|
|
|
335 else if (TREE_OPERAND (ap, 1) == va_list_fpr_counter_field)
|
|
|
336 va_list_counter_op (si, ap, var, false, write_p);
|
|
|
337
|
|
|
338 return true;
|
|
|
339 }
|
|
|
340
|
|
|
341
|
|
|
342 /* Check for TEM = AP. Return true if found and the caller shouldn't
|
|
|
343 search for va_list references in the statement. */
|
|
|
344
|
|
|
345 static bool
|
|
|
346 va_list_ptr_read (struct stdarg_info *si, tree ap, tree tem)
|
|
|
347 {
|
|
|
348 if (TREE_CODE (ap) != VAR_DECL
|
|
|
349 || !bitmap_bit_p (si->va_list_vars, DECL_UID (ap)))
|
|
|
350 return false;
|
|
|
351
|
|
|
352 if (TREE_CODE (tem) != SSA_NAME
|
|
|
353 || bitmap_bit_p (si->va_list_vars,
|
|
|
354 DECL_UID (SSA_NAME_VAR (tem)))
|
|
|
355 || is_global_var (SSA_NAME_VAR (tem)))
|
|
|
356 return false;
|
|
|
357
|
|
|
358 if (si->compute_sizes < 0)
|
|
|
359 {
|
|
|
360 si->compute_sizes = 0;
|
|
|
361 if (si->va_start_count == 1
|
|
|
362 && reachable_at_most_once (si->bb, si->va_start_bb))
|
|
|
363 si->compute_sizes = 1;
|
|
|
364
|
|
|
365 if (dump_file && (dump_flags & TDF_DETAILS))
|
|
|
366 fprintf (dump_file,
|
|
|
367 "bb%d will %sbe executed at most once for each va_start "
|
|
|
368 "in bb%d\n", si->bb->index, si->compute_sizes ? "" : "not ",
|
|
|
369 si->va_start_bb->index);
|
|
|
370 }
|
|
|
371
|
|
|
372 /* For void * or char * va_list types, there is just one counter.
|
|
|
373 If va_arg is used in a loop, we don't know how many registers need
|
|
|
374 saving. */
|
|
|
375 if (! si->compute_sizes)
|
|
|
376 return false;
|
|
|
377
|
|
|
378 if (va_list_counter_bump (si, ap, tem, true) == (unsigned HOST_WIDE_INT) -1)
|
|
|
379 return false;
|
|
|
380
|
|
|
381 /* Note the temporary, as we need to track whether it doesn't escape
|
|
|
382 the current function. */
|
|
|
383 bitmap_set_bit (si->va_list_escape_vars,
|
|
|
384 DECL_UID (SSA_NAME_VAR (tem)));
|
|
|
385 return true;
|
|
|
386 }
|
|
|
387
|
|
|
388
|
|
|
389 /* Check for:
|
|
|
390 tem1 = AP;
|
|
|
391 TEM2 = tem1 + CST;
|
|
|
392 AP = TEM2;
|
|
|
393 sequence and update cfun->va_list_gpr_size. Return true if found. */
|
|
|
394
|
|
|
395 static bool
|
|
|
396 va_list_ptr_write (struct stdarg_info *si, tree ap, tree tem2)
|
|
|
397 {
|
|
|
398 unsigned HOST_WIDE_INT increment;
|
|
|
399
|
|
|
400 if (TREE_CODE (ap) != VAR_DECL
|
|
|
401 || !bitmap_bit_p (si->va_list_vars, DECL_UID (ap)))
|
|
|
402 return false;
|
|
|
403
|
|
|
404 if (TREE_CODE (tem2) != SSA_NAME
|
|
|
405 || bitmap_bit_p (si->va_list_vars, DECL_UID (SSA_NAME_VAR (tem2))))
|
|
|
406 return false;
|
|
|
407
|
|
|
408 if (si->compute_sizes <= 0)
|
|
|
409 return false;
|
|
|
410
|
|
|
411 increment = va_list_counter_bump (si, ap, tem2, true);
|
|
|
412 if (increment + 1 <= 1)
|
|
|
413 return false;
|
|
|
414
|
|
|
415 if (cfun->va_list_gpr_size + increment < VA_LIST_MAX_GPR_SIZE)
|
|
|
416 cfun->va_list_gpr_size += increment;
|
|
|
417 else
|
|
|
418 cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
|
|
|
419
|
|
|
420 return true;
|
|
|
421 }
|
|
|
422
|
|
|
423
|
|
|
424 /* If RHS is X, (some type *) X or X + CST for X a temporary variable
|
|
|
425 containing value of some va_list variable plus optionally some constant,
|
|
|
426 either set si->va_list_escapes or add LHS to si->va_list_escape_vars,
|
|
|
427 depending whether LHS is a function local temporary. */
|
|
|
428
|
|
|
429 static void
|
|
|
430 check_va_list_escapes (struct stdarg_info *si, tree lhs, tree rhs)
|
|
|
431 {
|
|
|
432 if (! POINTER_TYPE_P (TREE_TYPE (rhs)))
|
|
|
433 return;
|
|
|
434
|
|
|
435 if (TREE_CODE (rhs) != SSA_NAME
|
|
|
436 || ! bitmap_bit_p (si->va_list_escape_vars,
|
|
|
437 DECL_UID (SSA_NAME_VAR (rhs))))
|
|
|
438 return;
|
|
|
439
|
|
|
440 if (TREE_CODE (lhs) != SSA_NAME || is_global_var (SSA_NAME_VAR (lhs)))
|
|
|
441 {
|
|
|
442 si->va_list_escapes = true;
|
|
|
443 return;
|
|
|
444 }
|
|
|
445
|
|
|
446 if (si->compute_sizes < 0)
|
|
|
447 {
|
|
|
448 si->compute_sizes = 0;
|
|
|
449 if (si->va_start_count == 1
|
|
|
450 && reachable_at_most_once (si->bb, si->va_start_bb))
|
|
|
451 si->compute_sizes = 1;
|
|
|
452
|
|
|
453 if (dump_file && (dump_flags & TDF_DETAILS))
|
|
|
454 fprintf (dump_file,
|
|
|
455 "bb%d will %sbe executed at most once for each va_start "
|
|
|
456 "in bb%d\n", si->bb->index, si->compute_sizes ? "" : "not ",
|
|
|
457 si->va_start_bb->index);
|
|
|
458 }
|
|
|
459
|
|
|
460 /* For void * or char * va_list types, there is just one counter.
|
|
|
461 If va_arg is used in a loop, we don't know how many registers need
|
|
|
462 saving. */
|
|
|
463 if (! si->compute_sizes)
|
|
|
464 {
|
|
|
465 si->va_list_escapes = true;
|
|
|
466 return;
|
|
|
467 }
|
|
|
468
|
|
|
469 if (va_list_counter_bump (si, si->va_start_ap, lhs, true)
|
|
|
470 == (unsigned HOST_WIDE_INT) -1)
|
|
|
471 {
|
|
|
472 si->va_list_escapes = true;
|
|
|
473 return;
|
|
|
474 }
|
|
|
475
|
|
|
476 bitmap_set_bit (si->va_list_escape_vars,
|
|
|
477 DECL_UID (SSA_NAME_VAR (lhs)));
|
|
|
478 }
|
|
|
479
|
|
|
480
|
|
|
481 /* Check all uses of temporaries from si->va_list_escape_vars bitmap.
|
|
|
482 Return true if va_list might be escaping. */
|
|
|
483
|
|
|
484 static bool
|
|
|
485 check_all_va_list_escapes (struct stdarg_info *si)
|
|
|
486 {
|
|
|
487 basic_block bb;
|
|
|
488
|
|
|
489 FOR_EACH_BB (bb)
|
|
|
490 {
|
|
|
491 gimple_stmt_iterator i;
|
|
|
492
|
|
|
493 for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
|
|
|
494 {
|
|
|
495 gimple stmt = gsi_stmt (i);
|
|
|
496 tree use;
|
|
|
497 ssa_op_iter iter;
|
|
|
498
|
|
|
499 FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_ALL_USES)
|
|
|
500 {
|
|
|
501 if (! bitmap_bit_p (si->va_list_escape_vars,
|
|
|
502 DECL_UID (SSA_NAME_VAR (use))))
|
|
|
503 continue;
|
|
|
504
|
|
|
505 if (is_gimple_assign (stmt))
|
|
|
506 {
|
|
|
507 tree rhs = gimple_assign_rhs1 (stmt);
|
|
|
508 enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
|
|
|
509
|
|
|
510 /* x = *ap_temp; */
|
|
|
511 if (gimple_assign_rhs_code (stmt) == INDIRECT_REF
|
|
|
512 && TREE_OPERAND (rhs, 0) == use
|
|
|
513 && TYPE_SIZE_UNIT (TREE_TYPE (rhs))
|
|
|
514 && host_integerp (TYPE_SIZE_UNIT (TREE_TYPE (rhs)), 1)
|
|
|
515 && si->offsets[SSA_NAME_VERSION (use)] != -1)
|
|
|
516 {
|
|
|
517 unsigned HOST_WIDE_INT gpr_size;
|
|
|
518 tree access_size = TYPE_SIZE_UNIT (TREE_TYPE (rhs));
|
|
|
519
|
|
|
520 gpr_size = si->offsets[SSA_NAME_VERSION (use)]
|
|
|
521 + tree_low_cst (access_size, 1);
|
|
|
522 if (gpr_size >= VA_LIST_MAX_GPR_SIZE)
|
|
|
523 cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
|
|
|
524 else if (gpr_size > cfun->va_list_gpr_size)
|
|
|
525 cfun->va_list_gpr_size = gpr_size;
|
|
|
526 continue;
|
|
|
527 }
|
|
|
528
|
|
|
529 /* va_arg sequences may contain
|
|
|
530 other_ap_temp = ap_temp;
|
|
|
531 other_ap_temp = ap_temp + constant;
|
|
|
532 other_ap_temp = (some_type *) ap_temp;
|
|
|
533 ap = ap_temp;
|
|
|
534 statements. */
|
|
|
535 if (rhs == use
|
|
|
536 && ((rhs_code == POINTER_PLUS_EXPR
|
|
|
537 && (TREE_CODE (gimple_assign_rhs2 (stmt))
|
|
|
538 == INTEGER_CST))
|
|
|
539 || gimple_assign_cast_p (stmt)
|
|
|
540 || (get_gimple_rhs_class (rhs_code)
|
|
|
541 == GIMPLE_SINGLE_RHS)))
|
|
|
542 {
|
|
|
543 tree lhs = gimple_assign_lhs (stmt);
|
|
|
544
|
|
|
545 if (TREE_CODE (lhs) == SSA_NAME
|
|
|
546 && bitmap_bit_p (si->va_list_escape_vars,
|
|
|
547 DECL_UID (SSA_NAME_VAR (lhs))))
|
|
|
548 continue;
|
|
|
549
|
|
|
550 if (TREE_CODE (lhs) == VAR_DECL
|
|
|
551 && bitmap_bit_p (si->va_list_vars,
|
|
|
552 DECL_UID (lhs)))
|
|
|
553 continue;
|
|
|
554 }
|
|
|
555 }
|
|
|
556
|
|
|
557 if (dump_file && (dump_flags & TDF_DETAILS))
|
|
|
558 {
|
|
|
559 fputs ("va_list escapes in ", dump_file);
|
|
|
560 print_gimple_stmt (dump_file, stmt, 0, dump_flags);
|
|
|
561 fputc ('\n', dump_file);
|
|
|
562 }
|
|
|
563 return true;
|
|
|
564 }
|
|
|
565 }
|
|
|
566 }
|
|
|
567
|
|
|
568 return false;
|
|
|
569 }
|
|
|
570
|
|
|
571
|
|
|
572 /* Return true if this optimization pass should be done.
|
|
|
573 It makes only sense for stdarg functions. */
|
|
|
574
|
|
|
575 static bool
|
|
|
576 gate_optimize_stdarg (void)
|
|
|
577 {
|
|
|
578 /* This optimization is only for stdarg functions. */
|
|
|
579 return cfun->stdarg != 0;
|
|
|
580 }
|
|
|
581
|
|
|
582
|
|
|
583 /* Entry point to the stdarg optimization pass. */
|
|
|
584
|
|
|
585 static unsigned int
|
|
|
586 execute_optimize_stdarg (void)
|
|
|
587 {
|
|
|
588 basic_block bb;
|
|
|
589 bool va_list_escapes = false;
|
|
|
590 bool va_list_simple_ptr;
|
|
|
591 struct stdarg_info si;
|
|
|
592 struct walk_stmt_info wi;
|
|
|
593 const char *funcname = NULL;
|
|
|
594 tree cfun_va_list;
|
|
|
595
|
|
|
596 cfun->va_list_gpr_size = 0;
|
|
|
597 cfun->va_list_fpr_size = 0;
|
|
|
598 memset (&si, 0, sizeof (si));
|
|
|
599 si.va_list_vars = BITMAP_ALLOC (NULL);
|
|
|
600 si.va_list_escape_vars = BITMAP_ALLOC (NULL);
|
|
|
601
|
|
|
602 if (dump_file)
|
|
|
603 funcname = lang_hooks.decl_printable_name (current_function_decl, 2);
|
|
|
604
|
|
|
605 cfun_va_list = targetm.fn_abi_va_list (cfun->decl);
|
|
|
606 va_list_simple_ptr = POINTER_TYPE_P (cfun_va_list)
|
|
|
607 && (TREE_TYPE (cfun_va_list) == void_type_node
|
|
|
608 || TREE_TYPE (cfun_va_list) == char_type_node);
|
|
|
609 gcc_assert (is_gimple_reg_type (cfun_va_list) == va_list_simple_ptr);
|
|
|
610
|
|
|
611 FOR_EACH_BB (bb)
|
|
|
612 {
|
|
|
613 gimple_stmt_iterator i;
|
|
|
614
|
|
|
615 for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
|
|
|
616 {
|
|
|
617 gimple stmt = gsi_stmt (i);
|
|
|
618 tree callee, ap;
|
|
|
619
|
|
|
620 if (!is_gimple_call (stmt))
|
|
|
621 continue;
|
|
|
622
|
|
|
623 callee = gimple_call_fndecl (stmt);
|
|
|
624 if (!callee
|
|
|
625 || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL)
|
|
|
626 continue;
|
|
|
627
|
|
|
628 switch (DECL_FUNCTION_CODE (callee))
|
|
|
629 {
|
|
|
630 case BUILT_IN_VA_START:
|
|
|
631 break;
|
|
|
632 /* If old style builtins are used, don't optimize anything. */
|
|
|
633 case BUILT_IN_SAVEREGS:
|
|
|
634 case BUILT_IN_ARGS_INFO:
|
|
|
635 case BUILT_IN_NEXT_ARG:
|
|
|
636 va_list_escapes = true;
|
|
|
637 continue;
|
|
|
638 default:
|
|
|
639 continue;
|
|
|
640 }
|
|
|
641
|
|
|
642 si.va_start_count++;
|
|
|
643 ap = gimple_call_arg (stmt, 0);
|
|
|
644
|
|
|
645 if (TREE_CODE (ap) != ADDR_EXPR)
|
|
|
646 {
|
|
|
647 va_list_escapes = true;
|
|
|
648 break;
|
|
|
649 }
|
|
|
650 ap = TREE_OPERAND (ap, 0);
|
|
|
651 if (TREE_CODE (ap) == ARRAY_REF)
|
|
|
652 {
|
|
|
653 if (! integer_zerop (TREE_OPERAND (ap, 1)))
|
|
|
654 {
|
|
|
655 va_list_escapes = true;
|
|
|
656 break;
|
|
|
657 }
|
|
|
658 ap = TREE_OPERAND (ap, 0);
|
|
|
659 }
|
|
|
660 if (TYPE_MAIN_VARIANT (TREE_TYPE (ap))
|
|
|
661 != TYPE_MAIN_VARIANT (targetm.fn_abi_va_list (cfun->decl))
|
|
|
662 || TREE_CODE (ap) != VAR_DECL)
|
|
|
663 {
|
|
|
664 va_list_escapes = true;
|
|
|
665 break;
|
|
|
666 }
|
|
|
667
|
|
|
668 if (is_global_var (ap))
|
|
|
669 {
|
|
|
670 va_list_escapes = true;
|
|
|
671 break;
|
|
|
672 }
|
|
|
673
|
|
|
674 bitmap_set_bit (si.va_list_vars, DECL_UID (ap));
|
|
|
675
|
|
|
676 /* VA_START_BB and VA_START_AP will be only used if there is just
|
|
|
677 one va_start in the function. */
|
|
|
678 si.va_start_bb = bb;
|
|
|
679 si.va_start_ap = ap;
|
|
|
680 }
|
|
|
681
|
|
|
682 if (va_list_escapes)
|
|
|
683 break;
|
|
|
684 }
|
|
|
685
|
|
|
686 /* If there were no va_start uses in the function, there is no need to
|
|
|
687 save anything. */
|
|
|
688 if (si.va_start_count == 0)
|
|
|
689 goto finish;
|
|
|
690
|
|
|
691 /* If some va_list arguments weren't local, we can't optimize. */
|
|
|
692 if (va_list_escapes)
|
|
|
693 goto finish;
|
|
|
694
|
|
|
695 /* For void * or char * va_list, something useful can be done only
|
|
|
696 if there is just one va_start. */
|
|
|
697 if (va_list_simple_ptr && si.va_start_count > 1)
|
|
|
698 {
|
|
|
699 va_list_escapes = true;
|
|
|
700 goto finish;
|
|
|
701 }
|
|
|
702
|
|
|
703 /* For struct * va_list, if the backend didn't tell us what the counter fields
|
|
|
704 are, there is nothing more we can do. */
|
|
|
705 if (!va_list_simple_ptr
|
|
|
706 && va_list_gpr_counter_field == NULL_TREE
|
|
|
707 && va_list_fpr_counter_field == NULL_TREE)
|
|
|
708 {
|
|
|
709 va_list_escapes = true;
|
|
|
710 goto finish;
|
|
|
711 }
|
|
|
712
|
|
|
713 /* For void * or char * va_list there is just one counter
|
|
|
714 (va_list itself). Use VA_LIST_GPR_SIZE for it. */
|
|
|
715 if (va_list_simple_ptr)
|
|
|
716 cfun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;
|
|
|
717
|
|
|
718 calculate_dominance_info (CDI_DOMINATORS);
|
|
|
719 memset (&wi, 0, sizeof (wi));
|
|
|
720 wi.info = si.va_list_vars;
|
|
|
721
|
|
|
722 FOR_EACH_BB (bb)
|
|
|
723 {
|
|
|
724 gimple_stmt_iterator i;
|
|
|
725
|
|
|
726 si.compute_sizes = -1;
|
|
|
727 si.bb = bb;
|
|
|
728
|
|
|
729 /* For va_list_simple_ptr, we have to check PHI nodes too. We treat
|
|
|
730 them as assignments for the purpose of escape analysis. This is
|
|
|
731 not needed for non-simple va_list because virtual phis don't perform
|
|
|
732 any real data movement. */
|
|
|
733 if (va_list_simple_ptr)
|
|
|
734 {
|
|
|
735 tree lhs, rhs;
|
|
|
736 use_operand_p uop;
|
|
|
737 ssa_op_iter soi;
|
|
|
738
|
|
|
739 for (i = gsi_start_phis (bb); !gsi_end_p (i); gsi_next (&i))
|
|
|
740 {
|
|
|
741 gimple phi = gsi_stmt (i);
|
|
|
742 lhs = PHI_RESULT (phi);
|
|
|
743
|
|
|
744 if (!is_gimple_reg (lhs))
|
|
|
745 continue;
|
|
|
746
|
|
|
747 FOR_EACH_PHI_ARG (uop, phi, soi, SSA_OP_USE)
|
|
|
748 {
|
|
|
749 rhs = USE_FROM_PTR (uop);
|
|
|
750 if (va_list_ptr_read (&si, rhs, lhs))
|
|
|
751 continue;
|
|
|
752 else if (va_list_ptr_write (&si, lhs, rhs))
|
|
|
753 continue;
|
|
|
754 else
|
|
|
755 check_va_list_escapes (&si, lhs, rhs);
|
|
|
756
|
|
|
757 if (si.va_list_escapes)
|
|
|
758 {
|
|
|
759 if (dump_file && (dump_flags & TDF_DETAILS))
|
|
|
760 {
|
|
|
761 fputs ("va_list escapes in ", dump_file);
|
|
|
762 print_gimple_stmt (dump_file, phi, 0, dump_flags);
|
|
|
763 fputc ('\n', dump_file);
|
|
|
764 }
|
|
|
765 va_list_escapes = true;
|
|
|
766 }
|
|
|
767 }
|
|
|
768 }
|
|
|
769 }
|
|
|
770
|
|
|
771 for (i = gsi_start_bb (bb);
|
|
|
772 !gsi_end_p (i) && !va_list_escapes;
|
|
|
773 gsi_next (&i))
|
|
|
774 {
|
|
|
775 gimple stmt = gsi_stmt (i);
|
|
|
776
|
|
|
777 /* Don't look at __builtin_va_{start,end}, they are ok. */
|
|
|
778 if (is_gimple_call (stmt))
|
|
|
779 {
|
|
|
780 tree callee = gimple_call_fndecl (stmt);
|
|
|
781
|
|
|
782 if (callee
|
|
|
783 && DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL
|
|
|
784 && (DECL_FUNCTION_CODE (callee) == BUILT_IN_VA_START
|
|
|
785 || DECL_FUNCTION_CODE (callee) == BUILT_IN_VA_END))
|
|
|
786 continue;
|
|
|
787 }
|
|
|
788
|
|
|
789 if (is_gimple_assign (stmt))
|
|
|
790 {
|
|
|
791 tree lhs = gimple_assign_lhs (stmt);
|
|
|
792 tree rhs = gimple_assign_rhs1 (stmt);
|
|
|
793
|
|
|
794 if (va_list_simple_ptr)
|
|
|
795 {
|
|
|
796 if (get_gimple_rhs_class (gimple_assign_rhs_code (stmt))
|
|
|
797 == GIMPLE_SINGLE_RHS)
|
|
|
798 {
|
|
|
799 /* Check for tem = ap. */
|
|
|
800 if (va_list_ptr_read (&si, rhs, lhs))
|
|
|
801 continue;
|
|
|
802
|
|
|
803 /* Check for the last insn in:
|
|
|
804 tem1 = ap;
|
|
|
805 tem2 = tem1 + CST;
|
|
|
806 ap = tem2;
|
|
|
807 sequence. */
|
|
|
808 else if (va_list_ptr_write (&si, lhs, rhs))
|
|
|
809 continue;
|
|
|
810 }
|
|
|
811
|
|
|
812 if ((gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR
|
|
|
813 && TREE_CODE (gimple_assign_rhs2 (stmt)) == INTEGER_CST)
|
|
|
814 || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt))
|
|
|
815 || (get_gimple_rhs_class (gimple_assign_rhs_code (stmt))
|
|
|
816 == GIMPLE_SINGLE_RHS))
|
|
|
817 check_va_list_escapes (&si, lhs, rhs);
|
|
|
818 }
|
|
|
819 else
|
|
|
820 {
|
|
|
821 if (get_gimple_rhs_class (gimple_assign_rhs_code (stmt))
|
|
|
822 == GIMPLE_SINGLE_RHS)
|
|
|
823 {
|
|
|
824 /* Check for ap[0].field = temp. */
|
|
|
825 if (va_list_counter_struct_op (&si, lhs, rhs, true))
|
|
|
826 continue;
|
|
|
827
|
|
|
828 /* Check for temp = ap[0].field. */
|
|
|
829 else if (va_list_counter_struct_op (&si, rhs, lhs,
|
|
|
830 false))
|
|
|
831 continue;
|
|
|
832 }
|
|
|
833
|
|
|
834 /* Do any architecture specific checking. */
|
|
|
835 if (targetm.stdarg_optimize_hook
|
|
|
836 && targetm.stdarg_optimize_hook (&si, stmt))
|
|
|
837 continue;
|
|
|
838 }
|
|
|
839 }
|
|
|
840
|
|
|
841 /* All other uses of va_list are either va_copy (that is not handled
|
|
|
842 in this optimization), taking address of va_list variable or
|
|
|
843 passing va_list to other functions (in that case va_list might
|
|
|
844 escape the function and therefore va_start needs to set it up
|
|
|
845 fully), or some unexpected use of va_list. None of these should
|
|
|
846 happen in a gimplified VA_ARG_EXPR. */
|
|
|
847 if (si.va_list_escapes
|
|
|
848 || walk_gimple_op (stmt, find_va_list_reference, &wi))
|
|
|
849 {
|
|
|
850 if (dump_file && (dump_flags & TDF_DETAILS))
|
|
|
851 {
|
|
|
852 fputs ("va_list escapes in ", dump_file);
|
|
|
853 print_gimple_stmt (dump_file, stmt, 0, dump_flags);
|
|
|
854 fputc ('\n', dump_file);
|
|
|
855 }
|
|
|
856 va_list_escapes = true;
|
|
|
857 }
|
|
|
858 }
|
|
|
859
|
|
|
860 if (va_list_escapes)
|
|
|
861 break;
|
|
|
862 }
|
|
|
863
|
|
|
864 if (! va_list_escapes
|
|
|
865 && va_list_simple_ptr
|
|
|
866 && ! bitmap_empty_p (si.va_list_escape_vars)
|
|
|
867 && check_all_va_list_escapes (&si))
|
|
|
868 va_list_escapes = true;
|
|
|
869
|
|
|
870 finish:
|
|
|
871 if (va_list_escapes)
|
|
|
872 {
|
|
|
873 cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
|
|
|
874 cfun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;
|
|
|
875 }
|
|
|
876 BITMAP_FREE (si.va_list_vars);
|
|
|
877 BITMAP_FREE (si.va_list_escape_vars);
|
|
|
878 free (si.offsets);
|
|
|
879 if (dump_file)
|
|
|
880 {
|
|
|
881 fprintf (dump_file, "%s: va_list escapes %d, needs to save ",
|
|
|
882 funcname, (int) va_list_escapes);
|
|
|
883 if (cfun->va_list_gpr_size >= VA_LIST_MAX_GPR_SIZE)
|
|
|
884 fputs ("all", dump_file);
|
|
|
885 else
|
|
|
886 fprintf (dump_file, "%d", cfun->va_list_gpr_size);
|
|
|
887 fputs (" GPR units and ", dump_file);
|
|
|
888 if (cfun->va_list_fpr_size >= VA_LIST_MAX_FPR_SIZE)
|
|
|
889 fputs ("all", dump_file);
|
|
|
890 else
|
|
|
891 fprintf (dump_file, "%d", cfun->va_list_fpr_size);
|
|
|
892 fputs (" FPR units.\n", dump_file);
|
|
|
893 }
|
|
|
894 return 0;
|
|
|
895 }
|
|
|
896
|
|
|
897
|
|
|
898 struct gimple_opt_pass pass_stdarg =
|
|
|
899 {
|
|
|
900 {
|
|
|
901 GIMPLE_PASS,
|
|
|
902 "stdarg", /* name */
|
|
|
903 gate_optimize_stdarg, /* gate */
|
|
|
904 execute_optimize_stdarg, /* execute */
|
|
|
905 NULL, /* sub */
|
|
|
906 NULL, /* next */
|
|
|
907 0, /* static_pass_number */
|
|
|
908 0, /* tv_id */
|
|
|
909 PROP_cfg | PROP_ssa | PROP_alias, /* properties_required */
|
|
|
910 0, /* properties_provided */
|
|
|
911 0, /* properties_destroyed */
|
|
|
912 0, /* todo_flags_start */
|
|
|
913 TODO_dump_func /* todo_flags_finish */
|
|
|
914 }
|
|
|
915 };
|
