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