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   TV_NONE, /* tv_id */
 675   ( PROP_cfg | PROP_ssa ), /* properties_required */
 676   0, /* properties_provided */
 677   0, /* properties_destroyed */
 678   0, /* todo_flags_start */
 679   0, /* todo_flags_finish */
 680 };
 681
 682 class pass_stdarg : public gimple_opt_pass
 683 {
 684 public:
 685   pass_stdarg (gcc::context *ctxt)
 686     : gimple_opt_pass (pass_data_stdarg, ctxt)
 687   {}
 688
 689   /* opt_pass methods: */
 690   virtual bool gate (function *fun)
 691     {
 692       /* This optimization is only for stdarg functions.  */
 693       return fun->stdarg != 0;
 694     }
 695
 696   virtual unsigned int execute (function *);
 697
 698 }; // class pass_stdarg
 699
 700 unsigned int
 701 pass_stdarg::execute (function *fun)
 702 {
 703   basic_block bb;
 704   bool va_list_escapes = false;
 705   bool va_list_simple_ptr;
 706   struct stdarg_info si;
 707   struct walk_stmt_info wi;
 708   const char *funcname = NULL;
 709   tree cfun_va_list;
 710
 711   fun->va_list_gpr_size = 0;
 712   fun->va_list_fpr_size = 0;
 713   memset (&si, 0, sizeof (si));
 714   si.va_list_vars = BITMAP_ALLOC (NULL);
 715   si.va_list_escape_vars = BITMAP_ALLOC (NULL);
 716
 717   if (dump_file)
 718     funcname = lang_hooks.decl_printable_name (current_function_decl, 2);
 719
 720   cfun_va_list = targetm.fn_abi_va_list (fun->decl);
 721   va_list_simple_ptr = POINTER_TYPE_P (cfun_va_list)
 722                        && (TREE_TYPE (cfun_va_list) == void_type_node
 723                            || TREE_TYPE (cfun_va_list) == char_type_node);
 724   gcc_assert (is_gimple_reg_type (cfun_va_list) == va_list_simple_ptr);
 725
 726   FOR_EACH_BB_FN (bb, fun)
 727     {
 728       gimple_stmt_iterator i;
 729
 730       for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
 731         {
 732           gimple stmt = gsi_stmt (i);
 733           tree callee, ap;
 734
 735           if (!is_gimple_call (stmt))
 736             continue;
 737
 738           callee = gimple_call_fndecl (stmt);
 739           if (!callee
 740               || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL)
 741             continue;
 742
 743           switch (DECL_FUNCTION_CODE (callee))
 744             {
 745             case BUILT_IN_VA_START:
 746               break;
 747               /* If old style builtins are used, don't optimize anything.  */
 748             case BUILT_IN_SAVEREGS:
 749             case BUILT_IN_NEXT_ARG:
 750               va_list_escapes = true;
 751               continue;
 752             default:
 753               continue;
 754             }
 755
 756           si.va_start_count++;
 757           ap = gimple_call_arg (stmt, 0);
 758
 759           if (TREE_CODE (ap) != ADDR_EXPR)
 760             {
 761               va_list_escapes = true;
 762               break;
 763             }
 764           ap = TREE_OPERAND (ap, 0);
 765           if (TREE_CODE (ap) == ARRAY_REF)
 766             {
 767               if (! integer_zerop (TREE_OPERAND (ap, 1)))
 768                 {
 769                   va_list_escapes = true;
 770                   break;
 771                 }
 772               ap = TREE_OPERAND (ap, 0);
 773             }
 774           if (TYPE_MAIN_VARIANT (TREE_TYPE (ap))
 775               != TYPE_MAIN_VARIANT (targetm.fn_abi_va_list (fun->decl))
 776               || TREE_CODE (ap) != VAR_DECL)
 777             {
 778               va_list_escapes = true;
 779               break;
 780             }
 781
 782           if (is_global_var (ap))
 783             {
 784               va_list_escapes = true;
 785               break;
 786             }
 787
 788           bitmap_set_bit (si.va_list_vars, DECL_UID (ap) + num_ssa_names);
 789
 790           /* VA_START_BB and VA_START_AP will be only used if there is just
 791              one va_start in the function.  */
 792           si.va_start_bb = bb;
 793           si.va_start_ap = ap;
 794         }
 795
 796       if (va_list_escapes)
 797         break;
 798     }
 799
 800   /* If there were no va_start uses in the function, there is no need to
 801      save anything.  */
 802   if (si.va_start_count == 0)
 803     goto finish;
 804
 805   /* If some va_list arguments weren't local, we can't optimize.  */
 806   if (va_list_escapes)
 807     goto finish;
 808
 809   /* For void * or char * va_list, something useful can be done only
 810      if there is just one va_start.  */
 811   if (va_list_simple_ptr && si.va_start_count > 1)
 812     {
 813       va_list_escapes = true;
 814       goto finish;
 815     }
 816
 817   /* For struct * va_list, if the backend didn't tell us what the counter fields
 818      are, there is nothing more we can do.  */
 819   if (!va_list_simple_ptr
 820       && va_list_gpr_counter_field == NULL_TREE
 821       && va_list_fpr_counter_field == NULL_TREE)
 822     {
 823       va_list_escapes = true;
 824       goto finish;
 825     }
 826
 827   /* For void * or char * va_list there is just one counter
 828      (va_list itself).  Use VA_LIST_GPR_SIZE for it.  */
 829   if (va_list_simple_ptr)
 830     fun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;
 831
 832   calculate_dominance_info (CDI_DOMINATORS);
 833   memset (&wi, 0, sizeof (wi));
 834   wi.info = si.va_list_vars;
 835
 836   FOR_EACH_BB_FN (bb, fun)
 837     {
 838       gimple_stmt_iterator i;
 839
 840       si.compute_sizes = -1;
 841       si.bb = bb;
 842
 843       /* For va_list_simple_ptr, we have to check PHI nodes too.  We treat
 844          them as assignments for the purpose of escape analysis.  This is
 845          not needed for non-simple va_list because virtual phis don't perform
 846          any real data movement.  */
 847       if (va_list_simple_ptr)
 848         {
 849           tree lhs, rhs;
 850           use_operand_p uop;
 851           ssa_op_iter soi;
 852
 853           for (i = gsi_start_phis (bb); !gsi_end_p (i); gsi_next (&i))
 854             {
 855               gimple phi = gsi_stmt (i);
 856               lhs = PHI_RESULT (phi);
 857
 858               if (virtual_operand_p (lhs))
 859                 continue;
 860
 861               FOR_EACH_PHI_ARG (uop, phi, soi, SSA_OP_USE)
 862                 {
 863                   rhs = USE_FROM_PTR (uop);
 864                   if (va_list_ptr_read (&si, rhs, lhs))
 865                     continue;
 866                   else if (va_list_ptr_write (&si, lhs, rhs))
 867                     continue;
 868                   else
 869                     check_va_list_escapes (&si, lhs, rhs);
 870
 871                   if (si.va_list_escapes)
 872                     {
 873                       if (dump_file && (dump_flags & TDF_DETAILS))
 874                         {
 875                           fputs ("va_list escapes in ", dump_file);
 876                           print_gimple_stmt (dump_file, phi, 0, dump_flags);
 877                           fputc ('\n', dump_file);
 878                         }
 879                       va_list_escapes = true;
 880                     }
 881                 }
 882             }
 883         }
 884
 885       for (i = gsi_start_bb (bb);
 886            !gsi_end_p (i) && !va_list_escapes;
 887            gsi_next (&i))
 888         {
 889           gimple stmt = gsi_stmt (i);
 890
 891           /* Don't look at __builtin_va_{start,end}, they are ok.  */
 892           if (is_gimple_call (stmt))
 893             {
 894               tree callee = gimple_call_fndecl (stmt);
 895
 896               if (callee
 897                   && DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL
 898                   && (DECL_FUNCTION_CODE (callee) == BUILT_IN_VA_START
 899                       || DECL_FUNCTION_CODE (callee) == BUILT_IN_VA_END))
 900                 continue;
 901             }
 902
 903           if (is_gimple_assign (stmt))
 904             {
 905               tree lhs = gimple_assign_lhs (stmt);
 906               tree rhs = gimple_assign_rhs1 (stmt);
 907
 908               if (va_list_simple_ptr)
 909                 {
 910                   if (get_gimple_rhs_class (gimple_assign_rhs_code (stmt))
 911                       == GIMPLE_SINGLE_RHS)
 912                     {
 913                       /* Check for ap ={v} {}.  */
 914                       if (TREE_CLOBBER_P (rhs))
 915                         continue;
 916
 917                       /* Check for tem = ap.  */
 918                       else if (va_list_ptr_read (&si, rhs, lhs))
 919                         continue;
 920
 921                       /* Check for the last insn in:
 922                          tem1 = ap;
 923                          tem2 = tem1 + CST;
 924                          ap = tem2;
 925                          sequence.  */
 926                       else if (va_list_ptr_write (&si, lhs, rhs))
 927                         continue;
 928                     }
 929
 930                   if ((gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR
 931                        && TREE_CODE (gimple_assign_rhs2 (stmt)) == INTEGER_CST)
 932                       || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt))
 933                       || (get_gimple_rhs_class (gimple_assign_rhs_code (stmt))
 934                           == GIMPLE_SINGLE_RHS))
 935                     check_va_list_escapes (&si, lhs, rhs);
 936                 }
 937               else
 938                 {
 939                   if (get_gimple_rhs_class (gimple_assign_rhs_code (stmt))
 940                       == GIMPLE_SINGLE_RHS)
 941                     {
 942                       /* Check for ap ={v} {}.  */
 943                       if (TREE_CLOBBER_P (rhs))
 944                         continue;
 945
 946                       /* Check for ap[0].field = temp.  */
 947                       else if (va_list_counter_struct_op (&si, lhs, rhs, true))
 948                         continue;
 949
 950                       /* Check for temp = ap[0].field.  */
 951                       else if (va_list_counter_struct_op (&si, rhs, lhs,
 952                                                           false))
 953                         continue;
 954                     }
 955
 956                   /* Do any architecture specific checking.  */
 957                   if (targetm.stdarg_optimize_hook
 958                       && targetm.stdarg_optimize_hook (&si, stmt))
 959                     continue;
 960                 }
 961             }
 962           else if (is_gimple_debug (stmt))
 963             continue;
 964
 965           /* All other uses of va_list are either va_copy (that is not handled
 966              in this optimization), taking address of va_list variable or
 967              passing va_list to other functions (in that case va_list might
 968              escape the function and therefore va_start needs to set it up
 969              fully), or some unexpected use of va_list.  None of these should
 970              happen in a gimplified VA_ARG_EXPR.  */
 971           if (si.va_list_escapes
 972               || walk_gimple_op (stmt, find_va_list_reference, &wi))
 973             {
 974               if (dump_file && (dump_flags & TDF_DETAILS))
 975                 {
 976                   fputs ("va_list escapes in ", dump_file);
 977                   print_gimple_stmt (dump_file, stmt, 0, dump_flags);
 978                   fputc ('\n', dump_file);
 979                 }
 980               va_list_escapes = true;
 981             }
 982         }
 983
 984       if (va_list_escapes)
 985         break;
 986     }
 987
 988   if (! va_list_escapes
 989       && va_list_simple_ptr
 990       && ! bitmap_empty_p (si.va_list_escape_vars)
 991       && check_all_va_list_escapes (&si))
 992     va_list_escapes = true;
 993
 994 finish:
 995   if (va_list_escapes)
 996     {
 997       fun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
 998       fun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;
 999     }
1000   BITMAP_FREE (si.va_list_vars);
1001   BITMAP_FREE (si.va_list_escape_vars);
1002   free (si.offsets);
1003   if (dump_file)
1004     {
1005       fprintf (dump_file, "%s: va_list escapes %d, needs to save ",
1006                funcname, (int) va_list_escapes);
1007       if (fun->va_list_gpr_size >= VA_LIST_MAX_GPR_SIZE)
1008         fputs ("all", dump_file);
1009       else
1010         fprintf (dump_file, "%d", cfun->va_list_gpr_size);
1011       fputs (" GPR units and ", dump_file);
1012       if (fun->va_list_fpr_size >= VA_LIST_MAX_FPR_SIZE)
1013         fputs ("all", dump_file);
1014       else
1015         fprintf (dump_file, "%d", cfun->va_list_fpr_size);
1016       fputs (" FPR units.\n", dump_file);
1017     }
1018   return 0;
1019 }
1020
1021 } // anon namespace
1022
1023 gimple_opt_pass *
1024 make_pass_stdarg (gcc::context *ctxt)
1025 {
1026   return new pass_stdarg (ctxt);
1027 }