procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

poly_int: PUSH_ROUNDING

Browse source 
PUSH_ROUNDING is difficult to convert to a hook since there is still
a lot of conditional code based on it.  It isn't clear that a direct
conversion with checks for null hooks is the right thing to do.

Rather than untangle that, this patch converts all implementations
that do something to out-of-line functions that have the same
interface as a hook would have.  This should at least help towards
any future hook conversion.

2018-01-03  Richard Sandiford  <richard.sandiford@linaro.org>
	    Alan Hayward  <alan.hayward@arm.com>
	    David Sherwood  <david.sherwood@arm.com>

gcc/
	* config/cr16/cr16-protos.h (cr16_push_rounding): Declare.
	* config/cr16/cr16.h (PUSH_ROUNDING): Move implementation to...
	* config/cr16/cr16.c (cr16_push_rounding): ...this new function.
	* config/h8300/h8300-protos.h (h8300_push_rounding): Declare.
	* config/h8300/h8300.h (PUSH_ROUNDING): Move implementation to...
	* config/h8300/h8300.c (h8300_push_rounding): ...this new function.
	* config/i386/i386-protos.h (ix86_push_rounding): Declare.
	* config/i386/i386.h (PUSH_ROUNDING): Move implementation to...
	* config/i386/i386.c (ix86_push_rounding): ...this new function.
	* config/m32c/m32c-protos.h (m32c_push_rounding): Take and return
	a poly_int64.
	* config/m32c/m32c.c (m32c_push_rounding): Likewise.
	* config/m68k/m68k-protos.h (m68k_push_rounding): Declare.
	* config/m68k/m68k.h (PUSH_ROUNDING): Move implementation to...
	* config/m68k/m68k.c (m68k_push_rounding): ...this new function.
	* config/pdp11/pdp11-protos.h (pdp11_push_rounding): Declare.
	* config/pdp11/pdp11.h (PUSH_ROUNDING): Move implementation to...
	* config/pdp11/pdp11.c (pdp11_push_rounding): ...this new function.
	* config/stormy16/stormy16-protos.h (xstormy16_push_rounding): Declare.
	* config/stormy16/stormy16.h (PUSH_ROUNDING): Move implementation to...
	* config/stormy16/stormy16.c (xstormy16_push_rounding): ...this new
	function.
	* expr.c (emit_move_resolve_push): Treat the input and result
	of PUSH_ROUNDING as a poly_int64.
	(emit_move_complex_push, emit_single_push_insn_1): Likewise.
	(emit_push_insn): Likewise.
	* lra-eliminations.c (mark_not_eliminable): Likewise.
	* recog.c (push_operand): Likewise.
	* reload1.c (elimination_effects): Likewise.
	* rtlanal.c (nonzero_bits1): Likewise.
	* calls.c (store_one_arg): Likewise.  Require the padding to be
	known at compile time.

Co-Authored-By: Alan Hayward <alan.hayward@arm.com>
Co-Authored-By: David Sherwood <david.sherwood@arm.com>

From-SVN: r256155
This commit is contained in:
Richard Sandiford 2018-01-03 07:18:13 +00:00 • committed by Richard Sandiford
parent a930fe5150
commit 7b4df2bf95
27 changed files with 151 additions and 68 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

37
gcc/ChangeLog
View file

