gcc/combine-stack-adj.c

   1 /* Combine stack adjustments.
   2    Copyright (C) 1987-2014 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 /* Track stack adjustments and stack memory references.  Attempt to
  21    reduce the number of stack adjustments by back-propagating across
  22    the memory references.
  23
  24    This is intended primarily for use with targets that do not define
  25    ACCUMULATE_OUTGOING_ARGS.  It is of significantly more value to
  26    targets that define PREFERRED_STACK_BOUNDARY more aligned than
  27    STACK_BOUNDARY (e.g. x86), or if not all registers can be pushed
  28    (e.g. x86 fp regs) which would ordinarily have to be implemented
  29    as a sub/mov pair due to restrictions in calls.c.
  30
  31    Propagation stops when any of the insns that need adjusting are
  32    (a) no longer valid because we've exceeded their range, (b) a
  33    non-trivial push instruction, or (c) a call instruction.
  34
  35    Restriction B is based on the assumption that push instructions
  36    are smaller or faster.  If a port really wants to remove all
  37    pushes, it should have defined ACCUMULATE_OUTGOING_ARGS.  The
  38    one exception that is made is for an add immediately followed
  39    by a push.  */
  40
  41 #include "config.h"
  42 #include "system.h"
  43 #include "coretypes.h"
  44 #include "tm.h"
  45 #include "rtl.h"
  46 #include "tm_p.h"
  47 #include "insn-config.h"
  48 #include "recog.h"
  49 #include "regs.h"
  50 #include "hard-reg-set.h"
  51 #include "flags.h"
  52 #include "function.h"
  53 #include "expr.h"
  54 #include "basic-block.h"
  55 #include "df.h"
  56 #include "except.h"
  57 #include "reload.h"
  58 #include "tree-pass.h"
  59
  60 \f
  61 /* Turn STACK_GROWS_DOWNWARD into a boolean.  */
  62 #ifdef STACK_GROWS_DOWNWARD
  63 #undef STACK_GROWS_DOWNWARD
  64 #define STACK_GROWS_DOWNWARD 1
  65 #else
  66 #define STACK_GROWS_DOWNWARD 0
  67 #endif
  68
  69 /* This structure records two kinds of stack references between stack
  70    adjusting instructions: stack references in memory addresses for
  71    regular insns and all stack references for debug insns.  */
  72
  73 struct csa_reflist
  74 {
  75   HOST_WIDE_INT sp_offset;
  76   rtx_insn *insn;
  77   rtx *ref;
  78   struct csa_reflist *next;
  79 };
  80
  81 static int stack_memref_p (rtx);
  82 static rtx single_set_for_csa (rtx_insn *);
  83 static void free_csa_reflist (struct csa_reflist *);
  84 static struct csa_reflist *record_one_stack_ref (rtx_insn *, rtx *,
  85                                                  struct csa_reflist *);
  86 static int try_apply_stack_adjustment (rtx_insn *, struct csa_reflist *,
  87                                        HOST_WIDE_INT, HOST_WIDE_INT);
  88 static void combine_stack_adjustments_for_block (basic_block);
  89 static int record_stack_refs (rtx *, void *);
  90
  91
  92 /* Main entry point for stack adjustment combination.  */
  93
  94 static void
  95 combine_stack_adjustments (void)
  96 {
  97   basic_block bb;
  98
  99   FOR_EACH_BB_FN (bb, cfun)
 100     combine_stack_adjustments_for_block (bb);
 101 }
 102
 103 /* Recognize a MEM of the form (sp) or (plus sp const).  */
 104
 105 static int
 106 stack_memref_p (rtx x)
 107 {
 108   if (!MEM_P (x))
 109     return 0;
 110   x = XEXP (x, 0);
 111
 112   if (x == stack_pointer_rtx)
 113     return 1;
 114   if (GET_CODE (x) == PLUS
 115       && XEXP (x, 0) == stack_pointer_rtx
 116       && CONST_INT_P (XEXP (x, 1)))
 117     return 1;
 118
 119   return 0;
 120 }
 121
 122 /* Recognize either normal single_set or the hack in i386.md for
 123    tying fp and sp adjustments.  */
 124
 125 static rtx
 126 single_set_for_csa (rtx_insn *insn)
 127 {
 128   int i;
 129   rtx tmp = single_set (insn);
 130   if (tmp)
 131     return tmp;
 132
 133   if (!NONJUMP_INSN_P (insn)
 134       || GET_CODE (PATTERN (insn)) != PARALLEL)
 135     return NULL_RTX;
 136
 137   tmp = PATTERN (insn);
 138   if (GET_CODE (XVECEXP (tmp, 0, 0)) != SET)
 139     return NULL_RTX;
 140
 141   for (i = 1; i < XVECLEN (tmp, 0); ++i)
 142     {
 143       rtx this_rtx = XVECEXP (tmp, 0, i);
 144
 145       /* The special case is allowing a no-op set.  */
 146       if (GET_CODE (this_rtx) == SET
 147           && SET_SRC (this_rtx) == SET_DEST (this_rtx))
 148         ;
 149       else if (GET_CODE (this_rtx) != CLOBBER
 150                && GET_CODE (this_rtx) != USE)
 151         return NULL_RTX;
 152     }
 153
 154   return XVECEXP (tmp, 0, 0);
 155 }
 156
 157 /* Free the list of csa_reflist nodes.  */
 158
 159 static void
 160 free_csa_reflist (struct csa_reflist *reflist)
 161 {
 162   struct csa_reflist *next;
 163   for (; reflist ; reflist = next)
 164     {
 165       next = reflist->next;
 166       free (reflist);
 167     }
 168 }
 169
 170 /* Create a new csa_reflist node from the given stack reference.
 171    It is already known that the reference is either a MEM satisfying the
 172    predicate stack_memref_p or a REG representing the stack pointer.  */
 173
 174 static struct csa_reflist *
 175 record_one_stack_ref (rtx_insn *insn, rtx *ref, struct csa_reflist *next_reflist)
 176 {
 177   struct csa_reflist *ml;
 178
 179   ml = XNEW (struct csa_reflist);
 180
 181   if (REG_P (*ref) || XEXP (*ref, 0) == stack_pointer_rtx)
 182     ml->sp_offset = 0;
 183   else
 184     ml->sp_offset = INTVAL (XEXP (XEXP (*ref, 0), 1));
 185
 186   ml->insn = insn;
 187   ml->ref = ref;
 188   ml->next = next_reflist;
 189
 190   return ml;
 191 }
 192
 193 /* Attempt to apply ADJUST to the stack adjusting insn INSN, as well
 194    as each of the memories and stack references in REFLIST.  Return true
 195    on success.  */
 196
 197 static int
 198 try_apply_stack_adjustment (rtx_insn *insn, struct csa_reflist *reflist,
 199                             HOST_WIDE_INT new_adjust, HOST_WIDE_INT delta)
 200 {
 201   struct csa_reflist *ml;
 202   rtx set;
 203
 204   set = single_set_for_csa (insn);
 205   if (MEM_P (SET_DEST (set)))
 206     validate_change (insn, &SET_DEST (set),
 207                      replace_equiv_address (SET_DEST (set), stack_pointer_rtx),
 208                      1);
 209   else
 210     validate_change (insn, &XEXP (SET_SRC (set), 1), GEN_INT (new_adjust), 1);
 211
 212   for (ml = reflist; ml ; ml = ml->next)
 213     {
 214       rtx new_addr = plus_constant (Pmode, stack_pointer_rtx,
 215                                     ml->sp_offset - delta);
 216       rtx new_val;
 217
 218       if (MEM_P (*ml->ref))
 219         new_val = replace_equiv_address_nv (*ml->ref, new_addr);
 220       else if (GET_MODE (*ml->ref) == GET_MODE (stack_pointer_rtx))
 221         new_val = new_addr;
 222       else
 223         new_val = lowpart_subreg (GET_MODE (*ml->ref), new_addr,
 224                                   GET_MODE (new_addr));
 225       validate_change (ml->insn, ml->ref, new_val, 1);
 226     }
 227
 228   if (apply_change_group ())
 229     {
 230       /* Succeeded.  Update our knowledge of the stack references.  */
 231       for (ml = reflist; ml ; ml = ml->next)
 232         ml->sp_offset -= delta;
 233
 234       return 1;
 235     }
 236   else
 237     return 0;
 238 }
 239
 240 /* Called via for_each_rtx and used to record all stack memory and other
 241    references in the insn and discard all other stack pointer references.  */
 242 struct record_stack_refs_data
 243 {
 244   rtx_insn *insn;
 245   struct csa_reflist *reflist;
 246 };
 247
 248 static int
 249 record_stack_refs (rtx *xp, void *data)
 250 {
 251   rtx x = *xp;
 252   struct record_stack_refs_data *d =
 253     (struct record_stack_refs_data *) data;
 254   if (!x)
 255     return 0;
 256   switch (GET_CODE (x))
 257     {
 258     case MEM:
 259       if (!reg_mentioned_p (stack_pointer_rtx, x))
 260         return -1;
 261       /* We are not able to handle correctly all possible memrefs containing
 262          stack pointer, so this check is necessary.  */
 263       if (stack_memref_p (x))
 264         {
 265           d->reflist = record_one_stack_ref (d->insn, xp, d->reflist);
 266           return -1;
 267         }
 268       /* Try harder for DEBUG_INSNs, handle e.g. (mem (mem (sp + 16) + 4).  */
 269       return !DEBUG_INSN_P (d->insn);
 270     case REG:
 271       /* ??? We want be able to handle non-memory stack pointer
 272          references later.  For now just discard all insns referring to
 273          stack pointer outside mem expressions.  We would probably
 274          want to teach validate_replace to simplify expressions first.
 275
 276          We can't just compare with STACK_POINTER_RTX because the
 277          reference to the stack pointer might be in some other mode.
 278          In particular, an explicit clobber in an asm statement will
 279          result in a QImode clobber.
 280
 281          In DEBUG_INSNs, we want to replace all occurrences, otherwise
 282          they will cause -fcompare-debug failures.  */
 283       if (REGNO (x) == STACK_POINTER_REGNUM)
 284         {
 285           if (!DEBUG_INSN_P (d->insn))
 286             return 1;
 287           d->reflist = record_one_stack_ref (d->insn, xp, d->reflist);
 288           return -1;
 289         }
 290       break;
 291     default:
 292       break;
 293     }
 294   return 0;
 295 }
 296
 297 /* If INSN has a REG_ARGS_SIZE note, move it to LAST.
 298    AFTER is true iff LAST follows INSN in the instruction stream.  */
 299
 300 static void
 301 maybe_move_args_size_note (rtx_insn *last, rtx_insn *insn, bool after)
 302 {
 303   rtx note, last_note;
 304
 305   note = find_reg_note (insn, REG_ARGS_SIZE, NULL_RTX);
 306   if (note == NULL)
 307     return;
 308
 309   last_note = find_reg_note (last, REG_ARGS_SIZE, NULL_RTX);
 310   if (last_note)
 311     {
 312       /* The ARGS_SIZE notes are *not* cumulative.  They represent an
 313          absolute value, and the "most recent" note wins.  */
 314       if (!after)
 315         XEXP (last_note, 0) = XEXP (note, 0);
 316     }
 317   else
 318     add_reg_note (last, REG_ARGS_SIZE, XEXP (note, 0));
 319 }
 320
 321 /* Return the next (or previous) active insn within BB.  */
 322
 323 static rtx_insn *
 324 prev_active_insn_bb (basic_block bb, rtx_insn *insn)
 325 {
 326   for (insn = PREV_INSN (insn);
 327        insn != PREV_INSN (BB_HEAD (bb));
 328        insn = PREV_INSN (insn))
 329     if (active_insn_p (insn))
 330       return insn;
 331   return NULL;
 332 }
 333
 334 static rtx_insn *
 335 next_active_insn_bb (basic_block bb, rtx_insn *insn)
 336 {
 337   for (insn = NEXT_INSN (insn);
 338        insn != NEXT_INSN (BB_END (bb));
 339        insn = NEXT_INSN (insn))
 340     if (active_insn_p (insn))
 341       return insn;
 342   return NULL;
 343 }
 344
 345 /* If INSN has a REG_ARGS_SIZE note, if possible move it to PREV.  Otherwise
 346    search for a nearby candidate within BB where we can stick the note.  */
 347
 348 static void
 349 force_move_args_size_note (basic_block bb, rtx_insn *prev, rtx_insn *insn)
 350 {
 351   rtx note;
 352   rtx_insn *test, *next_candidate, *prev_candidate;
 353
 354   /* If PREV exists, tail-call to the logic in the other function.  */
 355   if (prev)
 356     {
 357       maybe_move_args_size_note (prev, insn, false);
 358       return;
 359     }
 360
 361   /* First, make sure there's anything that needs doing.  */
 362   note = find_reg_note (insn, REG_ARGS_SIZE, NULL_RTX);
 363   if (note == NULL)
 364     return;
 365
 366   /* We need to find a spot between the previous and next exception points
 367      where we can place the note and "properly" deallocate the arguments.  */
 368   next_candidate = prev_candidate = NULL;
 369
 370   /* It is often the case that we have insns in the order:
 371         call
 372         add sp (previous deallocation)
 373         sub sp (align for next arglist)
 374         push arg
 375      and the add/sub cancel.  Therefore we begin by searching forward.  */
 376
 377   test = insn;
 378   while ((test = next_active_insn_bb (bb, test)) != NULL)
 379     {
 380       /* Found an existing note: nothing to do.  */
 381       if (find_reg_note (test, REG_ARGS_SIZE, NULL_RTX))
 382         return;
 383       /* Found something that affects unwinding.  Stop searching.  */
 384       if (CALL_P (test) || !insn_nothrow_p (test))
 385         break;
 386       if (next_candidate == NULL)
 387         next_candidate = test;
 388     }
 389
 390   test = insn;
 391   while ((test = prev_active_insn_bb (bb, test)) != NULL)
 392     {
 393       rtx tnote;
 394       /* Found a place that seems logical to adjust the stack.  */
 395       tnote = find_reg_note (test, REG_ARGS_SIZE, NULL_RTX);
 396       if (tnote)
 397         {
 398           XEXP (tnote, 0) = XEXP (note, 0);
 399           return;
 400         }
 401       if (prev_candidate == NULL)
 402         prev_candidate = test;
 403       /* Found something that affects unwinding.  Stop searching.  */
 404       if (CALL_P (test) || !insn_nothrow_p (test))
 405         break;
 406     }
 407
 408   if (prev_candidate)
 409     test = prev_candidate;
 410   else if (next_candidate)
 411     test = next_candidate;
 412   else
 413     {
 414       /* ??? We *must* have a place, lest we ICE on the lost adjustment.
 415          Options are: dummy clobber insn, nop, or prevent the removal of
 416          the sp += 0 insn.  */
 417       /* TODO: Find another way to indicate to the dwarf2 code that we
 418          have not in fact lost an adjustment.  */
 419       test = emit_insn_before (gen_rtx_CLOBBER (VOIDmode, const0_rtx), insn);
 420     }
 421   add_reg_note (test, REG_ARGS_SIZE, XEXP (note, 0));
 422 }
 423
 424 /* Subroutine of combine_stack_adjustments, called for each basic block.  */
 425
 426 static void
 427 combine_stack_adjustments_for_block (basic_block bb)
 428 {
 429   HOST_WIDE_INT last_sp_adjust = 0;
 430   rtx_insn *last_sp_set = NULL;
 431   rtx_insn *last2_sp_set = NULL;
 432   struct csa_reflist *reflist = NULL;
 433   rtx_insn *insn, *next;
 434   rtx set;
 435   struct record_stack_refs_data data;
 436   bool end_of_block = false;
 437
 438   for (insn = BB_HEAD (bb); !end_of_block ; insn = next)
 439     {
 440       end_of_block = insn == BB_END (bb);
 441       next = NEXT_INSN (insn);
 442
 443       if (! INSN_P (insn))
 444         continue;
 445
 446       set = single_set_for_csa (insn);
 447       if (set)
 448         {
 449           rtx dest = SET_DEST (set);
 450           rtx src = SET_SRC (set);
 451
 452           /* Find constant additions to the stack pointer.  */
 453           if (dest == stack_pointer_rtx
 454               && GET_CODE (src) == PLUS
 455               && XEXP (src, 0) == stack_pointer_rtx
 456               && CONST_INT_P (XEXP (src, 1)))
 457             {
 458               HOST_WIDE_INT this_adjust = INTVAL (XEXP (src, 1));
 459
 460               /* If we've not seen an adjustment previously, record
 461                  it now and continue.  */
 462               if (! last_sp_set)
 463                 {
 464                   last_sp_set = insn;
 465                   last_sp_adjust = this_adjust;
 466                   continue;
 467                 }
 468
 469               /* If not all recorded refs can be adjusted, or the
 470                  adjustment is now too large for a constant addition,
 471                  we cannot merge the two stack adjustments.
 472
 473                  Also we need to be careful to not move stack pointer
 474                  such that we create stack accesses outside the allocated
 475                  area.  We can combine an allocation into the first insn,
 476                  or a deallocation into the second insn.  We can not
 477                  combine an allocation followed by a deallocation.
 478
 479                  The only somewhat frequent occurrence of the later is when
 480                  a function allocates a stack frame but does not use it.
 481                  For this case, we would need to analyze rtl stream to be
 482                  sure that allocated area is really unused.  This means not
 483                  only checking the memory references, but also all registers
 484                  or global memory references possibly containing a stack
 485                  frame address.
 486
 487                  Perhaps the best way to address this problem is to teach
 488                  gcc not to allocate stack for objects never used.  */
 489
 490               /* Combine an allocation into the first instruction.  */
 491               if (STACK_GROWS_DOWNWARD ? this_adjust <= 0 : this_adjust >= 0)
 492                 {
 493                   if (try_apply_stack_adjustment (last_sp_set, reflist,
 494                                                   last_sp_adjust + this_adjust,
 495                                                   this_adjust))
 496                     {
 497                       /* It worked!  */
 498                       maybe_move_args_size_note (last_sp_set, insn, false);
 499                       delete_insn (insn);
 500                       last_sp_adjust += this_adjust;
 501                       continue;
 502                     }
 503                 }
 504
 505               /* Otherwise we have a deallocation.  Do not combine with
 506                  a previous allocation.  Combine into the second insn.  */
 507               else if (STACK_GROWS_DOWNWARD
 508                        ? last_sp_adjust >= 0 : last_sp_adjust <= 0)
 509                 {
 510                   if (try_apply_stack_adjustment (insn, reflist,
 511                                                   last_sp_adjust + this_adjust,
 512                                                   -last_sp_adjust))
 513                     {
 514                       /* It worked!  */
 515                       maybe_move_args_size_note (insn, last_sp_set, true);
 516                       delete_insn (last_sp_set);
 517                       last_sp_set = insn;
 518                       last_sp_adjust += this_adjust;
 519                       free_csa_reflist (reflist);
 520                       reflist = NULL;
 521                       continue;
 522                     }
 523                 }
 524
 525               /* Combination failed.  Restart processing from here.  If
 526                  deallocation+allocation conspired to cancel, we can
 527                  delete the old deallocation insn.  */
 528               if (last_sp_set)
 529                 {
 530                   if (last_sp_adjust == 0)
 531                     {
 532                       maybe_move_args_size_note (insn, last_sp_set, true);
 533                       delete_insn (last_sp_set);
 534                     }
 535                   else
 536                     last2_sp_set = last_sp_set;
 537                 }
 538               free_csa_reflist (reflist);
 539               reflist = NULL;
 540               last_sp_set = insn;
 541               last_sp_adjust = this_adjust;
 542               continue;
 543             }
 544
 545           /* Find a store with pre-(dec|inc)rement or pre-modify of exactly
 546              the previous adjustment and turn it into a simple store.  This
 547              is equivalent to anticipating the stack adjustment so this must
 548              be an allocation.  */
 549           if (MEM_P (dest)
 550               && ((STACK_GROWS_DOWNWARD
 551                    ? (GET_CODE (XEXP (dest, 0)) == PRE_DEC
 552                       && last_sp_adjust
 553                          == (HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (dest)))
 554                    : (GET_CODE (XEXP (dest, 0)) == PRE_INC
 555                       && last_sp_adjust
 556                          == -(HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (dest))))
 557                   || ((STACK_GROWS_DOWNWARD
 558                        ? last_sp_adjust >= 0 : last_sp_adjust <= 0)
 559                       && GET_CODE (XEXP (dest, 0)) == PRE_MODIFY
 560                       && GET_CODE (XEXP (XEXP (dest, 0), 1)) == PLUS
 561                       && XEXP (XEXP (XEXP (dest, 0), 1), 0)
 562                          == stack_pointer_rtx
 563                       && GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
 564                          == CONST_INT
 565                       && INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1))
 566                          == -last_sp_adjust))
 567               && XEXP (XEXP (dest, 0), 0) == stack_pointer_rtx
 568               && !reg_mentioned_p (stack_pointer_rtx, src)
 569               && memory_address_p (GET_MODE (dest), stack_pointer_rtx)
 570               && try_apply_stack_adjustment (insn, reflist, 0,
 571                                              -last_sp_adjust))
 572             {
 573               if (last2_sp_set)
 574                 maybe_move_args_size_note (last2_sp_set, last_sp_set, false);
 575               else
 576                 maybe_move_args_size_note (insn, last_sp_set, true);
 577               delete_insn (last_sp_set);
 578               free_csa_reflist (reflist);
 579               reflist = NULL;
 580               last_sp_set = NULL;
 581               last_sp_adjust = 0;
 582               continue;
 583             }
 584         }
 585
 586       data.insn = insn;
 587       data.reflist = reflist;
 588       if (!CALL_P (insn) && last_sp_set
 589           && !for_each_rtx (&PATTERN (insn), record_stack_refs, &data))
 590         {
 591            reflist = data.reflist;
 592            continue;
 593         }
 594       reflist = data.reflist;
 595
 596       /* Otherwise, we were not able to process the instruction.
 597          Do not continue collecting data across such a one.  */
 598       if (last_sp_set
 599           && (CALL_P (insn)
 600               || reg_mentioned_p (stack_pointer_rtx, PATTERN (insn))))
 601         {
 602           if (last_sp_set && last_sp_adjust == 0)
 603             {
 604               force_move_args_size_note (bb, last2_sp_set, last_sp_set);
 605               delete_insn (last_sp_set);
 606             }
 607           free_csa_reflist (reflist);
 608           reflist = NULL;
 609           last2_sp_set = NULL;
 610           last_sp_set = NULL;
 611           last_sp_adjust = 0;
 612         }
 613     }
 614
 615   if (last_sp_set && last_sp_adjust == 0)
 616     {
 617       force_move_args_size_note (bb, last2_sp_set, last_sp_set);
 618       delete_insn (last_sp_set);
 619     }
 620
 621   if (reflist)
 622     free_csa_reflist (reflist);
 623 }
 624 \f
 625 static unsigned int
 626 rest_of_handle_stack_adjustments (void)
 627 {
 628   df_note_add_problem ();
 629   df_analyze ();
 630   combine_stack_adjustments ();
 631   return 0;
 632 }
 633
 634 namespace {
 635
 636 const pass_data pass_data_stack_adjustments =
 637 {
 638   RTL_PASS, /* type */
 639   "csa", /* name */
 640   OPTGROUP_NONE, /* optinfo_flags */
 641   TV_COMBINE_STACK_ADJUST, /* tv_id */
 642   0, /* properties_required */
 643   0, /* properties_provided */
 644   0, /* properties_destroyed */
 645   0, /* todo_flags_start */
 646   TODO_df_finish, /* todo_flags_finish */
 647 };
 648
 649 class pass_stack_adjustments : public rtl_opt_pass
 650 {
 651 public:
 652   pass_stack_adjustments (gcc::context *ctxt)
 653     : rtl_opt_pass (pass_data_stack_adjustments, ctxt)
 654   {}
 655
 656   /* opt_pass methods: */
 657   virtual bool gate (function *);
 658   virtual unsigned int execute (function *)
 659     {
 660       return rest_of_handle_stack_adjustments ();
 661     }
 662
 663 }; // class pass_stack_adjustments
 664
 665 bool
 666 pass_stack_adjustments::gate (function *)
 667 {
 668   /* This is kind of a heuristic.  We need to run combine_stack_adjustments
 669      even for machines with possibly nonzero TARGET_RETURN_POPS_ARGS
 670      and ACCUMULATE_OUTGOING_ARGS.  We expect that only ports having
 671      push instructions will have popping returns.  */
 672 #ifndef PUSH_ROUNDING
 673   if (ACCUMULATE_OUTGOING_ARGS)
 674     return false;
 675 #endif
 676   return flag_combine_stack_adjustments;
 677 }
 678
 679 } // anon namespace
 680
 681 rtl_opt_pass *
 682 make_pass_stack_adjustments (gcc::context *ctxt)
 683 {
 684   return new pass_stack_adjustments (ctxt);
 685 }