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 }