@ -1,3 +1,40 @@
2018-01-03 Richard Sandiford <richard.sandiford@linaro.org>
Alan Hayward <alan.hayward@arm.com>
David Sherwood <david.sherwood@arm.com>
* config/cr16/cr16-protos.h (cr16_push_rounding): Declare.
* config/cr16/cr16.h (PUSH_ROUNDING): Move implementation to...
* config/cr16/cr16.c (cr16_push_rounding): ...this new function.
* config/h8300/h8300-protos.h (h8300_push_rounding): Declare.
* config/h8300/h8300.h (PUSH_ROUNDING): Move implementation to...
* config/h8300/h8300.c (h8300_push_rounding): ...this new function.
* config/i386/i386-protos.h (ix86_push_rounding): Declare.
* config/i386/i386.h (PUSH_ROUNDING): Move implementation to...
* config/i386/i386.c (ix86_push_rounding): ...this new function.
* config/m32c/m32c-protos.h (m32c_push_rounding): Take and return
a poly_int64.
* config/m32c/m32c.c (m32c_push_rounding): Likewise.
* config/m68k/m68k-protos.h (m68k_push_rounding): Declare.
* config/m68k/m68k.h (PUSH_ROUNDING): Move implementation to...
* config/m68k/m68k.c (m68k_push_rounding): ...this new function.
* config/pdp11/pdp11-protos.h (pdp11_push_rounding): Declare.
* config/pdp11/pdp11.h (PUSH_ROUNDING): Move implementation to...
* config/pdp11/pdp11.c (pdp11_push_rounding): ...this new function.
* config/stormy16/stormy16-protos.h (xstormy16_push_rounding): Declare.
* config/stormy16/stormy16.h (PUSH_ROUNDING): Move implementation to...
* config/stormy16/stormy16.c (xstormy16_push_rounding): ...this new
function.
* expr.c (emit_move_resolve_push): Treat the input and result
of PUSH_ROUNDING as a poly_int64.
(emit_move_complex_push, emit_single_push_insn_1): Likewise.
(emit_push_insn): Likewise.
* lra-eliminations.c (mark_not_eliminable): Likewise.
* recog.c (push_operand): Likewise.
* reload1.c (elimination_effects): Likewise.
* rtlanal.c (nonzero_bits1): Likewise.
* calls.c (store_one_arg): Likewise. Require the padding to be
known at compile time.
2018-01-03 Richard Sandiford <richard.sandiford@linaro.org>
Alan Hayward <alan.hayward@arm.com>
David Sherwood <david.sherwood@arm.com>

14
gcc/calls.c
View file

@ -5639,7 +5639,6 @@ store_one_arg (struct arg_data *arg, rtx argblock, int flags,
;
else if (arg->mode != BLKmode)
{
int size;
unsigned int parm_align;
/* Argument is a scalar, not entirely passed in registers.
@ -5652,10 +5651,8 @@ store_one_arg (struct arg_data *arg, rtx argblock, int flags,
Note that in C the default argument promotions
will prevent such mismatches. */
if (TYPE_EMPTY_P (TREE_TYPE (pval)))
size = 0;
else
size = GET_MODE_SIZE (arg->mode);
poly_int64 size = (TYPE_EMPTY_P (TREE_TYPE (pval))
? 0 : GET_MODE_SIZE (arg->mode));
/* Compute how much space the push instruction will push.
On many machines, pushing a byte will advance the stack
@ -5669,9 +5666,10 @@ store_one_arg (struct arg_data *arg, rtx argblock, int flags,
round up to a multiple of the alignment for arguments. */
if (targetm.calls.function_arg_padding (arg->mode, TREE_TYPE (pval))
!= PAD_NONE)
used = (((size + PARM_BOUNDARY / BITS_PER_UNIT - 1)
/ (PARM_BOUNDARY / BITS_PER_UNIT))
* (PARM_BOUNDARY / BITS_PER_UNIT));
/* At the moment we don't (need to) support ABIs for which the
padding isn't known at compile time. In principle it should
be easy to add though. */
used = force_align_up (size, PARM_BOUNDARY / BITS_PER_UNIT);
/* Compute the alignment of the pushed argument. */
parm_align = arg->locate.boundary;

1
gcc/config/cr16/cr16-protos.h
View file

@ -94,5 +94,6 @@ extern const char *cr16_emit_logical_di (rtx *, enum rtx_code);
/* Handling the "interrupt" attribute. */
extern int cr16_interrupt_function_p (void);
extern bool cr16_is_data_model (enum data_model_type);
extern poly_int64 cr16_push_rounding (poly_int64);
#endif /* Not GCC_CR16_PROTOS_H. */

8
gcc/config/cr16/cr16.c
View file

@ -2215,6 +2215,14 @@ cr16_emit_logical_di (rtx *operands, enum rtx_code code)
return "";
}
/* Implement PUSH_ROUNDING. */
poly_int64
cr16_push_rounding (poly_int64 bytes)
{
return (bytes + 1) & ~1;
}
/* Initialize 'targetm' variable which contains pointers to functions
and data relating to the target machine. */

2
gcc/config/cr16/cr16.h
View file

@ -381,7 +381,7 @@ enum reg_class
#define PUSH_ARGS 1
#define PUSH_ROUNDING(BYTES) (((BYTES) + 1) & ~1)
#define PUSH_ROUNDING(BYTES) cr16_push_rounding (BYTES)
#ifndef CUMULATIVE_ARGS
struct cumulative_args

1
gcc/config/h8300/h8300-protos.h
View file

@ -112,5 +112,6 @@ extern bool h8sx_mergeable_memrefs_p (rtx, rtx);
extern bool h8sx_emit_movmd (rtx, rtx, rtx, HOST_WIDE_INT);
extern void h8300_swap_into_er6 (rtx);
extern void h8300_swap_out_of_er6 (rtx);
extern poly_int64 h8300_push_rounding (poly_int64);
#endif /* ! GCC_H8300_PROTOS_H */

15
gcc/config/h8300/h8300.c
View file

@ -6044,6 +6044,21 @@ h8300_trampoline_init (rtx m_tramp, tree fndecl, rtx cxt)
emit_move_insn (mem, tem);
}
}
/* Implement PUSH_ROUNDING.
On the H8/300, @-sp really pushes a byte if you ask it to - but that's
dangerous, so we claim that it always pushes a word, then we catch
the mov.b rx,@-sp and turn it into a mov.w rx,@-sp on output.
On the H8/300H, we simplify TARGET_QUICKCALL by setting this to 4
and doing a similar thing. */
poly_int64
h8300_push_rounding (poly_int64 bytes)
{
return ((bytes + PARM_BOUNDARY / 8 - 1) & (-PARM_BOUNDARY / 8));
}
/* Initialize the GCC target structure. */
#undef TARGET_ATTRIBUTE_TABLE

