* Makefile.in (reg-stack.o): Don't depend on gt-reg-stack.h.
[official-gcc.git] / gcc / tree-stdarg.c
blob4a67bc850f6944abda255c0c18ed28320e307de7
1 /* Pass computing data for optimizing stdarg functions.
2 Copyright (C) 2004, 2005 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 2, 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 COPYING. If not, write to
19 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "tree.h"
27 #include "function.h"
28 #include "langhooks.h"
29 #include "diagnostic.h"
30 #include "target.h"
31 #include "tree-flow.h"
32 #include "tree-pass.h"
33 #include "tree-stdarg.h"
35 /* A simple pass that attempts to optimize stdarg functions on architectures
36 that need to save register arguments to stack on entry to stdarg functions.
37 If the function doesn't use any va_start macros, no registers need to
38 be saved. If va_start macros are used, the va_list variables don't escape
39 the function, it is only necessary to save registers that will be used
40 in va_arg macros. E.g. if va_arg is only used with integral types
41 in the function, floating point registers don't need to be saved, etc. */
44 /* Return true if basic block VA_ARG_BB is dominated by VA_START_BB and
45 is executed at most as many times as VA_START_BB. */
47 static bool
48 reachable_at_most_once (basic_block va_arg_bb, basic_block va_start_bb)
50 edge *stack, e;
51 edge_iterator ei;
52 int sp;
53 sbitmap visited;
54 bool ret;
56 if (va_arg_bb == va_start_bb)
57 return true;
59 if (! dominated_by_p (CDI_DOMINATORS, va_arg_bb, va_start_bb))
60 return false;
62 stack = XNEWVEC (edge, n_basic_blocks + 1);
63 sp = 0;
65 visited = sbitmap_alloc (last_basic_block);
66 sbitmap_zero (visited);
67 ret = true;
69 FOR_EACH_EDGE (e, ei, va_arg_bb->preds)
70 stack[sp++] = e;
72 while (sp)
74 basic_block src;
76 --sp;
77 e = stack[sp];
78 src = e->src;
80 if (e->flags & EDGE_COMPLEX)
82 ret = false;
83 break;
86 if (src == va_start_bb)
87 continue;
89 /* va_arg_bb can be executed more times than va_start_bb. */
90 if (src == va_arg_bb)
92 ret = false;
93 break;
96 gcc_assert (src != ENTRY_BLOCK_PTR);
98 if (! TEST_BIT (visited, src->index))
100 SET_BIT (visited, src->index);
101 FOR_EACH_EDGE (e, ei, src->preds)
102 stack[sp++] = e;
106 free (stack);
107 sbitmap_free (visited);
108 return ret;
112 /* For statement COUNTER = RHS, if RHS is COUNTER + constant,
113 return constant, otherwise return (unsigned HOST_WIDE_INT) -1.
114 GPR_P is true if this is GPR counter. */
116 static unsigned HOST_WIDE_INT
117 va_list_counter_bump (struct stdarg_info *si, tree counter, tree rhs,
118 bool gpr_p)
120 tree stmt, lhs, orig_lhs;
121 unsigned HOST_WIDE_INT ret = 0, val, counter_val;
122 unsigned int max_size;
124 if (si->offsets == NULL)
126 unsigned int i;
128 si->offsets = XNEWVEC (int, num_ssa_names);
129 for (i = 0; i < num_ssa_names; ++i)
130 si->offsets[i] = -1;
133 counter_val = gpr_p ? cfun->va_list_gpr_size : cfun->va_list_fpr_size;
134 max_size = gpr_p ? VA_LIST_MAX_GPR_SIZE : VA_LIST_MAX_FPR_SIZE;
135 orig_lhs = lhs = rhs;
136 while (lhs)
138 if (si->offsets[SSA_NAME_VERSION (lhs)] != -1)
140 if (counter_val >= max_size)
142 ret = max_size;
143 break;
146 ret -= counter_val - si->offsets[SSA_NAME_VERSION (lhs)];
147 break;
150 stmt = SSA_NAME_DEF_STMT (lhs);
152 if (TREE_CODE (stmt) != MODIFY_EXPR
153 || TREE_OPERAND (stmt, 0) != lhs)
154 return (unsigned HOST_WIDE_INT) -1;
156 rhs = TREE_OPERAND (stmt, 1);
157 if (TREE_CODE (rhs) == WITH_SIZE_EXPR)
158 rhs = TREE_OPERAND (rhs, 0);
160 if (TREE_CODE (rhs) == SSA_NAME)
162 lhs = rhs;
163 continue;
166 if ((TREE_CODE (rhs) == NOP_EXPR
167 || TREE_CODE (rhs) == CONVERT_EXPR)
168 && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME)
170 lhs = TREE_OPERAND (rhs, 0);
171 continue;
174 if (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 = TREE_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) == PLUS_EXPR
233 && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME
234 && TREE_CODE (TREE_OPERAND (rhs, 1)) == INTEGER_CST
235 && host_integerp (TREE_OPERAND (rhs, 1), 1))
237 val -= tree_low_cst (TREE_OPERAND (rhs, 1), 1);
238 lhs = TREE_OPERAND (rhs, 0);
239 continue;
242 lhs = NULL;
245 return ret;
249 /* Called by walk_tree to look for references to va_list variables. */
251 static tree
252 find_va_list_reference (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
253 void *data)
255 bitmap va_list_vars = (bitmap) data;
256 tree var = *tp;
258 if (TREE_CODE (var) == SSA_NAME)
259 var = SSA_NAME_VAR (var);
261 if (TREE_CODE (var) == VAR_DECL
262 && bitmap_bit_p (va_list_vars, DECL_UID (var)))
263 return var;
265 return NULL_TREE;
269 /* Helper function of va_list_counter_struct_op. Compute
270 cfun->va_list_{g,f}pr_size. AP is a va_list GPR/FPR counter,
271 if WRITE_P is true, seen in AP = VAR, otherwise seen in VAR = AP
272 statement. GPR_P is true if AP is a GPR counter, false if it is
273 a FPR counter. */
275 static void
276 va_list_counter_op (struct stdarg_info *si, tree ap, tree var, bool gpr_p,
277 bool write_p)
279 unsigned HOST_WIDE_INT increment;
281 if (si->compute_sizes < 0)
283 si->compute_sizes = 0;
284 if (si->va_start_count == 1
285 && reachable_at_most_once (si->bb, si->va_start_bb))
286 si->compute_sizes = 1;
288 if (dump_file && (dump_flags & TDF_DETAILS))
289 fprintf (dump_file,
290 "bb%d will %sbe executed at most once for each va_start "
291 "in bb%d\n", si->bb->index, si->compute_sizes ? "" : "not ",
292 si->va_start_bb->index);
295 if (write_p
296 && si->compute_sizes
297 && (increment = va_list_counter_bump (si, ap, var, gpr_p)) + 1 > 1)
299 if (gpr_p && cfun->va_list_gpr_size + increment < VA_LIST_MAX_GPR_SIZE)
301 cfun->va_list_gpr_size += increment;
302 return;
305 if (!gpr_p && cfun->va_list_fpr_size + increment < VA_LIST_MAX_FPR_SIZE)
307 cfun->va_list_fpr_size += increment;
308 return;
312 if (write_p || !si->compute_sizes)
314 if (gpr_p)
315 cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
316 else
317 cfun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;
322 /* If AP is a va_list GPR/FPR counter, compute cfun->va_list_{g,f}pr_size.
323 If WRITE_P is true, AP has been seen in AP = VAR assignment, if WRITE_P
324 is false, AP has been seen in VAR = AP assignment.
325 Return true if the AP = VAR (resp. VAR = AP) statement is a recognized
326 va_arg operation that doesn't cause the va_list variable to escape
327 current function. */
329 static bool
330 va_list_counter_struct_op (struct stdarg_info *si, tree ap, tree var,
331 bool write_p)
333 tree base;
335 if (TREE_CODE (ap) != COMPONENT_REF
336 || TREE_CODE (TREE_OPERAND (ap, 1)) != FIELD_DECL)
337 return false;
339 if (TREE_CODE (var) != SSA_NAME
340 || bitmap_bit_p (si->va_list_vars, DECL_UID (SSA_NAME_VAR (var))))
341 return false;
343 base = get_base_address (ap);
344 if (TREE_CODE (base) != VAR_DECL
345 || !bitmap_bit_p (si->va_list_vars, DECL_UID (base)))
346 return false;
348 if (TREE_OPERAND (ap, 1) == va_list_gpr_counter_field)
349 va_list_counter_op (si, ap, var, true, write_p);
350 else if (TREE_OPERAND (ap, 1) == va_list_fpr_counter_field)
351 va_list_counter_op (si, ap, var, false, write_p);
353 return true;
357 /* Check for TEM = AP. Return true if found and the caller shouldn't
358 search for va_list references in the statement. */
360 static bool
361 va_list_ptr_read (struct stdarg_info *si, tree ap, tree tem)
363 if (TREE_CODE (ap) != VAR_DECL
364 || !bitmap_bit_p (si->va_list_vars, DECL_UID (ap)))
365 return false;
367 if (TREE_CODE (tem) != SSA_NAME
368 || bitmap_bit_p (si->va_list_vars,
369 DECL_UID (SSA_NAME_VAR (tem)))
370 || is_global_var (SSA_NAME_VAR (tem)))
371 return false;
373 if (si->compute_sizes < 0)
375 si->compute_sizes = 0;
376 if (si->va_start_count == 1
377 && reachable_at_most_once (si->bb, si->va_start_bb))
378 si->compute_sizes = 1;
380 if (dump_file && (dump_flags & TDF_DETAILS))
381 fprintf (dump_file,
382 "bb%d will %sbe executed at most once for each va_start "
383 "in bb%d\n", si->bb->index, si->compute_sizes ? "" : "not ",
384 si->va_start_bb->index);
387 /* For void * or char * va_list types, there is just one counter.
388 If va_arg is used in a loop, we don't know how many registers need
389 saving. */
390 if (! si->compute_sizes)
391 return false;
393 if (va_list_counter_bump (si, ap, tem, true) == (unsigned HOST_WIDE_INT) -1)
394 return false;
396 /* Note the temporary, as we need to track whether it doesn't escape
397 the current function. */
398 bitmap_set_bit (si->va_list_escape_vars,
399 DECL_UID (SSA_NAME_VAR (tem)));
400 return true;
404 /* Check for:
405 tem1 = AP;
406 TEM2 = tem1 + CST;
407 AP = TEM2;
408 sequence and update cfun->va_list_gpr_size. Return true if found. */
410 static bool
411 va_list_ptr_write (struct stdarg_info *si, tree ap, tree tem2)
413 unsigned HOST_WIDE_INT increment;
415 if (TREE_CODE (ap) != VAR_DECL
416 || !bitmap_bit_p (si->va_list_vars, DECL_UID (ap)))
417 return false;
419 if (TREE_CODE (tem2) != SSA_NAME
420 || bitmap_bit_p (si->va_list_vars, DECL_UID (SSA_NAME_VAR (tem2))))
421 return false;
423 if (si->compute_sizes <= 0)
424 return false;
426 increment = va_list_counter_bump (si, ap, tem2, true);
427 if (increment + 1 <= 1)
428 return false;
430 if (cfun->va_list_gpr_size + increment < VA_LIST_MAX_GPR_SIZE)
431 cfun->va_list_gpr_size += increment;
432 else
433 cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
435 return true;
439 /* If RHS is X, (some type *) X or X + CST for X a temporary variable
440 containing value of some va_list variable plus optionally some constant,
441 either set si->va_list_escapes or add LHS to si->va_list_escape_vars,
442 depending whether LHS is a function local temporary. */
444 static void
445 check_va_list_escapes (struct stdarg_info *si, tree lhs, tree rhs)
447 if (! POINTER_TYPE_P (TREE_TYPE (rhs)))
448 return;
450 if ((TREE_CODE (rhs) == PLUS_EXPR
451 && TREE_CODE (TREE_OPERAND (rhs, 1)) == INTEGER_CST)
452 || TREE_CODE (rhs) == NOP_EXPR
453 || TREE_CODE (rhs) == CONVERT_EXPR)
454 rhs = TREE_OPERAND (rhs, 0);
456 if (TREE_CODE (rhs) != SSA_NAME
457 || ! bitmap_bit_p (si->va_list_escape_vars,
458 DECL_UID (SSA_NAME_VAR (rhs))))
459 return;
461 if (TREE_CODE (lhs) != SSA_NAME || is_global_var (SSA_NAME_VAR (lhs)))
463 si->va_list_escapes = true;
464 return;
467 if (si->compute_sizes < 0)
469 si->compute_sizes = 0;
470 if (si->va_start_count == 1
471 && reachable_at_most_once (si->bb, si->va_start_bb))
472 si->compute_sizes = 1;
474 if (dump_file && (dump_flags & TDF_DETAILS))
475 fprintf (dump_file,
476 "bb%d will %sbe executed at most once for each va_start "
477 "in bb%d\n", si->bb->index, si->compute_sizes ? "" : "not ",
478 si->va_start_bb->index);
481 /* For void * or char * va_list types, there is just one counter.
482 If va_arg is used in a loop, we don't know how many registers need
483 saving. */
484 if (! si->compute_sizes)
486 si->va_list_escapes = true;
487 return;
490 if (va_list_counter_bump (si, si->va_start_ap, lhs, true)
491 == (unsigned HOST_WIDE_INT) -1)
493 si->va_list_escapes = true;
494 return;
497 bitmap_set_bit (si->va_list_escape_vars,
498 DECL_UID (SSA_NAME_VAR (lhs)));
502 /* Check all uses of temporaries from si->va_list_escape_vars bitmap.
503 Return true if va_list might be escaping. */
505 static bool
506 check_all_va_list_escapes (struct stdarg_info *si)
508 basic_block bb;
510 FOR_EACH_BB (bb)
512 block_stmt_iterator i;
514 for (i = bsi_start (bb); !bsi_end_p (i); bsi_next (&i))
516 tree stmt = bsi_stmt (i), use;
517 ssa_op_iter iter;
519 FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_ALL_USES)
521 if (! bitmap_bit_p (si->va_list_escape_vars,
522 DECL_UID (SSA_NAME_VAR (use))))
523 continue;
525 if (TREE_CODE (stmt) == MODIFY_EXPR)
527 tree lhs = TREE_OPERAND (stmt, 0);
528 tree rhs = TREE_OPERAND (stmt, 1);
530 if (TREE_CODE (rhs) == WITH_SIZE_EXPR)
531 rhs = TREE_OPERAND (rhs, 0);
533 /* x = *ap_temp; */
534 if (TREE_CODE (rhs) == INDIRECT_REF
535 && TREE_OPERAND (rhs, 0) == use
536 && TYPE_SIZE_UNIT (TREE_TYPE (rhs))
537 && host_integerp (TYPE_SIZE_UNIT (TREE_TYPE (rhs)), 1)
538 && si->offsets[SSA_NAME_VERSION (use)] != -1)
540 unsigned HOST_WIDE_INT gpr_size;
541 tree access_size = TYPE_SIZE_UNIT (TREE_TYPE (rhs));
543 gpr_size = si->offsets[SSA_NAME_VERSION (use)]
544 + tree_low_cst (access_size, 1);
545 if (gpr_size >= VA_LIST_MAX_GPR_SIZE)
546 cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
547 else if (gpr_size > cfun->va_list_gpr_size)
548 cfun->va_list_gpr_size = gpr_size;
549 continue;
552 /* va_arg sequences may contain
553 other_ap_temp = ap_temp;
554 other_ap_temp = ap_temp + constant;
555 other_ap_temp = (some_type *) ap_temp;
556 ap = ap_temp;
557 statements. */
558 if ((TREE_CODE (rhs) == PLUS_EXPR
559 && TREE_CODE (TREE_OPERAND (rhs, 1)) == INTEGER_CST)
560 || TREE_CODE (rhs) == NOP_EXPR
561 || TREE_CODE (rhs) == CONVERT_EXPR)
562 rhs = TREE_OPERAND (rhs, 0);
564 if (rhs == use)
566 if (TREE_CODE (lhs) == SSA_NAME
567 && bitmap_bit_p (si->va_list_escape_vars,
568 DECL_UID (SSA_NAME_VAR (lhs))))
569 continue;
571 if (TREE_CODE (lhs) == VAR_DECL
572 && bitmap_bit_p (si->va_list_vars,
573 DECL_UID (lhs)))
574 continue;
578 if (dump_file && (dump_flags & TDF_DETAILS))
580 fputs ("va_list escapes in ", dump_file);
581 print_generic_expr (dump_file, stmt, dump_flags);
582 fputc ('\n', dump_file);
584 return true;
589 return false;
593 /* Return true if this optimization pass should be done.
594 It makes only sense for stdarg functions. */
596 static bool
597 gate_optimize_stdarg (void)
599 /* This optimization is only for stdarg functions. */
600 return current_function_stdarg != 0;
604 /* Entry point to the stdarg optimization pass. */
606 static unsigned int
607 execute_optimize_stdarg (void)
609 basic_block bb;
610 bool va_list_escapes = false;
611 bool va_list_simple_ptr;
612 struct stdarg_info si;
613 const char *funcname = NULL;
615 cfun->va_list_gpr_size = 0;
616 cfun->va_list_fpr_size = 0;
617 memset (&si, 0, sizeof (si));
618 si.va_list_vars = BITMAP_ALLOC (NULL);
619 si.va_list_escape_vars = BITMAP_ALLOC (NULL);
621 if (dump_file)
622 funcname = lang_hooks.decl_printable_name (current_function_decl, 2);
624 va_list_simple_ptr = POINTER_TYPE_P (va_list_type_node)
625 && (TREE_TYPE (va_list_type_node) == void_type_node
626 || TREE_TYPE (va_list_type_node) == char_type_node);
627 gcc_assert (is_gimple_reg_type (va_list_type_node) == va_list_simple_ptr);
629 FOR_EACH_BB (bb)
631 block_stmt_iterator i;
633 for (i = bsi_start (bb); !bsi_end_p (i); bsi_next (&i))
635 tree stmt = bsi_stmt (i);
636 tree call = get_call_expr_in (stmt), callee;
637 tree ap;
639 if (!call)
640 continue;
642 callee = get_callee_fndecl (call);
643 if (!callee
644 || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL)
645 continue;
647 switch (DECL_FUNCTION_CODE (callee))
649 case BUILT_IN_VA_START:
650 break;
651 /* If old style builtins are used, don't optimize anything. */
652 case BUILT_IN_SAVEREGS:
653 case BUILT_IN_STDARG_START:
654 case BUILT_IN_ARGS_INFO:
655 case BUILT_IN_NEXT_ARG:
656 va_list_escapes = true;
657 continue;
658 default:
659 continue;
662 si.va_start_count++;
663 ap = TREE_VALUE (TREE_OPERAND (call, 1));
665 if (TREE_CODE (ap) != ADDR_EXPR)
667 va_list_escapes = true;
668 break;
670 ap = TREE_OPERAND (ap, 0);
671 if (TREE_CODE (ap) == ARRAY_REF)
673 if (! integer_zerop (TREE_OPERAND (ap, 1)))
675 va_list_escapes = true;
676 break;
678 ap = TREE_OPERAND (ap, 0);
680 if (TYPE_MAIN_VARIANT (TREE_TYPE (ap))
681 != TYPE_MAIN_VARIANT (va_list_type_node)
682 || TREE_CODE (ap) != VAR_DECL)
684 va_list_escapes = true;
685 break;
688 if (is_global_var (ap))
690 va_list_escapes = true;
691 break;
694 bitmap_set_bit (si.va_list_vars, DECL_UID (ap));
696 /* VA_START_BB and VA_START_AP will be only used if there is just
697 one va_start in the function. */
698 si.va_start_bb = bb;
699 si.va_start_ap = ap;
702 if (va_list_escapes)
703 break;
706 /* If there were no va_start uses in the function, there is no need to
707 save anything. */
708 if (si.va_start_count == 0)
709 goto finish;
711 /* If some va_list arguments weren't local, we can't optimize. */
712 if (va_list_escapes)
713 goto finish;
715 /* For void * or char * va_list, something useful can be done only
716 if there is just one va_start. */
717 if (va_list_simple_ptr && si.va_start_count > 1)
719 va_list_escapes = true;
720 goto finish;
723 /* For struct * va_list, if the backend didn't tell us what the counter fields
724 are, there is nothing more we can do. */
725 if (!va_list_simple_ptr
726 && va_list_gpr_counter_field == NULL_TREE
727 && va_list_fpr_counter_field == NULL_TREE)
729 va_list_escapes = true;
730 goto finish;
733 /* For void * or char * va_list there is just one counter
734 (va_list itself). Use VA_LIST_GPR_SIZE for it. */
735 if (va_list_simple_ptr)
736 cfun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;
738 calculate_dominance_info (CDI_DOMINATORS);
740 FOR_EACH_BB (bb)
742 block_stmt_iterator i;
744 si.compute_sizes = -1;
745 si.bb = bb;
747 /* For va_list_simple_ptr, we have to check PHI nodes too. We treat
748 them as assignments for the purpose of escape analysis. This is
749 not needed for non-simple va_list because virtual phis don't perform
750 any real data movement. */
751 if (va_list_simple_ptr)
753 tree phi, lhs, rhs;
754 use_operand_p uop;
755 ssa_op_iter soi;
757 for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
759 lhs = PHI_RESULT (phi);
761 if (!is_gimple_reg (lhs))
762 continue;
764 FOR_EACH_PHI_ARG (uop, phi, soi, SSA_OP_USE)
766 rhs = USE_FROM_PTR (uop);
767 if (va_list_ptr_read (&si, rhs, lhs))
768 continue;
769 else if (va_list_ptr_write (&si, lhs, rhs))
770 continue;
771 else
772 check_va_list_escapes (&si, lhs, rhs);
774 if (si.va_list_escapes
775 || walk_tree (&phi, find_va_list_reference,
776 si.va_list_vars, NULL))
778 if (dump_file && (dump_flags & TDF_DETAILS))
780 fputs ("va_list escapes in ", dump_file);
781 print_generic_expr (dump_file, phi, dump_flags);
782 fputc ('\n', dump_file);
784 va_list_escapes = true;
790 for (i = bsi_start (bb);
791 !bsi_end_p (i) && !va_list_escapes;
792 bsi_next (&i))
794 tree stmt = bsi_stmt (i);
795 tree call;
797 /* Don't look at __builtin_va_{start,end}, they are ok. */
798 call = get_call_expr_in (stmt);
799 if (call)
801 tree callee = get_callee_fndecl (call);
803 if (callee
804 && DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL
805 && (DECL_FUNCTION_CODE (callee) == BUILT_IN_VA_START
806 || DECL_FUNCTION_CODE (callee) == BUILT_IN_VA_END))
807 continue;
810 if (TREE_CODE (stmt) == MODIFY_EXPR)
812 tree lhs = TREE_OPERAND (stmt, 0);
813 tree rhs = TREE_OPERAND (stmt, 1);
815 if (TREE_CODE (rhs) == WITH_SIZE_EXPR)
816 rhs = TREE_OPERAND (rhs, 0);
818 if (va_list_simple_ptr)
820 /* Check for tem = ap. */
821 if (va_list_ptr_read (&si, rhs, lhs))
822 continue;
824 /* Check for the last insn in:
825 tem1 = ap;
826 tem2 = tem1 + CST;
827 ap = tem2;
828 sequence. */
829 else if (va_list_ptr_write (&si, lhs, rhs))
830 continue;
832 else
833 check_va_list_escapes (&si, lhs, rhs);
835 else
837 /* Check for ap[0].field = temp. */
838 if (va_list_counter_struct_op (&si, lhs, rhs, true))
839 continue;
841 /* Check for temp = ap[0].field. */
842 else if (va_list_counter_struct_op (&si, rhs, lhs, false))
843 continue;
845 /* Do any architecture specific checking. */
846 else if (targetm.stdarg_optimize_hook
847 && targetm.stdarg_optimize_hook (&si, lhs, rhs))
848 continue;
852 /* All other uses of va_list are either va_copy (that is not handled
853 in this optimization), taking address of va_list variable or
854 passing va_list to other functions (in that case va_list might
855 escape the function and therefore va_start needs to set it up
856 fully), or some unexpected use of va_list. None of these should
857 happen in a gimplified VA_ARG_EXPR. */
858 if (si.va_list_escapes
859 || walk_tree (&stmt, find_va_list_reference,
860 si.va_list_vars, NULL))
862 if (dump_file && (dump_flags & TDF_DETAILS))
864 fputs ("va_list escapes in ", dump_file);
865 print_generic_expr (dump_file, stmt, dump_flags);
866 fputc ('\n', dump_file);
868 va_list_escapes = true;
872 if (va_list_escapes)
873 break;
876 if (! va_list_escapes
877 && va_list_simple_ptr
878 && ! bitmap_empty_p (si.va_list_escape_vars)
879 && check_all_va_list_escapes (&si))
880 va_list_escapes = true;
882 finish:
883 if (va_list_escapes)
885 cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
886 cfun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;
888 BITMAP_FREE (si.va_list_vars);
889 BITMAP_FREE (si.va_list_escape_vars);
890 free (si.offsets);
891 if (dump_file)
893 fprintf (dump_file, "%s: va_list escapes %d, needs to save ",
894 funcname, (int) va_list_escapes);
895 if (cfun->va_list_gpr_size >= VA_LIST_MAX_GPR_SIZE)
896 fputs ("all", dump_file);
897 else
898 fprintf (dump_file, "%d", cfun->va_list_gpr_size);
899 fputs (" GPR units and ", dump_file);
900 if (cfun->va_list_fpr_size >= VA_LIST_MAX_FPR_SIZE)
901 fputs ("all", dump_file);
902 else
903 fprintf (dump_file, "%d", cfun->va_list_fpr_size);
904 fputs (" FPR units.\n", dump_file);
906 return 0;
910 struct tree_opt_pass pass_stdarg =
912 "stdarg", /* name */
913 gate_optimize_stdarg, /* gate */
914 execute_optimize_stdarg, /* execute */
915 NULL, /* sub */
916 NULL, /* next */
917 0, /* static_pass_number */
918 0, /* tv_id */
919 PROP_cfg | PROP_ssa | PROP_alias, /* properties_required */
920 0, /* properties_provided */
921 0, /* properties_destroyed */
922 0, /* todo_flags_start */
923 TODO_dump_func, /* todo_flags_finish */
924 0 /* letter */