From: Richard Sandiford Date: Wed, 3 Jan 2018 07:18:13 +0000 (+0000) Subject: poly_int: PUSH_ROUNDING X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=7b4df2bf95d2254756f6509ee57a90c398baf81b;p=gcc.git poly_int: PUSH_ROUNDING 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 Alan Hayward David Sherwood 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 Co-Authored-By: David Sherwood From-SVN: r256155 --- diff --git a/gcc/ChangeLog b/gcc/ChangeLog index d37f05a5cfe..d9428fe63c6 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,40 @@ +2018-01-03 Richard Sandiford + Alan Hayward + David Sherwood + + * 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 Alan Hayward David Sherwood diff --git a/gcc/calls.c b/gcc/calls.c index 9b7e1189918..404cccc9136 100644 --- a/gcc/calls.c +++ b/gcc/calls.c @@ -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; diff --git a/gcc/config/cr16/cr16-protos.h b/gcc/config/cr16/cr16-protos.h index 4872c0b8b2e..886669092c5 100644 --- a/gcc/config/cr16/cr16-protos.h +++ b/gcc/config/cr16/cr16-protos.h @@ -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. */ diff --git a/gcc/config/cr16/cr16.c b/gcc/config/cr16/cr16.c index ddadab2ca7b..9ea02a967ff 100644 --- a/gcc/config/cr16/cr16.c +++ b/gcc/config/cr16/cr16.c @@ -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. */ diff --git a/gcc/config/cr16/cr16.h b/gcc/config/cr16/cr16.h index 5c4702c28ef..692bbaf86d5 100644 --- a/gcc/config/cr16/cr16.h +++ b/gcc/config/cr16/cr16.h @@ -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 diff --git a/gcc/config/h8300/h8300-protos.h b/gcc/config/h8300/h8300-protos.h index d6adebbbe94..1d4a574c7b9 100644 --- a/gcc/config/h8300/h8300-protos.h +++ b/gcc/config/h8300/h8300-protos.h @@ -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 */ diff --git a/gcc/config/h8300/h8300.c b/gcc/config/h8300/h8300.c index 88c21534471..432e23e37ff 100644 --- a/gcc/config/h8300/h8300.c +++ b/gcc/config/h8300/h8300.c @@ -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 diff --git a/gcc/config/h8300/h8300.h b/gcc/config/h8300/h8300.h index 9ba82a76ab9..a57e7b543e5 100644 --- a/gcc/config/h8300/h8300.h +++ b/gcc/config/h8300/h8300.h @@ -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 diff --git a/gcc/config/i386/i386-protos.h b/gcc/config/i386/i386-protos.h index 287b0198589..d1b5330c351 100644 --- a/gcc/config/i386/i386-protos.h +++ b/gcc/config/i386/i386-protos.h @@ -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. */ diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c index cac510de971..ff058f44542 100644 --- a/gcc/config/i386/i386.c +++ b/gcc/config/i386/i386.c @@ -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 diff --git a/gcc/config/i386/i386.h b/gcc/config/i386/i386.h index 3b953de506a..8a17c0e17c4 100644 --- a/gcc/config/i386/i386.h +++ b/gcc/config/i386/i386.h @@ -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'. diff --git a/gcc/config/m32c/m32c-protos.h b/gcc/config/m32c/m32c-protos.h index 8647a208420..f68d3b3185d 100644 --- a/gcc/config/m32c/m32c-protos.h +++ b/gcc/config/m32c/m32c-protos.h @@ -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); diff --git a/gcc/config/m32c/m32c.c b/gcc/config/m32c/m32c.c index f1a465a4b44..d8f69ee8ed9 100644 --- a/gcc/config/m32c/m32c.c +++ b/gcc/config/m32c/m32c.c @@ -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; diff --git a/gcc/config/m68k/m68k-protos.h b/gcc/config/m68k/m68k-protos.h index cdd6798c660..3c285a98fe2 100644 --- a/gcc/config/m68k/m68k-protos.h +++ b/gcc/config/m68k/m68k-protos.h @@ -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); diff --git a/gcc/config/m68k/m68k.c b/gcc/config/m68k/m68k.c index 10c78153e64..1c6484e8fec 100644 --- a/gcc/config/m68k/m68k.c +++ b/gcc/config/m68k/m68k.c @@ -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" diff --git a/gcc/config/m68k/m68k.h b/gcc/config/m68k/m68k.h index 97693cbf549..8eb898e6eba 100644 --- a/gcc/config/m68k/m68k.h +++ b/gcc/config/m68k/m68k.h @@ -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 diff --git a/gcc/config/pdp11/pdp11-protos.h b/gcc/config/pdp11/pdp11-protos.h index f6c7d1a7f1b..467b0d87a0a 100644 --- a/gcc/config/pdp11/pdp11-protos.h +++ b/gcc/config/pdp11/pdp11-protos.h @@ -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); diff --git a/gcc/config/pdp11/pdp11.c b/gcc/config/pdp11/pdp11.c index 06fef13f5d6..1367a072b1b 100644 --- a/gcc/config/pdp11/pdp11.c +++ b/gcc/config/pdp11/pdp11.c @@ -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; diff --git a/gcc/config/pdp11/pdp11.h b/gcc/config/pdp11/pdp11.h index 115bb5b83a0..5ccec18e91a 100644 --- a/gcc/config/pdp11/pdp11.h +++ b/gcc/config/pdp11/pdp11.h @@ -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 */ diff --git a/gcc/config/stormy16/stormy16-protos.h b/gcc/config/stormy16/stormy16-protos.h index 38be8d2adfd..c4ce1145c21 100644 --- a/gcc/config/stormy16/stormy16-protos.h +++ b/gcc/config/stormy16/stormy16-protos.h @@ -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 *, diff --git a/gcc/config/stormy16/stormy16.c b/gcc/config/stormy16/stormy16.c index a3557940d9e..002eeee8f8c 100644 --- a/gcc/config/stormy16/stormy16.c +++ b/gcc/config/stormy16/stormy16.c @@ -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" diff --git a/gcc/config/stormy16/stormy16.h b/gcc/config/stormy16/stormy16.h index 1d7045759c5..dfc659c2e98 100644 --- a/gcc/config/stormy16/stormy16.h +++ b/gcc/config/stormy16/stormy16.h @@ -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. */ diff --git a/gcc/expr.c b/gcc/expr.c index 336673f059a..580ec4868c0 100644 --- a/gcc/expr.c +++ b/gcc/expr.c @@ -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. diff --git a/gcc/lra-eliminations.c b/gcc/lra-eliminations.c index 4f130a68e79..a4437809431 100644 --- a/gcc/lra-eliminations.c +++ b/gcc/lra-eliminations.c @@ -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 diff --git a/gcc/recog.c b/gcc/recog.c index 99031df553d..43e8781099f 100644 --- a/gcc/recog.c +++ b/gcc/recog.c @@ -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; } diff --git a/gcc/reload1.c b/gcc/reload1.c index 2483ed9af8b..a1dcf421878 100644 --- a/gcc/reload1.c +++ b/gcc/reload1.c @@ -2996,7 +2996,7 @@ elimination_effects (rtx x, machine_mode mem_mode) for (ep = reg_eliminate; ep < ®_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 diff --git a/gcc/rtlanal.c b/gcc/rtlanal.c index 89c8816fbb9..62350972e2b 100644 --- a/gcc/rtlanal.c +++ b/gcc/rtlanal.c @@ -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);