gcc/combine-stack-adj.c

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