13
gcc/config/h8300/h8300.h
View file

@ -352,18 +352,7 @@ enum reg_class {
#define FRAME_GROWS_DOWNWARD 1
/* If we generate an insn to push BYTES bytes,
this says how many the stack pointer really advances by.
On the H8/300, @-sp really pushes a byte if you ask it to - but that's
dangerous, so we claim that it always pushes a word, then we catch
the mov.b rx,@-sp and turn it into a mov.w rx,@-sp on output.
On the H8/300H, we simplify TARGET_QUICKCALL by setting this to 4
and doing a similar thing. */
#define PUSH_ROUNDING(BYTES) \
(((BYTES) + PARM_BOUNDARY / 8 - 1) & -PARM_BOUNDARY / 8)
#define PUSH_ROUNDING(BYTES) h8300_push_rounding (BYTES)
/* Offset of first parameter from the argument pointer register value. */
/* Is equal to the size of the saved fp + pc, even if an fp isn't

2
gcc/config/i386/i386-protos.h
View file

@ -323,6 +323,8 @@ extern void ix86_core2i7_init_hooks (void);
extern int ix86_atom_sched_reorder (FILE *, int, rtx_insn **, int *, int);
extern poly_int64 ix86_push_rounding (poly_int64);
#ifdef RTX_CODE
/* Target data for multipass lookahead scheduling.
Currently used for Core 2/i7 tuning. */

13
gcc/config/i386/i386.c
View file

@ -49964,6 +49964,19 @@ ix86_excess_precision (enum excess_precision_type type)
return FLT_EVAL_METHOD_UNPREDICTABLE;
}
/* Implement PUSH_ROUNDING. On 386, we have pushw instruction that
decrements by exactly 2 no matter what the position was, there is no pushb.
But as CIE data alignment factor on this arch is -4 for 32bit targets
and -8 for 64bit targets, we need to make sure all stack pointer adjustments
are in multiple of 4 for 32bit targets and 8 for 64bit targets. */
poly_int64
ix86_push_rounding (poly_int64 bytes)
{
return ROUND_UP (bytes, UNITS_PER_WORD);
}
/* Target-specific selftests. */
#if CHECKING_P

10
gcc/config/i386/i386.h
View file

