1 /* Pass computing data for optimizing stdarg functions. 2 Copyright (C) 2004, 2005, 2007, 2008, 2009 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 if (is_gimple_debug (stmt)) 500 continue; 501 502 FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_ALL_USES) 503 { 504 if (! bitmap_bit_p (si->va_list_escape_vars, 505 DECL_UID (SSA_NAME_VAR (use)))) 506 continue; 507 508 if (is_gimple_assign (stmt)) 509 { 510 tree rhs = gimple_assign_rhs1 (stmt); 511 enum tree_code rhs_code = gimple_assign_rhs_code (stmt); 512 513 /* x = *ap_temp; */ 514 if (gimple_assign_rhs_code (stmt) == INDIRECT_REF 515 && TREE_OPERAND (rhs, 0) == use 516 && TYPE_SIZE_UNIT (TREE_TYPE (rhs)) 517 && host_integerp (TYPE_SIZE_UNIT (TREE_TYPE (rhs)), 1) 518 && si->offsets[SSA_NAME_VERSION (use)] != -1) 519 { 520 unsigned HOST_WIDE_INT gpr_size; 521 tree access_size = TYPE_SIZE_UNIT (TREE_TYPE (rhs)); 522 523 gpr_size = si->offsets[SSA_NAME_VERSION (use)] 524 + tree_low_cst (access_size, 1); 525 if (gpr_size >= VA_LIST_MAX_GPR_SIZE) 526 cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE; 527 else if (gpr_size > cfun->va_list_gpr_size) 528 cfun->va_list_gpr_size = gpr_size; 529 continue; 530 } 531 532 /* va_arg sequences may contain 533 other_ap_temp = ap_temp; 534 other_ap_temp = ap_temp + constant; 535 other_ap_temp = (some_type *) ap_temp; 536 ap = ap_temp; 537 statements. */ 538 if (rhs == use 539 && ((rhs_code == POINTER_PLUS_EXPR 540 && (TREE_CODE (gimple_assign_rhs2 (stmt)) 541 == INTEGER_CST)) 542 || gimple_assign_cast_p (stmt) 543 || (get_gimple_rhs_class (rhs_code) 544 == GIMPLE_SINGLE_RHS))) 545 { 546 tree lhs = gimple_assign_lhs (stmt); 547 548 if (TREE_CODE (lhs) == SSA_NAME 549 && bitmap_bit_p (si->va_list_escape_vars, 550 DECL_UID (SSA_NAME_VAR (lhs)))) 551 continue; 552 553 if (TREE_CODE (lhs) == VAR_DECL 554 && bitmap_bit_p (si->va_list_vars, 555 DECL_UID (lhs))) 556 continue; 557 } 558 } 559 560 if (dump_file && (dump_flags & TDF_DETAILS)) 561 { 562 fputs ("va_list escapes in ", dump_file); 563 print_gimple_stmt (dump_file, stmt, 0, dump_flags); 564 fputc ('\n', dump_file); 565 } 566 return true; 567 } 568 } 569 } 570 571 return false; 572 } 573 574 575 /* Return true if this optimization pass should be done. 576 It makes only sense for stdarg functions. */ 577 578 static bool 579 gate_optimize_stdarg (void) 580 { 581 /* This optimization is only for stdarg functions. */ 582 return cfun->stdarg != 0; 583 } 584 585 586 /* Entry point to the stdarg optimization pass. */ 587 588 static unsigned int 589 execute_optimize_stdarg (void) 590 { 591 basic_block bb; 592 bool va_list_escapes = false; 593 bool va_list_simple_ptr; 594 struct stdarg_info si; 595 struct walk_stmt_info wi; 596 const char *funcname = NULL; 597 tree cfun_va_list; 598 599 cfun->va_list_gpr_size = 0; 600 cfun->va_list_fpr_size = 0; 601 memset (&si, 0, sizeof (si)); 602 si.va_list_vars = BITMAP_ALLOC (NULL); 603 si.va_list_escape_vars = BITMAP_ALLOC (NULL); 604 605 if (dump_file) 606 funcname = lang_hooks.decl_printable_name (current_function_decl, 2); 607 608 cfun_va_list = targetm.fn_abi_va_list (cfun->decl); 609 va_list_simple_ptr = POINTER_TYPE_P (cfun_va_list) 610 && (TREE_TYPE (cfun_va_list) == void_type_node 611 || TREE_TYPE (cfun_va_list) == char_type_node); 612 gcc_assert (is_gimple_reg_type (cfun_va_list) == va_list_simple_ptr); 613 614 FOR_EACH_BB (bb) 615 { 616 gimple_stmt_iterator i; 617 618 for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i)) 619 { 620 gimple stmt = gsi_stmt (i); 621 tree callee, ap; 622 623 if (!is_gimple_call (stmt)) 624 continue; 625 626 callee = gimple_call_fndecl (stmt); 627 if (!callee 628 || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL) 629 continue; 630 631 switch (DECL_FUNCTION_CODE (callee)) 632 { 633 case BUILT_IN_VA_START: 634 break; 635 /* If old style builtins are used, don't optimize anything. */ 636 case BUILT_IN_SAVEREGS: 637 case BUILT_IN_ARGS_INFO: 638 case BUILT_IN_NEXT_ARG: 639 va_list_escapes = true; 640 continue; 641 default: 642 continue; 643 } 644 645 si.va_start_count++; 646 ap = gimple_call_arg (stmt, 0); 647 648 if (TREE_CODE (ap) != ADDR_EXPR) 649 { 650 va_list_escapes = true; 651 break; 652 } 653 ap = TREE_OPERAND (ap, 0); 654 if (TREE_CODE (ap) == ARRAY_REF) 655 { 656 if (! integer_zerop (TREE_OPERAND (ap, 1))) 657 { 658 va_list_escapes = true; 659 break; 660 } 661 ap = TREE_OPERAND (ap, 0); 662 } 663 if (TYPE_MAIN_VARIANT (TREE_TYPE (ap)) 664 != TYPE_MAIN_VARIANT (targetm.fn_abi_va_list (cfun->decl)) 665 || TREE_CODE (ap) != VAR_DECL) 666 { 667 va_list_escapes = true; 668 break; 669 } 670 671 if (is_global_var (ap)) 672 { 673 va_list_escapes = true; 674 break; 675 } 676 677 bitmap_set_bit (si.va_list_vars, DECL_UID (ap)); 678 679 /* VA_START_BB and VA_START_AP will be only used if there is just 680 one va_start in the function. */ 681 si.va_start_bb = bb; 682 si.va_start_ap = ap; 683 } 684 685 if (va_list_escapes) 686 break; 687 } 688 689 /* If there were no va_start uses in the function, there is no need to 690 save anything. */ 691 if (si.va_start_count == 0) 692 goto finish; 693 694 /* If some va_list arguments weren't local, we can't optimize. */ 695 if (va_list_escapes) 696 goto finish; 697 698 /* For void * or char * va_list, something useful can be done only 699 if there is just one va_start. */ 700 if (va_list_simple_ptr && si.va_start_count > 1) 701 { 702 va_list_escapes = true; 703 goto finish; 704 } 705 706 /* For struct * va_list, if the backend didn't tell us what the counter fields 707 are, there is nothing more we can do. */ 708 if (!va_list_simple_ptr 709 && va_list_gpr_counter_field == NULL_TREE 710 && va_list_fpr_counter_field == NULL_TREE) 711 { 712 va_list_escapes = true; 713 goto finish; 714 } 715 716 /* For void * or char * va_list there is just one counter 717 (va_list itself). Use VA_LIST_GPR_SIZE for it. */ 718 if (va_list_simple_ptr) 719 cfun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE; 720 721 calculate_dominance_info (CDI_DOMINATORS); 722 memset (&wi, 0, sizeof (wi)); 723 wi.info = si.va_list_vars; 724 725 FOR_EACH_BB (bb) 726 { 727 gimple_stmt_iterator i; 728 729 si.compute_sizes = -1; 730 si.bb = bb; 731 732 /* For va_list_simple_ptr, we have to check PHI nodes too. We treat 733 them as assignments for the purpose of escape analysis. This is 734 not needed for non-simple va_list because virtual phis don't perform 735 any real data movement. */ 736 if (va_list_simple_ptr) 737 { 738 tree lhs, rhs; 739 use_operand_p uop; 740 ssa_op_iter soi; 741 742 for (i = gsi_start_phis (bb); !gsi_end_p (i); gsi_next (&i)) 743 { 744 gimple phi = gsi_stmt (i); 745 lhs = PHI_RESULT (phi); 746 747 if (!is_gimple_reg (lhs)) 748 continue; 749 750 FOR_EACH_PHI_ARG (uop, phi, soi, SSA_OP_USE) 751 { 752 rhs = USE_FROM_PTR (uop); 753 if (va_list_ptr_read (&si, rhs, lhs)) 754 continue; 755 else if (va_list_ptr_write (&si, lhs, rhs)) 756 continue; 757 else 758 check_va_list_escapes (&si, lhs, rhs); 759 760 if (si.va_list_escapes) 761 { 762 if (dump_file && (dump_flags & TDF_DETAILS)) 763 { 764 fputs ("va_list escapes in ", dump_file); 765 print_gimple_stmt (dump_file, phi, 0, dump_flags); 766 fputc ('\n', dump_file); 767 } 768 va_list_escapes = true; 769 } 770 } 771 } 772 } 773 774 for (i = gsi_start_bb (bb); 775 !gsi_end_p (i) && !va_list_escapes; 776 gsi_next (&i)) 777 { 778 gimple stmt = gsi_stmt (i); 779 780 /* Don't look at __builtin_va_{start,end}, they are ok. */ 781 if (is_gimple_call (stmt)) 782 { 783 tree callee = gimple_call_fndecl (stmt); 784 785 if (callee 786 && DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL 787 && (DECL_FUNCTION_CODE (callee) == BUILT_IN_VA_START 788 || DECL_FUNCTION_CODE (callee) == BUILT_IN_VA_END)) 789 continue; 790 } 791 792 if (is_gimple_assign (stmt)) 793 { 794 tree lhs = gimple_assign_lhs (stmt); 795 tree rhs = gimple_assign_rhs1 (stmt); 796 797 if (va_list_simple_ptr) 798 { 799 if (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)) 800 == GIMPLE_SINGLE_RHS) 801 { 802 /* Check for tem = ap. */ 803 if (va_list_ptr_read (&si, rhs, lhs)) 804 continue; 805 806 /* Check for the last insn in: 807 tem1 = ap; 808 tem2 = tem1 + CST; 809 ap = tem2; 810 sequence. */ 811 else if (va_list_ptr_write (&si, lhs, rhs)) 812 continue; 813 } 814 815 if ((gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR 816 && TREE_CODE (gimple_assign_rhs2 (stmt)) == INTEGER_CST) 817 || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt)) 818 || (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)) 819 == GIMPLE_SINGLE_RHS)) 820 check_va_list_escapes (&si, lhs, rhs); 821 } 822 else 823 { 824 if (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)) 825 == GIMPLE_SINGLE_RHS) 826 { 827 /* Check for ap[0].field = temp. */ 828 if (va_list_counter_struct_op (&si, lhs, rhs, true)) 829 continue; 830 831 /* Check for temp = ap[0].field. */ 832 else if (va_list_counter_struct_op (&si, rhs, lhs, 833 false)) 834 continue; 835 } 836 837 /* Do any architecture specific checking. */ 838 if (targetm.stdarg_optimize_hook 839 && targetm.stdarg_optimize_hook (&si, stmt)) 840 continue; 841 } 842 } 843 else if (is_gimple_debug (stmt)) 844 continue; 845 846 /* All other uses of va_list are either va_copy (that is not handled 847 in this optimization), taking address of va_list variable or 848 passing va_list to other functions (in that case va_list might 849 escape the function and therefore va_start needs to set it up 850 fully), or some unexpected use of va_list. None of these should 851 happen in a gimplified VA_ARG_EXPR. */ 852 if (si.va_list_escapes 853 || walk_gimple_op (stmt, find_va_list_reference, &wi)) 854 { 855 if (dump_file && (dump_flags & TDF_DETAILS)) 856 { 857 fputs ("va_list escapes in ", dump_file); 858 print_gimple_stmt (dump_file, stmt, 0, dump_flags); 859 fputc ('\n', dump_file); 860 } 861 va_list_escapes = true; 862 } 863 } 864 865 if (va_list_escapes) 866 break; 867 } 868 869 if (! va_list_escapes 870 && va_list_simple_ptr 871 && ! bitmap_empty_p (si.va_list_escape_vars) 872 && check_all_va_list_escapes (&si)) 873 va_list_escapes = true; 874 875 finish: 876 if (va_list_escapes) 877 { 878 cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE; 879 cfun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE; 880 } 881 BITMAP_FREE (si.va_list_vars); 882 BITMAP_FREE (si.va_list_escape_vars); 883 free (si.offsets); 884 if (dump_file) 885 { 886 fprintf (dump_file, "%s: va_list escapes %d, needs to save ", 887 funcname, (int) va_list_escapes); 888 if (cfun->va_list_gpr_size >= VA_LIST_MAX_GPR_SIZE) 889 fputs ("all", dump_file); 890 else 891 fprintf (dump_file, "%d", cfun->va_list_gpr_size); 892 fputs (" GPR units and ", dump_file); 893 if (cfun->va_list_fpr_size >= VA_LIST_MAX_FPR_SIZE) 894 fputs ("all", dump_file); 895 else 896 fprintf (dump_file, "%d", cfun->va_list_fpr_size); 897 fputs (" FPR units.\n", dump_file); 898 } 899 return 0; 900 } 901 902 903 struct gimple_opt_pass pass_stdarg = 904 { 905 { 906 GIMPLE_PASS, 907 "stdarg", /* name */ 908 gate_optimize_stdarg, /* gate */ 909 execute_optimize_stdarg, /* execute */ 910 NULL, /* sub */ 911 NULL, /* next */ 912 0, /* static_pass_number */ 913 TV_NONE, /* tv_id */ 914 PROP_cfg | PROP_ssa, /* properties_required */ 915 0, /* properties_provided */ 916 0, /* properties_destroyed */ 917 0, /* todo_flags_start */ 918 TODO_dump_func /* todo_flags_finish */ 919 } 920 }; 921