gcc/combine-stack-adj.c

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