@ -1547,15 +1547,7 @@ enum reg_class
goes at a more negative offset in the frame. */
#define FRAME_GROWS_DOWNWARD 1
/* If we generate an insn to push BYTES bytes, this says how many the stack
pointer really advances by. On 386, we have pushw instruction that
decrements by exactly 2 no matter what the position was, there is no pushb.
But as CIE data alignment factor on this arch is -4 for 32bit targets
and -8 for 64bit targets, we need to make sure all stack pointer adjustments
are in multiple of 4 for 32bit targets and 8 for 64bit targets. */
#define PUSH_ROUNDING(BYTES) ROUND_UP ((BYTES), UNITS_PER_WORD)
#define PUSH_ROUNDING(BYTES) ix86_push_rounding (BYTES)
/* If defined, the maximum amount of space required for outgoing arguments
will be computed and placed into the variable `crtl->outgoing_args_size'.

2
gcc/config/m32c/m32c-protos.h
View file

@ -29,7 +29,7 @@ void m32c_init_expanders (void);
int m32c_initial_elimination_offset (int, int);
void m32c_output_reg_pop (FILE *, int);
void m32c_output_reg_push (FILE *, int);
unsigned int m32c_push_rounding (int);
poly_int64 m32c_push_rounding (poly_int64);
void m32c_register_pragmas (void);
void m32c_note_pragma_address (const char *, unsigned);
int m32c_regno_ok_for_base_p (int);

4
gcc/config/m32c/m32c.c
View file

@ -1290,8 +1290,8 @@ m32c_initial_elimination_offset (int from, int to)
/* Implements PUSH_ROUNDING. The R8C and M16C have byte stacks, the
M32C has word stacks. */
unsigned int
m32c_push_rounding (int n)
poly_int64
m32c_push_rounding (poly_int64 n)
{
if (TARGET_R8C || TARGET_M16C)
return n;

1
gcc/config/m68k/m68k-protos.h
View file

@ -99,3 +99,4 @@ extern void init_68881_table (void);
extern rtx m68k_legitimize_call_address (rtx);
extern rtx m68k_legitimize_sibcall_address (rtx);
extern int m68k_hard_regno_rename_ok(unsigned int, unsigned int);
extern poly_int64 m68k_push_rounding (poly_int64);

11
gcc/config/m68k/m68k.c
View file

@ -6610,4 +6610,15 @@ m68k_excess_precision (enum excess_precision_type type)
return FLT_EVAL_METHOD_UNPREDICTABLE;
}
/* Implement PUSH_ROUNDING. On the 680x0, sp@- in a byte insn really pushes
a word. On the ColdFire, sp@- in a byte insn pushes just a byte. */
poly_int64
m68k_push_rounding (poly_int64 bytes)
{
if (TARGET_COLDFIRE)
return bytes;
return (bytes + 1) & ~1;
}
#include "gt-m68k.h"

4
gcc/config/m68k/m68k.h
View file

@ -468,9 +468,7 @@ extern enum reg_class regno_reg_class[];
#define STACK_GROWS_DOWNWARD 1
#define FRAME_GROWS_DOWNWARD 1
/* On the 680x0, sp@- in a byte insn really pushes a word.
On the ColdFire, sp@- in a byte insn pushes just a byte. */
#define PUSH_ROUNDING(BYTES) (TARGET_COLDFIRE ? BYTES : ((BYTES) + 1) & ~1)
#define PUSH_ROUNDING(BYTES) m68k_push_rounding (BYTES)
#define FIRST_PARM_OFFSET(FNDECL) 8

1
gcc/config/pdp11/pdp11-protos.h
View file

@ -44,3 +44,4 @@ extern void pdp11_asm_output_var (FILE *, const char *, int, int, bool);
extern void pdp11_expand_prologue (void);
extern void pdp11_expand_epilogue (void);
extern int pdp11_branch_cost (void);
extern poly_int64 pdp11_push_rounding (poly_int64);

9
gcc/config/pdp11/pdp11.c
View file

@ -1977,4 +1977,13 @@ pdp11_modes_tieable_p (machine_mode, machine_mode)
return false;
}
/* Implement PUSH_ROUNDING. On the pdp11, the stack is on an even
boundary. */
poly_int64
pdp11_push_rounding (poly_int64 bytes)
{
return (bytes + 1) & ~1;
}
struct gcc_target targetm = TARGET_INITIALIZER;

5
gcc/config/pdp11/pdp11.h
View file

