gcc/combine-stack-adj.c

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