Daily bump.
[official-gcc.git] / gcc / tree-stdarg.c
blob168bd2f1564ea0c3f6c247817a4776e3dfea5af4
1 /* Pass computing data for optimizing stdarg functions.
2 Copyright (C) 2004, 2005, 2007 Free Software Foundation, Inc.
3 Contributed by Jakub Jelinek <jakub@redhat.com>
5 This file is part of GCC.
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.
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.
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/>. */
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"
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. */
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. */
46 static bool
47 reachable_at_most_once (basic_block va_arg_bb, basic_block va_start_bb)
49 edge *stack, e;
50 edge_iterator ei;
51 int sp;
52 sbitmap visited;
53 bool ret;
55 if (va_arg_bb == va_start_bb)
56 return true;
58 if (! dominated_by_p (CDI_DOMINATORS, va_arg_bb, va_start_bb))
59 return false;
61 stack = XNEWVEC (edge, n_basic_blocks + 1);
62 sp = 0;
64 visited = sbitmap_alloc (last_basic_block);
65 sbitmap_zero (visited);
66 ret = true;
68 FOR_EACH_EDGE (e, ei, va_arg_bb->preds)
69 stack[sp++] = e;
71 while (sp)
73 basic_block src;
75 --sp;
76 e = stack[sp];
77 src = e->src;
79 if (e->flags & EDGE_COMPLEX)
81 ret = false;
82 break;
85 if (src == va_start_bb)
86 continue;
88 /* va_arg_bb can be executed more times than va_start_bb. */
89 if (src == va_arg_bb)
91 ret = false;
92 break;
95 gcc_assert (src != ENTRY_BLOCK_PTR);
97 if (! TEST_BIT (visited, src->index))
99 SET_BIT (visited, src->index);
100 FOR_EACH_EDGE (e, ei, src->preds)
101 stack[sp++] = e;
105 free (stack);
106 sbitmap_free (visited);
107 return ret;
111 /* For statement COUNTER = RHS, if RHS is COUNTER + constant,
112 return constant, otherwise return (unsigned HOST_WIDE_INT) -1.
113 GPR_P is true if this is GPR counter. */
115 static unsigned HOST_WIDE_INT
116 va_list_counter_bump (struct stdarg_info *si, tree counter, tree rhs,
117 bool gpr_p)
119 tree stmt, lhs, orig_lhs;
120 unsigned HOST_WIDE_INT ret = 0, val, counter_val;
121 unsigned int max_size;
123 if (si->offsets == NULL)
125 unsigned int i;
127 si->offsets = XNEWVEC (int, num_ssa_names);
128 for (i = 0; i < num_ssa_names; ++i)
129 si->offsets[i] = -1;
132 counter_val = gpr_p ? cfun->va_list_gpr_size : cfun->va_list_fpr_size;
133 max_size = gpr_p ? VA_LIST_MAX_GPR_SIZE : VA_LIST_MAX_FPR_SIZE;
134 orig_lhs = lhs = rhs;
135 while (lhs)
137 if (si->offsets[SSA_NAME_VERSION (lhs)] != -1)
139 if (counter_val >= max_size)
141 ret = max_size;
142 break;
145 ret -= counter_val - si->offsets[SSA_NAME_VERSION (lhs)];
146 break;
149 stmt = SSA_NAME_DEF_STMT (lhs);
151 if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT
152 || GIMPLE_STMT_OPERAND (stmt, 0) != lhs)
153 return (unsigned HOST_WIDE_INT) -1;
155 rhs = GIMPLE_STMT_OPERAND (stmt, 1);
156 if (TREE_CODE (rhs) == WITH_SIZE_EXPR)
157 rhs = TREE_OPERAND (rhs, 0);
159 if (TREE_CODE (rhs) == SSA_NAME)
161 lhs = rhs;
162 continue;
165 if ((TREE_CODE (rhs) == NOP_EXPR
166 || TREE_CODE (rhs) == CONVERT_EXPR)
167 && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME)
169 lhs = TREE_OPERAND (rhs, 0);
170 continue;
173 if ((TREE_CODE (rhs) == POINTER_PLUS_EXPR
174 || TREE_CODE (rhs) == PLUS_EXPR)
175 && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME
176 && TREE_CODE (TREE_OPERAND (rhs, 1)) == INTEGER_CST
177 && host_integerp (TREE_OPERAND (rhs, 1), 1))
179 ret += tree_low_cst (TREE_OPERAND (rhs, 1), 1);
180 lhs = TREE_OPERAND (rhs, 0);
181 continue;
184 if (TREE_CODE (counter) != TREE_CODE (rhs))
185 return (unsigned HOST_WIDE_INT) -1;
187 if (TREE_CODE (counter) == COMPONENT_REF)
189 if (get_base_address (counter) != get_base_address (rhs)
190 || TREE_CODE (TREE_OPERAND (rhs, 1)) != FIELD_DECL
191 || TREE_OPERAND (counter, 1) != TREE_OPERAND (rhs, 1))
192 return (unsigned HOST_WIDE_INT) -1;
194 else if (counter != rhs)
195 return (unsigned HOST_WIDE_INT) -1;
197 lhs = NULL;
200 lhs = orig_lhs;
201 val = ret + counter_val;
202 while (lhs)
204 if (si->offsets[SSA_NAME_VERSION (lhs)] != -1)
205 break;
207 if (val >= max_size)
208 si->offsets[SSA_NAME_VERSION (lhs)] = max_size;
209 else
210 si->offsets[SSA_NAME_VERSION (lhs)] = val;
212 stmt = SSA_NAME_DEF_STMT (lhs);
214 rhs = GIMPLE_STMT_OPERAND (stmt, 1);
215 if (TREE_CODE (rhs) == WITH_SIZE_EXPR)
216 rhs = TREE_OPERAND (rhs, 0);
218 if (TREE_CODE (rhs) == SSA_NAME)
220 lhs = rhs;
221 continue;
224 if ((TREE_CODE (rhs) == NOP_EXPR
225 || TREE_CODE (rhs) == CONVERT_EXPR)
226 && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME)
228 lhs = TREE_OPERAND (rhs, 0);
229 continue;
232 if ((TREE_CODE (rhs) == POINTER_PLUS_EXPR
233 || TREE_CODE (rhs) == PLUS_EXPR)
234 && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME
235 && TREE_CODE (TREE_OPERAND (rhs, 1)) == INTEGER_CST
236 && host_integerp (TREE_OPERAND (rhs, 1), 1))
238 val -= tree_low_cst (TREE_OPERAND (rhs, 1), 1);
239 lhs = TREE_OPERAND (rhs, 0);
240 continue;
243 lhs = NULL;
246 return ret;
250 /* Called by walk_tree to look for references to va_list variables. */
252 static tree
253 find_va_list_reference (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
254 void *data)
256 bitmap va_list_vars = (bitmap) data;
257 tree var = *tp;
259 if (TREE_CODE (var) == SSA_NAME)
260 var = SSA_NAME_VAR (var);
262 if (TREE_CODE (var) == VAR_DECL
263 && bitmap_bit_p (va_list_vars, DECL_UID (var)))
264 return var;
266 return NULL_TREE;
270 /* Helper function of va_list_counter_struct_op. Compute
271 cfun->va_list_{g,f}pr_size. AP is a va_list GPR/FPR counter,
272 if WRITE_P is true, seen in AP = VAR, otherwise seen in VAR = AP
273 statement. GPR_P is true if AP is a GPR counter, false if it is
274 a FPR counter. */
276 static void
277 va_list_counter_op (struct stdarg_info *si, tree ap, tree var, bool gpr_p,
278 bool write_p)
280 unsigned HOST_WIDE_INT increment;
282 if (si->compute_sizes < 0)
284 si->compute_sizes = 0;
285 if (si->va_start_count == 1
286 && reachable_at_most_once (si->bb, si->va_start_bb))
287 si->compute_sizes = 1;
289 if (dump_file && (dump_flags & TDF_DETAILS))
290 fprintf (dump_file,
291 "bb%d will %sbe executed at most once for each va_start "
292 "in bb%d\n", si->bb->index, si->compute_sizes ? "" : "not ",
293 si->va_start_bb->index);
296 if (write_p
297 && si->compute_sizes
298 && (increment = va_list_counter_bump (si, ap, var, gpr_p)) + 1 > 1)
300 if (gpr_p && cfun->va_list_gpr_size + increment < VA_LIST_MAX_GPR_SIZE)
302 cfun->va_list_gpr_size += increment;
303 return;
306 if (!gpr_p && cfun->va_list_fpr_size + increment < VA_LIST_MAX_FPR_SIZE)
308 cfun->va_list_fpr_size += increment;
309 return;
313 if (write_p || !si->compute_sizes)
315 if (gpr_p)
316 cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
317 else
318 cfun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;
323 /* If AP is a va_list GPR/FPR counter, compute cfun->va_list_{g,f}pr_size.
324 If WRITE_P is true, AP has been seen in AP = VAR assignment, if WRITE_P
325 is false, AP has been seen in VAR = AP assignment.
326 Return true if the AP = VAR (resp. VAR = AP) statement is a recognized
327 va_arg operation that doesn't cause the va_list variable to escape
328 current function. */
330 static bool
331 va_list_counter_struct_op (struct stdarg_info *si, tree ap, tree var,
332 bool write_p)
334 tree base;
336 if (TREE_CODE (ap) != COMPONENT_REF
337 || TREE_CODE (TREE_OPERAND (ap, 1)) != FIELD_DECL)
338 return false;
340 if (TREE_CODE (var) != SSA_NAME
341 || bitmap_bit_p (si->va_list_vars, DECL_UID (SSA_NAME_VAR (var))))
342 return false;
344 base = get_base_address (ap);
345 if (TREE_CODE (base) != VAR_DECL
346 || !bitmap_bit_p (si->va_list_vars, DECL_UID (base)))
347 return false;
349 if (TREE_OPERAND (ap, 1) == va_list_gpr_counter_field)
350 va_list_counter_op (si, ap, var, true, write_p);
351 else if (TREE_OPERAND (ap, 1) == va_list_fpr_counter_field)
352 va_list_counter_op (si, ap, var, false, write_p);
354 return true;
358 /* Check for TEM = AP. Return true if found and the caller shouldn't
359 search for va_list references in the statement. */
361 static bool
362 va_list_ptr_read (struct stdarg_info *si, tree ap, tree tem)
364 if (TREE_CODE (ap) != VAR_DECL
365 || !bitmap_bit_p (si->va_list_vars, DECL_UID (ap)))
366 return false;
368 if (TREE_CODE (tem) != SSA_NAME
369 || bitmap_bit_p (si->va_list_vars,
370 DECL_UID (SSA_NAME_VAR (tem)))
371 || is_global_var (SSA_NAME_VAR (tem)))
372 return false;
374 if (si->compute_sizes < 0)
376 si->compute_sizes = 0;
377 if (si->va_start_count == 1
378 && reachable_at_most_once (si->bb, si->va_start_bb))
379 si->compute_sizes = 1;
381 if (dump_file && (dump_flags & TDF_DETAILS))
382 fprintf (dump_file,
383 "bb%d will %sbe executed at most once for each va_start "
384 "in bb%d\n", si->bb->index, si->compute_sizes ? "" : "not ",
385 si->va_start_bb->index);
388 /* For void * or char * va_list types, there is just one counter.
389 If va_arg is used in a loop, we don't know how many registers need
390 saving. */
391 if (! si->compute_sizes)
392 return false;
394 if (va_list_counter_bump (si, ap, tem, true) == (unsigned HOST_WIDE_INT) -1)
395 return false;
397 /* Note the temporary, as we need to track whether it doesn't escape
398 the current function. */
399 bitmap_set_bit (si->va_list_escape_vars,
400 DECL_UID (SSA_NAME_VAR (tem)));
401 return true;
405 /* Check for:
406 tem1 = AP;
407 TEM2 = tem1 + CST;
408 AP = TEM2;
409 sequence and update cfun->va_list_gpr_size. Return true if found. */
411 static bool
412 va_list_ptr_write (struct stdarg_info *si, tree ap, tree tem2)
414 unsigned HOST_WIDE_INT increment;
416 if (TREE_CODE (ap) != VAR_DECL
417 || !bitmap_bit_p (si->va_list_vars, DECL_UID (ap)))
418 return false;
420 if (TREE_CODE (tem2) != SSA_NAME
421 || bitmap_bit_p (si->va_list_vars, DECL_UID (SSA_NAME_VAR (tem2))))
422 return false;
424 if (si->compute_sizes <= 0)
425 return false;
427 increment = va_list_counter_bump (si, ap, tem2, true);
428 if (increment + 1 <= 1)
429 return false;
431 if (cfun->va_list_gpr_size + increment < VA_LIST_MAX_GPR_SIZE)
432 cfun->va_list_gpr_size += increment;
433 else
434 cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
436 return true;
440 /* If RHS is X, (some type *) X or X + CST for X a temporary variable
441 containing value of some va_list variable plus optionally some constant,
442 either set si->va_list_escapes or add LHS to si->va_list_escape_vars,
443 depending whether LHS is a function local temporary. */
445 static void
446 check_va_list_escapes (struct stdarg_info *si, tree lhs, tree rhs)
448 if (! POINTER_TYPE_P (TREE_TYPE (rhs)))
449 return;
451 if (((TREE_CODE (rhs) == POINTER_PLUS_EXPR
452 || TREE_CODE (rhs) == PLUS_EXPR)
453 && TREE_CODE (TREE_OPERAND (rhs, 1)) == INTEGER_CST)
454 || TREE_CODE (rhs) == NOP_EXPR
455 || TREE_CODE (rhs) == CONVERT_EXPR)
456 rhs = TREE_OPERAND (rhs, 0);
458 if (TREE_CODE (rhs) != SSA_NAME
459 || ! bitmap_bit_p (si->va_list_escape_vars,
460 DECL_UID (SSA_NAME_VAR (rhs))))
461 return;
463 if (TREE_CODE (lhs) != SSA_NAME || is_global_var (SSA_NAME_VAR (lhs)))
465 si->va_list_escapes = true;
466 return;
469 if (si->compute_sizes < 0)
471 si->compute_sizes = 0;
472 if (si->va_start_count == 1
473 && reachable_at_most_once (si->bb, si->va_start_bb))
474 si->compute_sizes = 1;
476 if (dump_file && (dump_flags & TDF_DETAILS))
477 fprintf (dump_file,
478 "bb%d will %sbe executed at most once for each va_start "
479 "in bb%d\n", si->bb->index, si->compute_sizes ? "" : "not ",
480 si->va_start_bb->index);
483 /* For void * or char * va_list types, there is just one counter.
484 If va_arg is used in a loop, we don't know how many registers need
485 saving. */
486 if (! si->compute_sizes)
488 si->va_list_escapes = true;
489 return;
492 if (va_list_counter_bump (si, si->va_start_ap, lhs, true)
493 == (unsigned HOST_WIDE_INT) -1)
495 si->va_list_escapes = true;
496 return;
499 bitmap_set_bit (si->va_list_escape_vars,
500 DECL_UID (SSA_NAME_VAR (lhs)));
504 /* Check all uses of temporaries from si->va_list_escape_vars bitmap.
505 Return true if va_list might be escaping. */
507 static bool
508 check_all_va_list_escapes (struct stdarg_info *si)
510 basic_block bb;
512 FOR_EACH_BB (bb)
514 block_stmt_iterator i;
516 for (i = bsi_start (bb); !bsi_end_p (i); bsi_next (&i))
518 tree stmt = bsi_stmt (i), use;
519 ssa_op_iter iter;
521 FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_ALL_USES)
523 if (! bitmap_bit_p (si->va_list_escape_vars,
524 DECL_UID (SSA_NAME_VAR (use))))
525 continue;
527 if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
529 tree lhs = GIMPLE_STMT_OPERAND (stmt, 0);
530 tree rhs = GIMPLE_STMT_OPERAND (stmt, 1);
532 if (TREE_CODE (rhs) == WITH_SIZE_EXPR)
533 rhs = TREE_OPERAND (rhs, 0);
535 /* x = *ap_temp; */
536 if (TREE_CODE (rhs) == INDIRECT_REF
537 && TREE_OPERAND (rhs, 0) == use
538 && TYPE_SIZE_UNIT (TREE_TYPE (rhs))
539 && host_integerp (TYPE_SIZE_UNIT (TREE_TYPE (rhs)), 1)
540 && si->offsets[SSA_NAME_VERSION (use)] != -1)
542 unsigned HOST_WIDE_INT gpr_size;
543 tree access_size = TYPE_SIZE_UNIT (TREE_TYPE (rhs));
545 gpr_size = si->offsets[SSA_NAME_VERSION (use)]
546 + tree_low_cst (access_size, 1);
547 if (gpr_size >= VA_LIST_MAX_GPR_SIZE)
548 cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
549 else if (gpr_size > cfun->va_list_gpr_size)
550 cfun->va_list_gpr_size = gpr_size;
551 continue;
554 /* va_arg sequences may contain
555 other_ap_temp = ap_temp;
556 other_ap_temp = ap_temp + constant;
557 other_ap_temp = (some_type *) ap_temp;
558 ap = ap_temp;
559 statements. */
560 if ((TREE_CODE (rhs) == POINTER_PLUS_EXPR
561 && TREE_CODE (TREE_OPERAND (rhs, 1)) == INTEGER_CST)
562 || TREE_CODE (rhs) == NOP_EXPR
563 || TREE_CODE (rhs) == CONVERT_EXPR)
564 rhs = TREE_OPERAND (rhs, 0);
566 if (rhs == use)
568 if (TREE_CODE (lhs) == SSA_NAME
569 && bitmap_bit_p (si->va_list_escape_vars,
570 DECL_UID (SSA_NAME_VAR (lhs))))
571 continue;
573 if (TREE_CODE (lhs) == VAR_DECL
574 && bitmap_bit_p (si->va_list_vars,
575 DECL_UID (lhs)))
576 continue;
580 if (dump_file && (dump_flags & TDF_DETAILS))
582 fputs ("va_list escapes in ", dump_file);
583 print_generic_expr (dump_file, stmt, dump_flags);
584 fputc ('\n', dump_file);
586 return true;
591 return false;
595 /* Return true if this optimization pass should be done.
596 It makes only sense for stdarg functions. */
598 static bool
599 gate_optimize_stdarg (void)
601 /* This optimization is only for stdarg functions. */
602 return current_function_stdarg != 0;
606 /* Entry point to the stdarg optimization pass. */
608 static unsigned int
609 execute_optimize_stdarg (void)
611 basic_block bb;
612 bool va_list_escapes = false;
613 bool va_list_simple_ptr;
614 struct stdarg_info si;
615 const char *funcname = NULL;
617 cfun->va_list_gpr_size = 0;
618 cfun->va_list_fpr_size = 0;
619 memset (&si, 0, sizeof (si));
620 si.va_list_vars = BITMAP_ALLOC (NULL);
621 si.va_list_escape_vars = BITMAP_ALLOC (NULL);
623 if (dump_file)
624 funcname = lang_hooks.decl_printable_name (current_function_decl, 2);
626 va_list_simple_ptr = POINTER_TYPE_P (va_list_type_node)
627 && (TREE_TYPE (va_list_type_node) == void_type_node
628 || TREE_TYPE (va_list_type_node) == char_type_node);
629 gcc_assert (is_gimple_reg_type (va_list_type_node) == va_list_simple_ptr);
631 FOR_EACH_BB (bb)
633 block_stmt_iterator i;
635 for (i = bsi_start (bb); !bsi_end_p (i); bsi_next (&i))
637 tree stmt = bsi_stmt (i);
638 tree call = get_call_expr_in (stmt), callee;
639 tree ap;
641 if (!call)
642 continue;
644 callee = get_callee_fndecl (call);
645 if (!callee
646 || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL)
647 continue;
649 switch (DECL_FUNCTION_CODE (callee))
651 case BUILT_IN_VA_START:
652 break;
653 /* If old style builtins are used, don't optimize anything. */
654 case BUILT_IN_SAVEREGS:
655 case BUILT_IN_STDARG_START:
656 case BUILT_IN_ARGS_INFO:
657 case BUILT_IN_NEXT_ARG:
658 va_list_escapes = true;
659 continue;
660 default:
661 continue;
664 si.va_start_count++;
665 ap = CALL_EXPR_ARG (call, 0);
667 if (TREE_CODE (ap) != ADDR_EXPR)
669 va_list_escapes = true;
670 break;
672 ap = TREE_OPERAND (ap, 0);
673 if (TREE_CODE (ap) == ARRAY_REF)
675 if (! integer_zerop (TREE_OPERAND (ap, 1)))
677 va_list_escapes = true;
678 break;
680 ap = TREE_OPERAND (ap, 0);
682 if (TYPE_MAIN_VARIANT (TREE_TYPE (ap))
683 != TYPE_MAIN_VARIANT (va_list_type_node)
684 || TREE_CODE (ap) != VAR_DECL)
686 va_list_escapes = true;
687 break;
690 if (is_global_var (ap))
692 va_list_escapes = true;
693 break;
696 bitmap_set_bit (si.va_list_vars, DECL_UID (ap));
698 /* VA_START_BB and VA_START_AP will be only used if there is just
699 one va_start in the function. */
700 si.va_start_bb = bb;
701 si.va_start_ap = ap;
704 if (va_list_escapes)
705 break;
708 /* If there were no va_start uses in the function, there is no need to
709 save anything. */
710 if (si.va_start_count == 0)
711 goto finish;
713 /* If some va_list arguments weren't local, we can't optimize. */
714 if (va_list_escapes)
715 goto finish;
717 /* For void * or char * va_list, something useful can be done only
718 if there is just one va_start. */
719 if (va_list_simple_ptr && si.va_start_count > 1)
721 va_list_escapes = true;
722 goto finish;
725 /* For struct * va_list, if the backend didn't tell us what the counter fields
726 are, there is nothing more we can do. */
727 if (!va_list_simple_ptr
728 && va_list_gpr_counter_field == NULL_TREE
729 && va_list_fpr_counter_field == NULL_TREE)
731 va_list_escapes = true;
732 goto finish;
735 /* For void * or char * va_list there is just one counter
736 (va_list itself). Use VA_LIST_GPR_SIZE for it. */
737 if (va_list_simple_ptr)
738 cfun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;
740 calculate_dominance_info (CDI_DOMINATORS);
742 FOR_EACH_BB (bb)
744 block_stmt_iterator i;
746 si.compute_sizes = -1;
747 si.bb = bb;
749 /* For va_list_simple_ptr, we have to check PHI nodes too. We treat
750 them as assignments for the purpose of escape analysis. This is
751 not needed for non-simple va_list because virtual phis don't perform
752 any real data movement. */
753 if (va_list_simple_ptr)
755 tree phi, lhs, rhs;
756 use_operand_p uop;
757 ssa_op_iter soi;
759 for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
761 lhs = PHI_RESULT (phi);
763 if (!is_gimple_reg (lhs))
764 continue;
766 FOR_EACH_PHI_ARG (uop, phi, soi, SSA_OP_USE)
768 rhs = USE_FROM_PTR (uop);
769 if (va_list_ptr_read (&si, rhs, lhs))
770 continue;
771 else if (va_list_ptr_write (&si, lhs, rhs))
772 continue;
773 else
774 check_va_list_escapes (&si, lhs, rhs);
776 if (si.va_list_escapes
777 || walk_tree (&phi, find_va_list_reference,
778 si.va_list_vars, NULL))
780 if (dump_file && (dump_flags & TDF_DETAILS))
782 fputs ("va_list escapes in ", dump_file);
783 print_generic_expr (dump_file, phi, dump_flags);
784 fputc ('\n', dump_file);
786 va_list_escapes = true;
792 for (i = bsi_start (bb);
793 !bsi_end_p (i) && !va_list_escapes;
794 bsi_next (&i))
796 tree stmt = bsi_stmt (i);
797 tree call;
799 /* Don't look at __builtin_va_{start,end}, they are ok. */
800 call = get_call_expr_in (stmt);
801 if (call)
803 tree callee = get_callee_fndecl (call);
805 if (callee
806 && DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL
807 && (DECL_FUNCTION_CODE (callee) == BUILT_IN_VA_START
808 || DECL_FUNCTION_CODE (callee) == BUILT_IN_VA_END))
809 continue;
812 if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
814 tree lhs = GIMPLE_STMT_OPERAND (stmt, 0);
815 tree rhs = GIMPLE_STMT_OPERAND (stmt, 1);
817 if (TREE_CODE (rhs) == WITH_SIZE_EXPR)
818 rhs = TREE_OPERAND (rhs, 0);
820 if (va_list_simple_ptr)
822 /* Check for tem = ap. */
823 if (va_list_ptr_read (&si, rhs, lhs))
824 continue;
826 /* Check for the last insn in:
827 tem1 = ap;
828 tem2 = tem1 + CST;
829 ap = tem2;
830 sequence. */
831 else if (va_list_ptr_write (&si, lhs, rhs))
832 continue;
834 else
835 check_va_list_escapes (&si, lhs, rhs);
837 else
839 /* Check for ap[0].field = temp. */
840 if (va_list_counter_struct_op (&si, lhs, rhs, true))
841 continue;
843 /* Check for temp = ap[0].field. */
844 else if (va_list_counter_struct_op (&si, rhs, lhs, false))
845 continue;
847 /* Do any architecture specific checking. */
848 else if (targetm.stdarg_optimize_hook
849 && targetm.stdarg_optimize_hook (&si, lhs, rhs))
850 continue;
854 /* All other uses of va_list are either va_copy (that is not handled
855 in this optimization), taking address of va_list variable or
856 passing va_list to other functions (in that case va_list might
857 escape the function and therefore va_start needs to set it up
858 fully), or some unexpected use of va_list. None of these should
859 happen in a gimplified VA_ARG_EXPR. */
860 if (si.va_list_escapes
861 || walk_tree (&stmt, find_va_list_reference,
862 si.va_list_vars, NULL))
864 if (dump_file && (dump_flags & TDF_DETAILS))
866 fputs ("va_list escapes in ", dump_file);
867 print_generic_expr (dump_file, stmt, dump_flags);
868 fputc ('\n', dump_file);
870 va_list_escapes = true;
874 if (va_list_escapes)
875 break;
878 if (! va_list_escapes
879 && va_list_simple_ptr
880 && ! bitmap_empty_p (si.va_list_escape_vars)
881 && check_all_va_list_escapes (&si))
882 va_list_escapes = true;
884 finish:
885 if (va_list_escapes)
887 cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
888 cfun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;
890 BITMAP_FREE (si.va_list_vars);
891 BITMAP_FREE (si.va_list_escape_vars);
892 free (si.offsets);
893 if (dump_file)
895 fprintf (dump_file, "%s: va_list escapes %d, needs to save ",
896 funcname, (int) va_list_escapes);
897 if (cfun->va_list_gpr_size >= VA_LIST_MAX_GPR_SIZE)
898 fputs ("all", dump_file);
899 else
900 fprintf (dump_file, "%d", cfun->va_list_gpr_size);
901 fputs (" GPR units and ", dump_file);
902 if (cfun->va_list_fpr_size >= VA_LIST_MAX_FPR_SIZE)
903 fputs ("all", dump_file);
904 else
905 fprintf (dump_file, "%d", cfun->va_list_fpr_size);
906 fputs (" FPR units.\n", dump_file);
908 return 0;
912 struct tree_opt_pass pass_stdarg =
914 "stdarg", /* name */
915 gate_optimize_stdarg, /* gate */
916 execute_optimize_stdarg, /* execute */
917 NULL, /* sub */
918 NULL, /* next */
919 0, /* static_pass_number */
920 0, /* tv_id */
921 PROP_cfg | PROP_ssa | PROP_alias, /* properties_required */
922 0, /* properties_provided */
923 0, /* properties_destroyed */
924 0, /* todo_flags_start */
925 TODO_dump_func, /* todo_flags_finish */
926 0 /* letter */