@ -257,10 +257,7 @@ enum reg_class { NO_REGS, MUL_REGS, GENERAL_REGS, LOAD_FPU_REGS, NO_LOAD_FPU_REG
*/
#define FRAME_GROWS_DOWNWARD 1
/* If we generate an insn to push BYTES bytes,
this says how many the stack pointer really advances by.
On the pdp11, the stack is on an even boundary */
#define PUSH_ROUNDING(BYTES) ((BYTES + 1) & ~1)
#define PUSH_ROUNDING(BYTES) pdp11_push_rounding (BYTES)
/* current_first_parm_offset stores the # of registers pushed on the
stack */

1
gcc/config/stormy16/stormy16-protos.h
View file

@ -28,6 +28,7 @@ extern int direct_return (void);
extern int xstormy16_interrupt_function_p (void);
extern int xstormy16_epilogue_uses (int);
extern void xstormy16_function_profiler (void);
extern poly_int64 xstormy16_push_rounding (poly_int64);
#if defined (TREE_CODE)
extern void xstormy16_asm_output_aligned_common (FILE *, tree, const char *,

8
gcc/config/stormy16/stormy16.c
View file

@ -2635,6 +2635,14 @@ xstormy16_modes_tieable_p (machine_mode mode1, machine_mode mode2)
{
return mode1 != BImode && mode2 != BImode;
}
/* Implement PUSH_ROUNDING. */
poly_int64
xstormy16_push_rounding (poly_int64 bytes)
{
return (bytes + 1) & ~1;
}
#undef TARGET_ASM_ALIGNED_HI_OP
#define TARGET_ASM_ALIGNED_HI_OP "\t.hword\t"

2
gcc/config/stormy16/stormy16.h
View file

@ -255,7 +255,7 @@ enum reg_class
/* Passing Function Arguments on the Stack. */
#define PUSH_ROUNDING(BYTES) (((BYTES) + 1) & ~1)
#define PUSH_ROUNDING(BYTES) xstormy16_push_rounding (BYTES)
/* Function Arguments in Registers. */

23
gcc/expr.c
View file

@ -3347,10 +3347,9 @@ rtx
emit_move_resolve_push (machine_mode mode, rtx x)
{
enum rtx_code code = GET_CODE (XEXP (x, 0));
HOST_WIDE_INT adjust;
rtx temp;
adjust = GET_MODE_SIZE (mode);
poly_int64 adjust = GET_MODE_SIZE (mode);
#ifdef PUSH_ROUNDING
adjust = PUSH_ROUNDING (adjust);
#endif
@ -3359,14 +3358,12 @@ emit_move_resolve_push (machine_mode mode, rtx x)
else if (code == PRE_MODIFY || code == POST_MODIFY)
{
rtx expr = XEXP (XEXP (x, 0), 1);
HOST_WIDE_INT val;
gcc_assert (GET_CODE (expr) == PLUS || GET_CODE (expr) == MINUS);
gcc_assert (CONST_INT_P (XEXP (expr, 1)));
val = INTVAL (XEXP (expr, 1));
poly_int64 val = rtx_to_poly_int64 (XEXP (expr, 1));
if (GET_CODE (expr) == MINUS)
val = -val;
gcc_assert (adjust == val || adjust == -val);
gcc_assert (known_eq (adjust, val) || known_eq (adjust, -val));
adjust = val;
}
@ -3408,11 +3405,11 @@ emit_move_complex_push (machine_mode mode, rtx x, rtx y)
bool imag_first;
#ifdef PUSH_ROUNDING
unsigned int submodesize = GET_MODE_SIZE (submode);
poly_int64 submodesize = GET_MODE_SIZE (submode);
/* In case we output to the stack, but the size is smaller than the
machine can push exactly, we need to use move instructions. */
if (PUSH_ROUNDING (submodesize) != submodesize)
if (maybe_ne (PUSH_ROUNDING (submodesize), submodesize))
{
x = emit_move_resolve_push (mode, x);
return emit_move_insn (x, y);
@ -4132,7 +4129,7 @@ static void
emit_single_push_insn_1 (machine_mode mode, rtx x, tree type)
{
rtx dest_addr;
unsigned rounded_size = PUSH_ROUNDING (GET_MODE_SIZE (mode));
poly_int64 rounded_size = PUSH_ROUNDING (GET_MODE_SIZE (mode));
rtx dest;
enum insn_code icode;
@ -4147,7 +4144,7 @@ emit_single_push_insn_1 (machine_mode mode, rtx x, tree type)
if (maybe_expand_insn (icode, 1, ops))
return;
}
if (GET_MODE_SIZE (mode) == rounded_size)
if (known_eq (GET_MODE_SIZE (mode), rounded_size))
dest_addr = gen_rtx_fmt_e (STACK_PUSH_CODE, Pmode, stack_pointer_rtx);
/* If we are to pad downward, adjust the stack pointer first and
then store X into the stack location using an offset. This is
@ -4375,9 +4372,9 @@ emit_push_insn (rtx x, machine_mode mode, tree type, rtx size,
and such small pushes do rounding that causes trouble. */
&& ((!targetm.slow_unaligned_access (word_mode, align))
|| align >= BIGGEST_ALIGNMENT
|| (PUSH_ROUNDING (align / BITS_PER_UNIT)
== (align / BITS_PER_UNIT)))
&& (HOST_WIDE_INT) PUSH_ROUNDING (INTVAL (size)) == INTVAL (size))
|| known_eq (PUSH_ROUNDING (align / BITS_PER_UNIT),
align / BITS_PER_UNIT))
&& known_eq (PUSH_ROUNDING (INTVAL (size)), INTVAL (size)))
{
/* Push padding now if padding above and stack grows down,
or if padding below and stack grows up.

2
gcc/lra-eliminations.c
View file

@ -748,7 +748,7 @@ mark_not_eliminable (rtx x, machine_mode mem_mode)
&& XEXP (x, 0) == XEXP (XEXP (x, 1), 0)
&& poly_int_rtx_p (XEXP (XEXP (x, 1), 1), &offset))))
{
int size = GET_MODE_SIZE (mem_mode);
poly_int64 size = GET_MODE_SIZE (mem_mode);
#ifdef PUSH_ROUNDING
/* If more bytes than MEM_MODE are pushed, account for

22
gcc/recog.c
View file

@ -1258,33 +1258,35 @@ nonmemory_operand (rtx op, machine_mode mode)
int
push_operand (rtx op, machine_mode mode)
{
unsigned int rounded_size = GET_MODE_SIZE (mode);
#ifdef PUSH_ROUNDING
rounded_size = PUSH_ROUNDING (rounded_size);
#endif
if (!MEM_P (op))
return 0;
if (mode != VOIDmode && GET_MODE (op) != mode)
return 0;
poly_int64 rounded_size = GET_MODE_SIZE (mode);
#ifdef PUSH_ROUNDING
rounded_size = PUSH_ROUNDING (MACRO_INT (rounded_size));
#endif
op = XEXP (op, 0);
if (rounded_size == GET_MODE_SIZE (mode))
if (known_eq (rounded_size, GET_MODE_SIZE (mode)))
{
if (GET_CODE (op) != STACK_PUSH_CODE)
return 0;
}
else
{
poly_int64 offset;
if (GET_CODE (op) != PRE_MODIFY
|| GET_CODE (XEXP (op, 1)) != PLUS
|| XEXP (XEXP (op, 1), 0) != XEXP (op, 0)
|| !CONST_INT_P (XEXP (XEXP (op, 1), 1))
|| INTVAL (XEXP (XEXP (op, 1), 1))
!= ((STACK_GROWS_DOWNWARD ? -1 : 1) * (int) rounded_size))
|| !poly_int_rtx_p (XEXP (XEXP (op, 1), 1), &offset)
|| (STACK_GROWS_DOWNWARD
? maybe_ne (offset, -rounded_size)
: maybe_ne (offset, rounded_size)))
return 0;
}

2
gcc/reload1.c
View file

@ -2996,7 +2996,7 @@ elimination_effects (rtx x, machine_mode mem_mode)
for (ep = reg_eliminate; ep < &reg_eliminate[NUM_ELIMINABLE_REGS]; ep++)
if (ep->to_rtx == XEXP (x, 0))
{
int size = GET_MODE_SIZE (mem_mode);
poly_int64 size = GET_MODE_SIZE (mem_mode);
/* If more bytes than MEM_MODE are pushed, account for them. */
#ifdef PUSH_ROUNDING

6
gcc/rtlanal.c
View file

@ -4518,8 +4518,10 @@ nonzero_bits1 (const_rtx x, scalar_int_mode mode, const_rtx known_x,
stack to be momentarily aligned only to that amount,
so we pick the least alignment. */
if (x == stack_pointer_rtx && PUSH_ARGS)
alignment = MIN ((unsigned HOST_WIDE_INT) PUSH_ROUNDING (1),
alignment);
{
poly_uint64 rounded_1 = PUSH_ROUNDING (poly_int64 (1));
alignment = MIN (known_alignment (rounded_1), alignment);
}
#endif
nonzero &= ~(alignment - 1);