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