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