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