OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

target.def (legitimate_constant_p): New hook. 

gcc/
	* target.def (legitimate_constant_p): New hook.
	* doc/tm.texi.in (LEGITIMATE_CONSTANT_P): Replace with...
	(TARGET_LEGITIMATE_CONSTANT_P): ...this.
	* doc/tm.texi: Regenerate.
	* hooks.h (hook_bool_mode_rtx_true): Declare.
	* hooks.c (hook_bool_mode_rtx_true): Define.
	* system.h (LEGITIMATE_CONSTANT_P): Poison.
	* calls.c (precompute_register_parameters): Replace uses of
	LEGITIMATE_CONSTANT_P with targetm.legitimate_constant_p.
	(emit_library_call_value_1): Likewise.
	* expr.c (move_block_to_reg, can_store_by_pieces, emit_move_insn)
	(compress_float_constant, emit_push_insn, expand_expr_real_1): Likewise.
	* ira-costs.c (scan_one_insn): Likewise.
	* recog.c (general_operand, immediate_operand): Likewise.
	* reload.c (find_reloads_toplev, find_reloads_address_part): Likewise.
	* reload1.c (init_eliminable_invariants): Likewise.

	* config/alpha/alpha-protos.h (alpha_legitimate_constant_p): Add a
	mode argument.
	* config/alpha/alpha.h (LEGITIMATE_CONSTANT_P): Delete.
	* config/alpha/alpha.c (alpha_legitimate_constant_p): Add a mode
	argument.
	(TARGET_LEGITIMATE_CONSTANT_P): Define.
	* config/alpha/predicates.md (input_operand): Update call to
	alpha_legitimate_constant_p.

	* config/arm/arm-protos.h (arm_cannot_force_const_mem): Delete.
	* config/arm/arm.h (ARM_LEGITIMATE_CONSTANT_P): Likewise.
	(THUMB_LEGITIMATE_CONSTANT_P, LEGITIMATE_CONSTANT_P): Likewise.
	* config/arm/arm.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
	(arm_legitimate_constant_p_1, thumb_legitimate_constant_p)
	(arm_legitimate_constant_p): New functions.
	(arm_cannot_force_const_mem): Make static.

	* config/avr/avr.h (LEGITIMATE_CONSTANT_P): Delete.

	* config/bfin/bfin-protos.h (bfin_legitimate_constant_p): Delete.
	* config/bfin/bfin.h (LEGITIMATE_CONSTANT_P): Delete.
	* config/bfin/bfin.c (expand_move): Use targetm.legitimate_constant_p
	instead of bfin_legitimate_constant_p.
	(bfin_legitimate_constant_p): Make static.  Add a mode argument.
	(TARGET_LEGITIMATE_CONSTANT_P): Define.

	* config/cris/cris.h (LEGITIMATE_CONSTANT_P): Delete.

	* config/fr30/fr30.h (LEGITIMATE_CONSTANT_P): Delete.

	* config/frv/frv-protos.h (frv_legitimate_constant_p): Delete.
	* config/frv/frv.h (LEGITIMATE_CONSTANT_P): Delete.
	* config/frv/frv.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
	(frv_legitimate_constant_p): Make static.  Add a mode argument.

	* config/h8300/h8300-protos.h (h8300_legitimate_constant_p): Delete.
	* config/h8300/h8300.h (LEGITIMATE_CONSTANT_P): Likewise.
	* config/h8300/h8300.c (h8300_legitimate_constant_p): Likewise.

	* config/i386/i386-protos.h (legitimate_constant_p): Delete.
	* config/i386/i386.h (LEGITIMATE_CONSTANT_P): Likewise.
	* config/i386/i386.c (legitimate_constant_p): Rename to...
	(ix86_legitimate_constant_p): ...this.  Make static.  Add a mode
	argument.
	(ix86_cannot_force_const_mem): Update accordingly.
	(ix86_legitimate_address_p): Likewise.
	(TARGET_LEGITIMATE_CONSTANT_P): Define.
	* config/i386/i386.md: Update commentary.

	* config/ia64/ia64-protos.h (ia64_legitimate_constant_p): Delete.
	* config/ia64/ia64.h (LEGITIMATE_CONSTANT_P): Likewise.
	* config/ia64/ia64.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
	(ia64_legitimate_constant_p): Make static.  Add a mode argument.

	* config/iq2000/iq2000.h (LEGITIMATE_CONSTANT_P): Delete.

	* config/lm32/lm32-protos.h (lm32_legitimate_constant_p): Delete.
	* config/lm32/lm32.h (LEGITIMATE_CONSTANT_P): Likewise.
	* config/lm32/lm32.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
	(lm32_legitimate_constant_p): Make static.  Add a mode argument.

	* config/m32c/m32c-protos.h (m32c_legitimate_constant_p): Delete.
	* config/m32c/m32c.h (LEGITIMATE_CONSTANT_P): Likewise.
	* config/m32c/m32c.c (m32c_legitimate_constant_p): Likewise.

	* config/m32r/m32r.h (LEGITIMATE_CONSTANT_P): Delete.
	* config/m32r/m32r.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
	(m32r_legitimate_constant_p): New function.

	* config/m68k/m68k-protos.h (m68k_legitimate_constant_p): Declare.
	* config/m68k/m68k.h (CONSTANT_ADDRESS_P): Call it instead of
	LEGITIMATE_CONSTANT_P.
	(LEGITIMATE_CONSTANT_P): Delete.
	* config/m68k/m68k.c (m68k_expand_prologue): Call
	m68k_legitimate_constant_p instead of LEGITIMATE_CONSTANT_P.
	(m68k_legitimate_constant_p): New function.
	* config/m68k/m68k.md: Update comments.

	* config/mcore/mcore.h (LEGITIMATE_CONSTANT_P): Delete.
	* config/mcore/mcore.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
	(mcore_legitimate_constant_p): New function.

	* config/mep/mep-protos.h (mep_legitimate_constant_p): Delete.
	* config/mep/mep.h (LEGITIMATE_CONSTANT_P): Likewise.
	* config/mep/mep.c (mep_legitimate_constant_p): Make static.
	Add a mode argument.
	(mep_legitimate_address): Update accordingly.
	(TARGET_LEGITIMATE_CONSTANT_P): Define.

	* config/microblaze/microblaze-protos.h (microblaze_const_double_ok):
	Delete.
	* config/microblaze/microblaze.h (LEGITIMATE_CONSTANT_P): Likewise.
	* config/microblaze/microblaze.c (microblaze_const_double_ok): Make
	static.  Check OP's mode for VOIDmode.
	(microblaze_legitimate_constant_p): New function.
	(TARGET_LEGITIMATE_CONSTANT_P): Define.

	* config/mips/mips.h (LEGITIMATE_CONSTANT_P): Delete.
	* config/mips/mips.c (mips_legitimate_constant_p): New function.
	(mips_cannot_force_const_mem): Use it instead of LEGITIMATE_CONSTANT_P.
	(TARGET_LEGITIMATE_CONSTANT_P): Define.
	* config/mips/predicates.md: Update comments.

	* config/mmix/mmix-protos.h (mmix_legitimate_constant_p): Delete.
	* config/mmix/mmix.h (LEGITIMATE_CONSTANT_P): Likewise.
	* config/mmix/mmix.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
	(mmix_legitimate_constant_p): Make static, return a bool, and take
	a mode argument.
	(mmix_print_operand_address): Update accordingly.

	* config/mn10300/mn10300-protos.h (mn10300_legitimate_constant_p):
	Delete.
	* config/mn10300/mn10300.h (LEGITIMATE_CONSTANT_P): Likewise.
	* config/mn10300/mn10300.c (mn10300_legitimate_constant_p):
	Make static.  Add a mode argument.
	(TARGET_LEGITIMATE_CONSTANT_P): Define.

	* config/moxie/moxie.h (LEGITIMATE_CONSTANT_P): Delete.

	* config/pa/pa.h (LEGITIMATE_CONSTANT_P): Delete.
	* config/pa/pa.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
	(pa_legitimate_constant_p): New function.

	* config/picochip/picochip.h (LEGITIMATE_CONSTANT_P): Delete.

	* config/pdp11/pdp11.h (LEGITIMATE_CONSTANT_P): Delete.
	* config/pdp11/pdp11.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
	(pdp11_legitimate_constant_p): New function.

	* config/rs6000/rs6000.h (LEGITIMATE_CONSTANT_P): Delete.
	* config/rs6000/rs6000.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
	(rs6000_legitimate_constant_p): New function.

	* config/rx/rx-protos.h (rx_is_legitimate_constant): Replace with...
	(rx_legitimate_constant_p): ...this.
	* config/rx/rx.h (LEGITIMATE_CONSTANT_P): Delete.
	* config/rx/rx.c (rx_is_legitimate_constant): Replace with...
	(rx_legitimate_constant_p): ...this.
	(TARGET_LEGITIMATE_CONSTANT_P): Define.
	* config/rx/rx.md (mov<register_modes:mode>): Update accordingly.

	* config/s390/s390-protos.h (legitimate_constant_p): Delete.
	* config/s390/s390.h (LEGITIMATE_CONSTANT_P): Likewise.
	* config/s390/s390.c (legitimate_constant_p): Rename to...
	(s390_legitimate_constant_p): ...this.  Make static, return a bool,
	and add a mode argument.
	(TARGET_LEGITIMATE_CONSTANT_P): Define.

	* config/score/score.h (LEGITIMATE_CONSTANT_P): Delete.

	* config/sh/sh.h (LEGITIMATE_CONSTANT_P): Delete.
	* config/sh/sh.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
	(sh_legitimate_constant_p): New function.

	* config/sparc/sparc-protos.h (legitimate_constant_p): Delete.
	* config/sparc/sparc.h (LEGITIMATE_CONSTANT_P): Delete.
	* config/sparc/sparc.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
	(legitimate_constant_p): Rename to...
	(sparc_legitimate_constant_p): ...this.  Make static.  Add a mode
	argument.
	(constant_address_p): Update accordingly.

	* config/spu/spu-protos.h (spu_legitimate_constant_p): Add a mode
	argument and return a bool.
	* config/spu/spu.h (LEGITIMATE_CONSTANT_P): Delete.
	* config/spu/spu.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
	(spu_legitimate_constant_p): Add a mode argument and return a bool.
	(spu_rtx_costs): Update accordingly.
	* config/spu/predicates.md (vec_imm_operand): Likewise.

	* config/stormy16/stormy16.h (LEGITIMATE_CONSTANT_P): Delete.

	* config/v850/v850.h (LEGITIMATE_CONSTANT_P): Delete.
	* config/v850/v850.c (v850_legitimate_constant_p): New function.
	(TARGET_LEGITIMATE_CONSTANT_P): Define.

	* config/vax/vax-protos.h (legitimate_constant_p): Delete.
	* config/vax/vax.h (LEGITIMATE_CONSTANT_P): Likewise.
	* config/vax/vax.c (legitimate_constant_p): Likewise.

	* config/xtensa/xtensa.h (LEGITIMATE_CONSTANT_P): Delete.
	* config/xtensa/xtensa.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
	(xtensa_legitimate_constant_p): New function.

From-SVN: r172814
This commit is contained in:
Richard Sandiford 2011-04-21 09:38:43 +00:00 committed by Richard Sandiford
parent fbbf66e77a
commit 1a627b35d3
102 changed files with 615 additions and 398 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

203
gcc/ChangeLog
View File

@ -1,3 +1,206 @@
2011-04-21 Richard Sandiford <richard.sandiford@linaro.org>
* target.def (legitimate_constant_p): New hook.
* doc/tm.texi.in (LEGITIMATE_CONSTANT_P): Replace with...
(TARGET_LEGITIMATE_CONSTANT_P): ...this.
* doc/tm.texi: Regenerate.
* hooks.h (hook_bool_mode_rtx_true): Declare.
* hooks.c (hook_bool_mode_rtx_true): Define.
* system.h (LEGITIMATE_CONSTANT_P): Poison.
* calls.c (precompute_register_parameters): Replace uses of
LEGITIMATE_CONSTANT_P with targetm.legitimate_constant_p.
(emit_library_call_value_1): Likewise.
* expr.c (move_block_to_reg, can_store_by_pieces, emit_move_insn)
(compress_float_constant, emit_push_insn, expand_expr_real_1): Likewise.
* ira-costs.c (scan_one_insn): Likewise.
* recog.c (general_operand, immediate_operand): Likewise.
* reload.c (find_reloads_toplev, find_reloads_address_part): Likewise.
* reload1.c (init_eliminable_invariants): Likewise.
* config/alpha/alpha-protos.h (alpha_legitimate_constant_p): Add a
mode argument.
* config/alpha/alpha.h (LEGITIMATE_CONSTANT_P): Delete.
* config/alpha/alpha.c (alpha_legitimate_constant_p): Add a mode
argument.
(TARGET_LEGITIMATE_CONSTANT_P): Define.
* config/alpha/predicates.md (input_operand): Update call to
alpha_legitimate_constant_p.
* config/arm/arm-protos.h (arm_cannot_force_const_mem): Delete.
* config/arm/arm.h (ARM_LEGITIMATE_CONSTANT_P): Likewise.
(THUMB_LEGITIMATE_CONSTANT_P, LEGITIMATE_CONSTANT_P): Likewise.
* config/arm/arm.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
(arm_legitimate_constant_p_1, thumb_legitimate_constant_p)
(arm_legitimate_constant_p): New functions.
(arm_cannot_force_const_mem): Make static.
* config/avr/avr.h (LEGITIMATE_CONSTANT_P): Delete.
* config/bfin/bfin-protos.h (bfin_legitimate_constant_p): Delete.
* config/bfin/bfin.h (LEGITIMATE_CONSTANT_P): Delete.
* config/bfin/bfin.c (expand_move): Use targetm.legitimate_constant_p
instead of bfin_legitimate_constant_p.
(bfin_legitimate_constant_p): Make static. Add a mode argument.
(TARGET_LEGITIMATE_CONSTANT_P): Define.
* config/cris/cris.h (LEGITIMATE_CONSTANT_P): Delete.
* config/fr30/fr30.h (LEGITIMATE_CONSTANT_P): Delete.
* config/frv/frv-protos.h (frv_legitimate_constant_p): Delete.
* config/frv/frv.h (LEGITIMATE_CONSTANT_P): Delete.
* config/frv/frv.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
(frv_legitimate_constant_p): Make static. Add a mode argument.
* config/h8300/h8300-protos.h (h8300_legitimate_constant_p): Delete.
* config/h8300/h8300.h (LEGITIMATE_CONSTANT_P): Likewise.
* config/h8300/h8300.c (h8300_legitimate_constant_p): Likewise.
* config/i386/i386-protos.h (legitimate_constant_p): Delete.
* config/i386/i386.h (LEGITIMATE_CONSTANT_P): Likewise.
* config/i386/i386.c (legitimate_constant_p): Rename to...
(ix86_legitimate_constant_p): ...this. Make static. Add a mode
argument.
(ix86_cannot_force_const_mem): Update accordingly.
(ix86_legitimate_address_p): Likewise.
(TARGET_LEGITIMATE_CONSTANT_P): Define.
* config/i386/i386.md: Update commentary.
* config/ia64/ia64-protos.h (ia64_legitimate_constant_p): Delete.
* config/ia64/ia64.h (LEGITIMATE_CONSTANT_P): Likewise.
* config/ia64/ia64.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
(ia64_legitimate_constant_p): Make static. Add a mode argument.
* config/iq2000/iq2000.h (LEGITIMATE_CONSTANT_P): Delete.
* config/lm32/lm32-protos.h (lm32_legitimate_constant_p): Delete.
* config/lm32/lm32.h (LEGITIMATE_CONSTANT_P): Likewise.
* config/lm32/lm32.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
(lm32_legitimate_constant_p): Make static. Add a mode argument.
* config/m32c/m32c-protos.h (m32c_legitimate_constant_p): Delete.
* config/m32c/m32c.h (LEGITIMATE_CONSTANT_P): Likewise.
* config/m32c/m32c.c (m32c_legitimate_constant_p): Likewise.
* config/m32r/m32r.h (LEGITIMATE_CONSTANT_P): Delete.
* config/m32r/m32r.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
(m32r_legitimate_constant_p): New function.
* config/m68k/m68k-protos.h (m68k_legitimate_constant_p): Declare.
* config/m68k/m68k.h (CONSTANT_ADDRESS_P): Call it instead of
LEGITIMATE_CONSTANT_P.
(LEGITIMATE_CONSTANT_P): Delete.
* config/m68k/m68k.c (m68k_expand_prologue): Call
m68k_legitimate_constant_p instead of LEGITIMATE_CONSTANT_P.
(m68k_legitimate_constant_p): New function.
* config/m68k/m68k.md: Update comments.
* config/mcore/mcore.h (LEGITIMATE_CONSTANT_P): Delete.
* config/mcore/mcore.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
(mcore_legitimate_constant_p): New function.
* config/mep/mep-protos.h (mep_legitimate_constant_p): Delete.
* config/mep/mep.h (LEGITIMATE_CONSTANT_P): Likewise.
* config/mep/mep.c (mep_legitimate_constant_p): Make static.
Add a mode argument.
(mep_legitimate_address): Update accordingly.
(TARGET_LEGITIMATE_CONSTANT_P): Define.
* config/microblaze/microblaze-protos.h (microblaze_const_double_ok):
Delete.
* config/microblaze/microblaze.h (LEGITIMATE_CONSTANT_P): Likewise.
* config/microblaze/microblaze.c (microblaze_const_double_ok): Make
static. Check OP's mode for VOIDmode.
(microblaze_legitimate_constant_p): New function.
(TARGET_LEGITIMATE_CONSTANT_P): Define.
* config/mips/mips.h (LEGITIMATE_CONSTANT_P): Delete.
* config/mips/mips.c (mips_legitimate_constant_p): New function.
(mips_cannot_force_const_mem): Use it instead of LEGITIMATE_CONSTANT_P.
(TARGET_LEGITIMATE_CONSTANT_P): Define.
* config/mips/predicates.md: Update comments.
* config/mmix/mmix-protos.h (mmix_legitimate_constant_p): Delete.
* config/mmix/mmix.h (LEGITIMATE_CONSTANT_P): Likewise.
* config/mmix/mmix.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
(mmix_legitimate_constant_p): Make static, return a bool, and take
a mode argument.
(mmix_print_operand_address): Update accordingly.
* config/mn10300/mn10300-protos.h (mn10300_legitimate_constant_p):
Delete.
* config/mn10300/mn10300.h (LEGITIMATE_CONSTANT_P): Likewise.
* config/mn10300/mn10300.c (mn10300_legitimate_constant_p):
Make static. Add a mode argument.
(TARGET_LEGITIMATE_CONSTANT_P): Define.
* config/moxie/moxie.h (LEGITIMATE_CONSTANT_P): Delete.
* config/pa/pa.h (LEGITIMATE_CONSTANT_P): Delete.
* config/pa/pa.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
(pa_legitimate_constant_p): New function.
* config/picochip/picochip.h (LEGITIMATE_CONSTANT_P): Delete.
* config/pdp11/pdp11.h (LEGITIMATE_CONSTANT_P): Delete.
* config/pdp11/pdp11.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
(pdp11_legitimate_constant_p): New function.
* config/rs6000/rs6000.h (LEGITIMATE_CONSTANT_P): Delete.
* config/rs6000/rs6000.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
(rs6000_legitimate_constant_p): New function.
* config/rx/rx-protos.h (rx_is_legitimate_constant): Replace with...
(rx_legitimate_constant_p): ...this.
* config/rx/rx.h (LEGITIMATE_CONSTANT_P): Delete.
* config/rx/rx.c (rx_is_legitimate_constant): Replace with...
(rx_legitimate_constant_p): ...this.
(TARGET_LEGITIMATE_CONSTANT_P): Define.
* config/rx/rx.md (mov<register_modes:mode>): Update accordingly.
* config/s390/s390-protos.h (legitimate_constant_p): Delete.
* config/s390/s390.h (LEGITIMATE_CONSTANT_P): Likewise.
* config/s390/s390.c (legitimate_constant_p): Rename to...
(s390_legitimate_constant_p): ...this. Make static, return a bool,
and add a mode argument.
(TARGET_LEGITIMATE_CONSTANT_P): Define.
* config/score/score.h (LEGITIMATE_CONSTANT_P): Delete.
* config/sh/sh.h (LEGITIMATE_CONSTANT_P): Delete.
* config/sh/sh.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
(sh_legitimate_constant_p): New function.
* config/sparc/sparc-protos.h (legitimate_constant_p): Delete.
* config/sparc/sparc.h (LEGITIMATE_CONSTANT_P): Delete.
* config/sparc/sparc.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
(legitimate_constant_p): Rename to...
(sparc_legitimate_constant_p): ...this. Make static. Add a mode
argument.
(constant_address_p): Update accordingly.
* config/spu/spu-protos.h (spu_legitimate_constant_p): Add a mode
argument and return a bool.
* config/spu/spu.h (LEGITIMATE_CONSTANT_P): Delete.
* config/spu/spu.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
(spu_legitimate_constant_p): Add a mode argument and return a bool.
(spu_rtx_costs): Update accordingly.
* config/spu/predicates.md (vec_imm_operand): Likewise.
* config/stormy16/stormy16.h (LEGITIMATE_CONSTANT_P): Delete.
* config/v850/v850.h (LEGITIMATE_CONSTANT_P): Delete.
* config/v850/v850.c (v850_legitimate_constant_p): New function.
(TARGET_LEGITIMATE_CONSTANT_P): Define.
* config/vax/vax-protos.h (legitimate_constant_p): Delete.
* config/vax/vax.h (LEGITIMATE_CONSTANT_P): Likewise.
* config/vax/vax.c (legitimate_constant_p): Likewise.
* config/xtensa/xtensa.h (LEGITIMATE_CONSTANT_P): Delete.
* config/xtensa/xtensa.c (TARGET_LEGITIMATE_CONSTANT_P): Define.
(xtensa_legitimate_constant_p): New function.
2011-04-21 Richard Sandiford <richard.sandiford@linaro.org>
* target.def (cannot_force_const_mem): Add a mode argument.

7
gcc/calls.c
View File

@ -690,7 +690,7 @@ precompute_register_parameters (int num_actuals, struct arg_data *args,
/* If the value is a non-legitimate constant, force it into a
pseudo now. TLS symbols sometimes need a call to resolve. */
if (CONSTANT_P (args[i].value)
&& !LEGITIMATE_CONSTANT_P (args[i].value))
&& !targetm.legitimate_constant_p (args[i].mode, args[i].value))
args[i].value = force_reg (args[i].mode, args[i].value);
/* If we are to promote the function arg to a wider mode,
@ -3447,7 +3447,8 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
/* Make sure it is a reasonable operand for a move or push insn. */
if (!REG_P (addr) && !MEM_P (addr)
&& ! (CONSTANT_P (addr) && LEGITIMATE_CONSTANT_P (addr)))
&& !(CONSTANT_P (addr)
&& targetm.legitimate_constant_p (Pmode, addr)))
addr = force_operand (addr, NULL_RTX);
argvec[count].value = addr;
@ -3488,7 +3489,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
/* Make sure it is a reasonable operand for a move or push insn. */
if (!REG_P (val) && !MEM_P (val)
&& ! (CONSTANT_P (val) && LEGITIMATE_CONSTANT_P (val)))
&& !(CONSTANT_P (val) && targetm.legitimate_constant_p (mode, val)))
val = force_operand (val, NULL_RTX);
if (pass_by_reference (&args_so_far, mode, NULL_TREE, 1))

2
gcc/config/alpha/alpha-protos.h
View File

@ -34,7 +34,7 @@ extern void alpha_output_filename (FILE *, const char *);
extern rtx alpha_tablejump_addr_vec (rtx);
extern rtx alpha_tablejump_best_label (rtx);
extern bool alpha_legitimate_constant_p (rtx);
extern bool alpha_legitimate_constant_p (enum machine_mode, rtx);
extern rtx alpha_legitimize_reload_address (rtx, enum machine_mode,
int, int, int);

9
gcc/config/alpha/alpha.c
View File

@ -2023,15 +2023,14 @@ alpha_extract_integer (rtx x, HOST_WIDE_INT *p0, HOST_WIDE_INT *p1)
*p1 = i1;
}
/* Implement LEGITIMATE_CONSTANT_P. This is all constants for which we
are willing to load the value into a register via a move pattern.
/* Implement TARGET_LEGITIMATE_CONSTANT_P. This is all constants for which
we are willing to load the value into a register via a move pattern.
Normally this is all symbolic constants, integral constants that
take three or fewer instructions, and floating-point zero. */
bool
alpha_legitimate_constant_p (rtx x)
alpha_legitimate_constant_p (enum machine_mode mode, rtx x)
{
enum machine_mode mode = GET_MODE (x);
HOST_WIDE_INT i0, i1;
switch (GET_CODE (x))
@ -9864,6 +9863,8 @@ alpha_conditional_register_usage (void)
#define TARGET_FUNCTION_OK_FOR_SIBCALL alpha_function_ok_for_sibcall
#undef TARGET_CANNOT_COPY_INSN_P
#define TARGET_CANNOT_COPY_INSN_P alpha_cannot_copy_insn_p
#undef TARGET_LEGITIMATE_CONSTANT_P
#define TARGET_LEGITIMATE_CONSTANT_P alpha_legitimate_constant_p
#undef TARGET_CANNOT_FORCE_CONST_MEM
#define TARGET_CANNOT_FORCE_CONST_MEM alpha_cannot_force_const_mem

5
gcc/config/alpha/alpha.h
View File

@ -808,11 +808,6 @@ extern int alpha_memory_latency;
(CONST_INT_P (X) \
&& (unsigned HOST_WIDE_INT) (INTVAL (X) + 0x8000) < 0x10000)
/* Include all constant integers and constant doubles, but not
floating-point, except for floating-point zero. */
#define LEGITIMATE_CONSTANT_P alpha_legitimate_constant_p
/* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
and check its validity for a certain class.
We have two alternate definitions for each of them.

4
gcc/config/alpha/predicates.md
View File

@ -218,14 +218,14 @@
case CONST_VECTOR:
if (reload_in_progress || reload_completed)
return alpha_legitimate_constant_p (op);
return alpha_legitimate_constant_p (mode, op);
return op == CONST0_RTX (mode);
case CONST_INT:
if (mode == QImode || mode == HImode)
return true;
if (reload_in_progress || reload_completed)
return alpha_legitimate_constant_p (op);
return alpha_legitimate_constant_p (mode, op);
return add_operand (op, mode);
default:

1
gcc/config/arm/arm-protos.h
View File

@ -82,7 +82,6 @@ extern void neon_disambiguate_copy (rtx *, rtx *, rtx *, unsigned int);
extern enum reg_class coproc_secondary_reload_class (enum machine_mode, rtx,
bool);
extern bool arm_tls_referenced_p (rtx);
extern bool arm_cannot_force_const_mem (enum machine_mode, rtx);
extern int cirrus_memory_offset (rtx);
extern int arm_coproc_mem_operand (rtx, bool);

39
gcc/config/arm/arm.c
View File

@ -144,6 +144,8 @@ static void arm_internal_label (FILE *, const char *, unsigned long);
static void arm_output_mi_thunk (FILE *, tree, HOST_WIDE_INT, HOST_WIDE_INT,
tree);
static bool arm_have_conditional_execution (void);
static bool arm_cannot_force_const_mem (enum machine_mode, rtx);
static bool arm_legitimate_constant_p (enum machine_mode, rtx);
static bool arm_rtx_costs_1 (rtx, enum rtx_code, int*, bool);
static bool arm_size_rtx_costs (rtx, enum rtx_code, enum rtx_code, int *);
static bool arm_slowmul_rtx_costs (rtx, enum rtx_code, enum rtx_code, int *, bool);
@ -528,6 +530,9 @@ static const struct default_options arm_option_optimization_table[] =
#undef TARGET_HAVE_CONDITIONAL_EXECUTION
#define TARGET_HAVE_CONDITIONAL_EXECUTION arm_have_conditional_execution
#undef TARGET_LEGITIMATE_CONSTANT_P
#define TARGET_LEGITIMATE_CONSTANT_P arm_legitimate_constant_p
#undef TARGET_CANNOT_FORCE_CONST_MEM
#define TARGET_CANNOT_FORCE_CONST_MEM arm_cannot_force_const_mem
@ -6497,9 +6502,41 @@ arm_tls_referenced_p (rtx x)
return for_each_rtx (&x, arm_tls_operand_p_1, NULL);
}
/* Implement TARGET_LEGITIMATE_CONSTANT_P.
On the ARM, allow any integer (invalid ones are removed later by insn
patterns), nice doubles and symbol_refs which refer to the function's
constant pool XXX.
When generating pic allow anything. */
static bool
arm_legitimate_constant_p_1 (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
{
return flag_pic || !label_mentioned_p (x);
}
static bool
thumb_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
{
return (GET_CODE (x) == CONST_INT
|| GET_CODE (x) == CONST_DOUBLE
|| CONSTANT_ADDRESS_P (x)
|| flag_pic);
}
static bool
arm_legitimate_constant_p (enum machine_mode mode, rtx x)
{
return (!arm_cannot_force_const_mem (mode, x)
&& (TARGET_32BIT
? arm_legitimate_constant_p_1 (mode, x)
: thumb_legitimate_constant_p (mode, x)));
}
/* Implement TARGET_CANNOT_FORCE_CONST_MEM. */
bool
static bool
arm_cannot_force_const_mem (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
{
rtx base, offset;

21
gcc/config/arm/arm.h
View File

@ -1746,27 +1746,6 @@ typedef struct
#define TARGET_DEFAULT_WORD_RELOCATIONS 0
#endif
/* Nonzero if the constant value X is a legitimate general operand.
It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE.
On the ARM, allow any integer (invalid ones are removed later by insn
patterns), nice doubles and symbol_refs which refer to the function's
constant pool XXX.
When generating pic allow anything. */
#define ARM_LEGITIMATE_CONSTANT_P(X) (flag_pic || ! label_mentioned_p (X))
#define THUMB_LEGITIMATE_CONSTANT_P(X) \
( GET_CODE (X) == CONST_INT \
|| GET_CODE (X) == CONST_DOUBLE \
|| CONSTANT_ADDRESS_P (X) \
|| flag_pic)
#define LEGITIMATE_CONSTANT_P(X) \
(!arm_cannot_force_const_mem (VOIDmode, X) \
&& (TARGET_32BIT ? ARM_LEGITIMATE_CONSTANT_P (X) \
: THUMB_LEGITIMATE_CONSTANT_P (X)))
#ifndef SUBTARGET_NAME_ENCODING_LENGTHS
#define SUBTARGET_NAME_ENCODING_LENGTHS
#endif

2
gcc/config/avr/avr.h
View File

@ -421,8 +421,6 @@ do { \
} \
} while(0)
#define LEGITIMATE_CONSTANT_P(X) 1
#define BRANCH_COST(speed_p, predictable_p) 0
#define SLOW_BYTE_ACCESS 0

1
gcc/config/bfin/bfin-protos.h
View File

@ -73,7 +73,6 @@ extern char *bfin_asm_long (void);
extern char *bfin_asm_short (void);
extern int log2constp (unsigned HOST_WIDE_INT);
extern bool bfin_legitimate_constant_p (rtx);
extern int hard_regno_mode_ok (int, Mmode);
extern void init_cumulative_args (CUMULATIVE_ARGS *, tree, rtx);
extern HOST_WIDE_INT bfin_initial_elimination_offset (int, int);

9
gcc/config/bfin/bfin.c
View File

@ -2163,7 +2163,7 @@ expand_move (rtx *operands, enum machine_mode mode)
else if (mode == SImode && GET_CODE (op) == CONST
&& GET_CODE (XEXP (op, 0)) == PLUS
&& GET_CODE (XEXP (XEXP (op, 0), 0)) == SYMBOL_REF
&& !bfin_legitimate_constant_p (op))
&& !targetm.legitimate_constant_p (mode, op))
{
rtx dest = operands[0];
rtx op0, op1;
@ -3070,8 +3070,8 @@ bfin_cannot_force_const_mem (enum machine_mode mode ATTRIBUTE_UNUSED,
This ensures that flat binaries never have to deal with relocations
crossing section boundaries. */
bool
bfin_legitimate_constant_p (rtx x)
static bool
bfin_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
{
rtx sym;
HOST_WIDE_INT offset;
@ -6682,6 +6682,9 @@ bfin_conditional_register_usage (void)
#undef TARGET_DELEGITIMIZE_ADDRESS
#define TARGET_DELEGITIMIZE_ADDRESS bfin_delegitimize_address
#undef TARGET_LEGITIMATE_CONSTANT_P
#define TARGET_LEGITIMATE_CONSTANT_P bfin_legitimate_constant_p
#undef TARGET_CANNOT_FORCE_CONST_MEM
#define TARGET_CANNOT_FORCE_CONST_MEM bfin_cannot_force_const_mem

7
gcc/config/bfin/bfin.h
View File

@ -784,13 +784,6 @@ typedef struct {
/* Addressing Modes */
/* Nonzero if the constant value X is a legitimate general operand.
symbol_ref are not legitimate and will be put into constant pool.
See force_const_mem().
If -mno-pool, all constants are legitimate.
*/
#define LEGITIMATE_CONSTANT_P(X) bfin_legitimate_constant_p (X)
/* A number, the maximum number of registers that can appear in a
valid memory address. Note that it is up to you to specify a
value equal to the maximum number that `TARGET_LEGITIMATE_ADDRESS_P'

2
gcc/config/cris/cris.h
View File

@ -1020,8 +1020,6 @@ struct cum_args {int regs;};
} \
while (0)
#define LEGITIMATE_CONSTANT_P(X) 1
/* Node: Condition Code */

6
gcc/config/fr30/fr30.h
View File

@ -667,12 +667,6 @@ enum reg_class
will reload one or both registers only if neither labeling works. */
#define REG_OK_FOR_INDEX_P(X) REG_OK_FOR_BASE_P (X)
/* A C expression that is nonzero if X is a legitimate constant for an
immediate operand on the target machine. You can assume that X satisfies
`CONSTANT_P', so you need not check this. In fact, `1' is a suitable
definition for this macro on machines where anything `CONSTANT_P' is valid. */
#define LEGITIMATE_CONSTANT_P(X) 1
/*}}}*/
/*{{{ Describing Relative Costs of Operations */

1
gcc/config/frv/frv-protos.h
View File

@ -79,7 +79,6 @@ extern int frv_hard_regno_mode_ok (int, enum machine_mode);
extern int frv_hard_regno_nregs (int, enum machine_mode);
extern int frv_class_max_nregs (enum reg_class rclass,
enum machine_mode mode);
extern int frv_legitimate_constant_p (rtx);
extern enum machine_mode frv_select_cc_mode (enum rtx_code, rtx, rtx);
#endif /* RTX_CODE */

15
gcc/config/frv/frv.c
View File

@ -372,6 +372,7 @@ static int frv_memory_move_cost (enum machine_mode,
static void frv_asm_out_constructor (rtx, int);
static void frv_asm_out_destructor (rtx, int);
static bool frv_function_symbol_referenced_p (rtx);
static bool frv_legitimate_constant_p (enum machine_mode, rtx);
static bool frv_cannot_force_const_mem (enum machine_mode, rtx);
static const char *unspec_got_name (int);
static void frv_output_const_unspec (FILE *,
@ -472,6 +473,8 @@ static const struct default_options frv_option_optimization_table[] =
#undef TARGET_FUNCTION_OK_FOR_SIBCALL
#define TARGET_FUNCTION_OK_FOR_SIBCALL frv_function_ok_for_sibcall
#undef TARGET_LEGITIMATE_CONSTANT_P
#define TARGET_LEGITIMATE_CONSTANT_P frv_legitimate_constant_p
#undef TARGET_CANNOT_FORCE_CONST_MEM
#define TARGET_CANNOT_FORCE_CONST_MEM frv_cannot_force_const_mem
@ -603,7 +606,7 @@ frv_const_unspec_p (rtx x, struct frv_unspec *unspec)
We never allow constants to be forced into memory for TARGET_FDPIC.
This is necessary for several reasons:
1. Since LEGITIMATE_CONSTANT_P rejects constant pool addresses, the
1. Since frv_legitimate_constant_p rejects constant pool addresses, the
target-independent code will try to force them into the constant
pool, thus leading to infinite recursion.
@ -6749,16 +6752,14 @@ frv_class_max_nregs (enum reg_class rclass, enum machine_mode mode)
`CONSTANT_P', so you need not check this. In fact, `1' is a suitable
definition for this macro on machines where anything `CONSTANT_P' is valid. */
int
frv_legitimate_constant_p (rtx x)
static bool
frv_legitimate_constant_p (enum machine_mode mode, rtx x)
{
enum machine_mode mode = GET_MODE (x);
/* frv_cannot_force_const_mem always returns true for FDPIC. This
means that the move expanders will be expected to deal with most
kinds of constant, regardless of what we return here.
However, among its other duties, LEGITIMATE_CONSTANT_P decides whether
However, among its other duties, frv_legitimate_constant_p decides whether
a constant can be entered into reg_equiv_constant[]. If we return true,
reload can create new instances of the constant whenever it likes.
@ -6775,7 +6776,7 @@ frv_legitimate_constant_p (rtx x)
return TRUE;
/* double integer constants are ok. */
if (mode == VOIDmode || mode == DImode)
if (GET_MODE (x) == VOIDmode || mode == DImode)
return TRUE;
/* 0 is always ok. */

6
gcc/config/frv/frv.h
View File

@ -1502,12 +1502,6 @@ __asm__("\n" \
#define FIND_BASE_TERM frv_find_base_term
/* A C expression that is nonzero if X is a legitimate constant for an
immediate operand on the target machine. You can assume that X satisfies
`CONSTANT_P', so you need not check this. In fact, `1' is a suitable
definition for this macro on machines where anything `CONSTANT_P' is valid. */
#define LEGITIMATE_CONSTANT_P(X) frv_legitimate_constant_p (X)
/* The load-and-update commands allow pre-modification in addresses.
The index has to be in a register. */
#define HAVE_PRE_MODIFY_REG 1

2
gcc/config/h8300/h8300-protos.h
View File

@ -60,8 +60,6 @@ extern int byte_accesses_mergeable_p (rtx, rtx);
extern int same_cmp_preceding_p (rtx);
extern int same_cmp_following_p (rtx);
extern int h8300_legitimate_constant_p (rtx);
/* Used in builtins.c */
extern rtx h8300_return_addr_rtx (int, rtx);

8
gcc/config/h8300/h8300.c
View File

@ -5749,14 +5749,6 @@ h8300_hard_regno_scratch_ok (unsigned int regno)
}
/* Return nonzero if X is a legitimate constant. */
int
h8300_legitimate_constant_p (rtx x ATTRIBUTE_UNUSED)
{
return 1;
}
/* Return nonzero if X is a REG or SUBREG suitable as a base register. */
static int

5
gcc/config/h8300/h8300.h
View File

@ -528,11 +528,6 @@ struct cum_arg
&& INTVAL (X) < (TARGET_H8300 ? 0x10000 : 0x1000000)) \
|| (GET_CODE (X) == HIGH || GET_CODE (X) == CONST))
/* Nonzero if the constant value X is a legitimate general operand.
It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE. */
#define LEGITIMATE_CONSTANT_P(X) (h8300_legitimate_constant_p (X))
/* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
and check its validity for a certain class.
We have two alternate definitions for each of them.

1
gcc/config/i386/i386-protos.h
View File

@ -55,7 +55,6 @@ extern bool ix86_expand_movmem (rtx, rtx, rtx, rtx, rtx, rtx);
extern bool ix86_expand_setmem (rtx, rtx, rtx, rtx, rtx, rtx);
extern bool ix86_expand_strlen (rtx, rtx, rtx, rtx);
extern bool legitimate_constant_p (rtx);
extern bool constant_address_p (rtx);
extern bool legitimate_pic_operand_p (rtx);
extern bool legitimate_pic_address_disp_p (rtx);

18
gcc/config/i386/i386.c
View File

@ -11918,8 +11918,8 @@ darwin_local_data_pic (rtx disp)
/* Determine if a given RTX is a valid constant. We already know this
satisfies CONSTANT_P. */
bool
legitimate_constant_p (rtx x)
static bool
ix86_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
{
switch (GET_CODE (x))
{
@ -12005,7 +12005,7 @@ legitimate_constant_p (rtx x)
is checked above. */
static bool
ix86_cannot_force_const_mem (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
ix86_cannot_force_const_mem (enum machine_mode mode, rtx x)
{
/* We can always put integral constants and vectors in memory. */
switch (GET_CODE (x))
@ -12018,7 +12018,7 @@ ix86_cannot_force_const_mem (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
default:
break;
}
return !legitimate_constant_p (x);
return !ix86_legitimate_constant_p (mode, x);
}
@ -12356,7 +12356,8 @@ ix86_legitimate_address_p (enum machine_mode mode ATTRIBUTE_UNUSED,
/* Displacement is an invalid pic construct. */
return false;
#if TARGET_MACHO
else if (MACHO_DYNAMIC_NO_PIC_P && !legitimate_constant_p (disp))
else if (MACHO_DYNAMIC_NO_PIC_P
&& !ix86_legitimate_constant_p (Pmode, disp))
/* displacment must be referenced via non_lazy_pointer */
return false;
#endif
@ -12386,9 +12387,9 @@ ix86_legitimate_address_p (enum machine_mode mode ATTRIBUTE_UNUSED,
else if (GET_CODE (disp) != LABEL_REF
&& !CONST_INT_P (disp)
&& (GET_CODE (disp) != CONST
|| !legitimate_constant_p (disp))
|| !ix86_legitimate_constant_p (Pmode, disp))
&& (GET_CODE (disp) != SYMBOL_REF
|| !legitimate_constant_p (disp)))
|| !ix86_legitimate_constant_p (Pmode, disp)))
/* Displacement is not constant. */
return false;
else if (TARGET_64BIT
@ -35454,6 +35455,9 @@ ix86_autovectorize_vector_sizes (void)
#undef TARGET_LEGITIMATE_ADDRESS_P
#define TARGET_LEGITIMATE_ADDRESS_P ix86_legitimate_address_p
#undef TARGET_LEGITIMATE_CONSTANT_P
#define TARGET_LEGITIMATE_CONSTANT_P ix86_legitimate_constant_p
#undef TARGET_FRAME_POINTER_REQUIRED
#define TARGET_FRAME_POINTER_REQUIRED ix86_frame_pointer_required

5
gcc/config/i386/i386.h
View File

@ -1644,11 +1644,6 @@ typedef struct ix86_args {
#define CONSTANT_ADDRESS_P(X) constant_address_p (X)
/* Nonzero if the constant value X is a legitimate general operand.
It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE. */
#define LEGITIMATE_CONSTANT_P(X) legitimate_constant_p (X)
/* If defined, a C expression to determine the base term of address X.
This macro is used in only one place: `find_base_term' in alias.c.

6
gcc/config/i386/i386.md
View File

@ -4056,7 +4056,7 @@
"TARGET_80387 || (TARGET_SSE2 && TARGET_SSE_MATH)"
{
/* ??? Needed for compress_float_constant since all fp constants
are LEGITIMATE_CONSTANT_P. */
are TARGET_LEGITIMATE_CONSTANT_P. */
if (GET_CODE (operands[1]) == CONST_DOUBLE)
{
if ((!TARGET_SSE2 || TARGET_MIX_SSE_I387)
@ -4162,7 +4162,7 @@
"TARGET_80387"
{
/* ??? Needed for compress_float_constant since all fp constants
are LEGITIMATE_CONSTANT_P. */
are TARGET_LEGITIMATE_CONSTANT_P. */
if (GET_CODE (operands[1]) == CONST_DOUBLE)
{
if (standard_80387_constant_p (operands[1]) > 0)
@ -6076,7 +6076,7 @@
;; Convert lea to the lea pattern to avoid flags dependency.
;; ??? This pattern handles immediate operands that do not satisfy immediate
;; operand predicate (LEGITIMATE_CONSTANT_P) in the previous pattern.
;; operand predicate (TARGET_LEGITIMATE_CONSTANT_P) in the previous pattern.
(define_split
[(set (match_operand:DI 0 "register_operand" "")
(plus:DI (match_operand:DI 1 "register_operand" "")

2
gcc/config/ia64/ia64-protos.h
View File

@ -26,8 +26,6 @@ extern int ia64_st_address_bypass_p (rtx, rtx);
extern int ia64_ld_address_bypass_p (rtx, rtx);
extern int ia64_produce_address_p (rtx);
extern bool ia64_legitimate_constant_p (rtx);
extern rtx ia64_expand_move (rtx, rtx);
extern int ia64_move_ok (rtx, rtx);
extern int ia64_load_pair_ok (rtx, rtx);

29
gcc/config/ia64/ia64.c
View File

@ -316,6 +316,7 @@ static rtx ia64_struct_value_rtx (tree, int);
static tree ia64_gimplify_va_arg (tree, tree, gimple_seq *, gimple_seq *);
static bool ia64_scalar_mode_supported_p (enum machine_mode mode);
static bool ia64_vector_mode_supported_p (enum machine_mode mode);
static bool ia64_legitimate_constant_p (enum machine_mode, rtx);
static bool ia64_cannot_force_const_mem (enum machine_mode, rtx);
static const char *ia64_mangle_type (const_tree);
static const char *ia64_invalid_conversion (const_tree, const_tree);
@ -605,6 +606,9 @@ static const struct default_options ia64_option_optimization_table[] =
#undef TARGET_HANDLE_OPTION
#define TARGET_HANDLE_OPTION ia64_handle_option
#undef TARGET_LEGITIMATE_CONSTANT_P
#define TARGET_LEGITIMATE_CONSTANT_P ia64_legitimate_constant_p
#undef TARGET_CANNOT_FORCE_CONST_MEM
#define TARGET_CANNOT_FORCE_CONST_MEM ia64_cannot_force_const_mem
@ -953,8 +957,8 @@ tls_symbolic_operand_type (rtx addr)
/* Return true if X is a constant that is valid for some immediate
field in an instruction. */
bool
ia64_legitimate_constant_p (rtx x)
static bool
ia64_legitimate_constant_p (enum machine_mode mode, rtx x)
{
switch (GET_CODE (x))
{
@ -963,8 +967,7 @@ ia64_legitimate_constant_p (rtx x)
return true;
case CONST_DOUBLE:
if (GET_MODE (x) == VOIDmode || GET_MODE (x) == SFmode
|| GET_MODE (x) == DFmode)
if (GET_MODE (x) == VOIDmode || mode == SFmode || mode == DFmode)
return true;
return satisfies_constraint_G (x);
@ -986,25 +989,21 @@ ia64_legitimate_constant_p (rtx x)
op = XEXP (XEXP (op, 0), 0);
}
if (any_offset_symbol_operand (op, GET_MODE (op))
|| function_operand (op, GET_MODE (op)))
if (any_offset_symbol_operand (op, mode)
|| function_operand (op, mode))
return true;
if (aligned_offset_symbol_operand (op, GET_MODE (op)))
if (aligned_offset_symbol_operand (op, mode))
return (addend & 0x3fff) == 0;
return false;
}
return false;
case CONST_VECTOR:
{
enum machine_mode mode = GET_MODE (x);
if (mode == V2SFmode)
return satisfies_constraint_Y (x);
if (mode == V2SFmode)
return satisfies_constraint_Y (x);
return (GET_MODE_CLASS (mode) == MODE_VECTOR_INT
&& GET_MODE_SIZE (mode) <= 8);
}
return (GET_MODE_CLASS (mode) == MODE_VECTOR_INT
&& GET_MODE_SIZE (mode) <= 8);
default:
return false;

5
gcc/config/ia64/ia64.h
View File

@ -1200,11 +1200,6 @@ do { \
use as an index register. This is needed for POST_MODIFY. */
#define REG_OK_FOR_INDEX_P(X) REG_OK_FOR_BASE_P (X)
/* A C expression that is nonzero if X is a legitimate constant for an
immediate operand on the target machine. */
#define LEGITIMATE_CONSTANT_P(X) ia64_legitimate_constant_p (X)
/* Condition Code Status */

2
gcc/config/iq2000/iq2000.h
View File

@ -389,8 +389,6 @@ typedef struct iq2000_args
#define REG_OK_FOR_INDEX_P(X) 0
#define LEGITIMATE_CONSTANT_P(X) (1)
/* Describing Relative Costs of Operations. */

1
gcc/config/lm32/lm32-protos.h
View File

@ -36,4 +36,3 @@ extern rtx lm32_legitimize_pic_address (rtx, enum machine_mode, rtx);
extern void lm32_expand_scc (rtx operands[]);
extern void lm32_expand_conditional_branch (rtx operands[]);
extern bool lm32_move_ok (enum machine_mode, rtx operands[2]);
extern bool lm32_legitimate_constant_p (rtx);

11
gcc/config/lm32/lm32.c
View File

@ -81,6 +81,7 @@ static rtx lm32_function_arg (CUMULATIVE_ARGS * cum,
static void lm32_function_arg_advance (CUMULATIVE_ARGS * cum,
enum machine_mode mode,
const_tree type, bool named);
static bool lm32_legitimate_constant_p (enum machine_mode, rtx);
/* Implement TARGET_OPTION_OPTIMIZATION_TABLE. */
static const struct default_options lm32_option_optimization_table[] =
@ -119,6 +120,8 @@ static const struct default_options lm32_option_optimization_table[] =
#define TARGET_LEGITIMATE_ADDRESS_P lm32_legitimate_address_p
#undef TARGET_EXCEPT_UNWIND_INFO
#define TARGET_EXCEPT_UNWIND_INFO sjlj_except_unwind_info
#undef TARGET_LEGITIMATE_CONSTANT_P
#define TARGET_LEGITIMATE_CONSTANT_P lm32_legitimate_constant_p
struct gcc_target targetm = TARGET_INITIALIZER;
@ -1235,13 +1238,13 @@ lm32_move_ok (enum machine_mode mode, rtx operands[2]) {
return true;
}
/* Implement LEGITIMATE_CONSTANT_P. */
/* Implement TARGET_LEGITIMATE_CONSTANT_P. */
bool
lm32_legitimate_constant_p (rtx x)
static bool
lm32_legitimate_constant_p (enum machine_mode mode, rtx x)
{
/* 32-bit addresses require multiple instructions. */
if (!flag_pic && reloc_operand (x, GET_MODE (x)))
if (!flag_pic && reloc_operand (x, mode))
return false;
return true;

2
gcc/config/lm32/lm32.h
View File

@ -346,8 +346,6 @@ enum reg_class
#define REG_OK_FOR_BASE_P(X) NONSTRICT_REG_OK_FOR_BASE_P(X)
#endif
#define LEGITIMATE_CONSTANT_P(X) lm32_legitimate_constant_p (X)
/*-------------------------*/
/* Condition Code Status. */
/*-------------------------*/

1
gcc/config/m32c/m32c-protos.h
View File

@ -65,7 +65,6 @@ int m32c_hard_regno_ok (int, MM);
bool m32c_illegal_subreg_p (rtx);
bool m32c_immd_dbl_mov (rtx *, MM);
rtx m32c_incoming_return_addr_rtx (void);
int m32c_legitimate_constant_p (rtx);
int m32c_legitimize_reload_address (rtx *, MM, int, int, int);
int m32c_limit_reload_class (MM, int);
int m32c_modes_tieable_p (MM, MM);

9
gcc/config/m32c/m32c.c
View File

@ -2148,15 +2148,6 @@ m32c_legitimize_reload_address (rtx * x,
return 0;
}
/* Implements LEGITIMATE_CONSTANT_P. We split large constants anyway,
so we can allow anything. */
int
m32c_legitimate_constant_p (rtx x ATTRIBUTE_UNUSED)
{
return 1;
}
/* Return the appropriate mode for a named address pointer. */
#undef TARGET_ADDR_SPACE_POINTER_MODE
#define TARGET_ADDR_SPACE_POINTER_MODE m32c_addr_space_pointer_mode

2
gcc/config/m32c/m32c.h
View File

@ -570,8 +570,6 @@ typedef struct m32c_cumulative_args
if (m32c_legitimize_reload_address(&(X),MODE,OPNUM,TYPE,IND_LEVELS)) \
goto WIN;
#define LEGITIMATE_CONSTANT_P(X) m32c_legitimate_constant_p (X)
/* Address spaces. */
#define ADDR_SPACE_FAR 1

22
gcc/config/m32r/m32r.c
View File

@ -99,6 +99,7 @@ static void m32r_function_arg_advance (CUMULATIVE_ARGS *, enum machine_mode,
static bool m32r_can_eliminate (const int, const int);
static void m32r_conditional_register_usage (void);
static void m32r_trampoline_init (rtx, tree, rtx);
static bool m32r_legitimate_constant_p (enum machine_mode, rtx);
/* M32R specific attributes. */
@ -211,6 +212,9 @@ static const struct default_options m32r_option_optimization_table[] =
#undef TARGET_TRAMPOLINE_INIT
#define TARGET_TRAMPOLINE_INIT m32r_trampoline_init
#undef TARGET_LEGITIMATE_CONSTANT_P
#define TARGET_LEGITIMATE_CONSTANT_P m32r_legitimate_constant_p
#undef TARGET_EXCEPT_UNWIND_INFO
#define TARGET_EXCEPT_UNWIND_INFO sjlj_except_unwind_info
@ -2935,3 +2939,21 @@ m32r_conditional_register_usage (void)
call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1;
}
}
/* Implement TARGET_LEGITIMATE_CONSTANT_P
We don't allow (plus symbol large-constant) as the relocations can't
describe it. INTVAL > 32767 handles both 16-bit and 24-bit relocations.
We allow all CONST_DOUBLE's as the md file patterns will force the
constant to memory if they can't handle them. */
static bool
m32r_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
{
return !(GET_CODE (x) == CONST
&& GET_CODE (XEXP (x, 0)) == PLUS
&& (GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
|| GET_CODE (XEXP (XEXP (x, 0), 0)) == LABEL_REF)
&& CONST_INT_P (XEXP (XEXP (x, 0), 1))
&& UINTVAL (XEXP (XEXP (x, 0), 1)) > 32767);
}

13
gcc/config/m32r/m32r.h
View File

@ -749,19 +749,6 @@ L2: .word STATIC
|| CONST_INT_P (X) \
|| (GET_CODE (X) == CONST \
&& ! (flag_pic && ! m32r_legitimate_pic_operand_p (X))))
/* Nonzero if the constant value X is a legitimate general operand.
We don't allow (plus symbol large-constant) as the relocations can't
describe it. INTVAL > 32767 handles both 16-bit and 24-bit relocations.
We allow all CONST_DOUBLE's as the md file patterns will force the
constant to memory if they can't handle them. */
#define LEGITIMATE_CONSTANT_P(X) \
(! (GET_CODE (X) == CONST \
&& GET_CODE (XEXP (X, 0)) == PLUS \
&& (GET_CODE (XEXP (XEXP (X, 0), 0)) == SYMBOL_REF || GET_CODE (XEXP (XEXP (X, 0), 0)) == LABEL_REF) \
&& CONST_INT_P (XEXP (XEXP (X, 0), 1)) \
&& (unsigned HOST_WIDE_INT) INTVAL (XEXP (XEXP (X, 0), 1)) > 32767))
/* Condition code usage. */

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

@ -56,6 +56,7 @@ extern void notice_update_cc (rtx, rtx);
extern bool m68k_legitimate_base_reg_p (rtx, bool);
extern bool m68k_legitimate_index_reg_p (rtx, bool);
extern bool m68k_illegitimate_symbolic_constant_p (rtx);
extern bool m68k_legitimate_constant_p (enum machine_mode, rtx);
extern bool m68k_matches_q_p (rtx);
extern bool m68k_matches_u_p (rtx);
extern rtx legitimize_pic_address (rtx, enum machine_mode, rtx);

13
gcc/config/m68k/m68k.c
View File

@ -299,6 +299,9 @@ const char *m68k_library_id_string = "_current_shared_library_a5_offset_";
#undef TARGET_FUNCTION_ARG_ADVANCE
#define TARGET_FUNCTION_ARG_ADVANCE m68k_function_arg_advance
#undef TARGET_LEGITIMATE_CONSTANT_P
#define TARGET_LEGITIMATE_CONSTANT_P m68k_legitimate_constant_p
static const struct attribute_spec m68k_attribute_table[] =
{
/* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
@ -1034,7 +1037,7 @@ m68k_expand_prologue (void)
&& GET_CODE (stack_limit_rtx) == SYMBOL_REF)
{
limit = plus_constant (stack_limit_rtx, current_frame.size + 4);
if (!LEGITIMATE_CONSTANT_P (limit))
if (!m68k_legitimate_constant_p (Pmode, limit))
{
emit_move_insn (gen_rtx_REG (Pmode, D0_REG), limit);
limit = gen_rtx_REG (Pmode, D0_REG);
@ -2163,6 +2166,14 @@ m68k_legitimate_mem_p (rtx x, struct m68k_address *address)
address));
}
/* Implement TARGET_LEGITIMATE_CONSTANT_P. */
bool
m68k_legitimate_constant_p (enum machine_mode mode, rtx x)
{
return mode != XFmode && !m68k_illegitimate_symbolic_constant_p (x);
}
/* Return true if X matches the 'Q' constraint. It must be a memory
with a base address and no constant offset or index. */

8
gcc/config/m68k/m68k.h
View File

@ -664,13 +664,7 @@ __transfer_from_trampoline () \
((GET_CODE (X) == LABEL_REF || GET_CODE (X) == SYMBOL_REF \
|| GET_CODE (X) == CONST_INT || GET_CODE (X) == CONST \
|| GET_CODE (X) == HIGH) \
&& LEGITIMATE_CONSTANT_P (X))
/* Nonzero if the constant value X is a legitimate general operand.
It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE. */
#define LEGITIMATE_CONSTANT_P(X) \
(GET_MODE (X) != XFmode \
&& !m68k_illegitimate_symbolic_constant_p (X))
&& m68k_legitimate_constant_p (Pmode, X))
#ifndef REG_OK_STRICT
#define REG_STRICT_P 0

2
gcc/config/m68k/m68k.md
View File

@ -1383,7 +1383,7 @@
;; ??? The XFmode patterns are schizophrenic about whether constants are
;; allowed. Most but not all have predicates and constraint that disallow
;; constants. Most but not all have output templates that handle constants.
;; See also LEGITIMATE_CONSTANT_P.
;; See also TARGET_LEGITIMATE_CONSTANT_P.
(define_expand "movxf"
[(set (match_operand:XF 0 "nonimmediate_operand" "")

14
gcc/config/mcore/mcore.c
View File

@ -138,6 +138,7 @@ static unsigned int mcore_function_arg_boundary (enum machine_mode,
static void mcore_asm_trampoline_template (FILE *);
static void mcore_trampoline_init (rtx, tree, rtx);
static void mcore_option_override (void);
static bool mcore_legitimate_constant_p (enum machine_mode, rtx);
/* MCore specific attributes. */
@ -247,6 +248,9 @@ static const struct default_options mcore_option_optimization_table[] =
#undef TARGET_EXCEPT_UNWIND_INFO
#define TARGET_EXCEPT_UNWIND_INFO sjlj_except_unwind_info
#undef TARGET_LEGITIMATE_CONSTANT_P
#define TARGET_LEGITIMATE_CONSTANT_P mcore_legitimate_constant_p
struct gcc_target targetm = TARGET_INITIALIZER;
/* Adjust the stack and return the number of bytes taken to do it. */
@ -3205,3 +3209,13 @@ mcore_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value)
mem = adjust_address (m_tramp, SImode, 12);
emit_move_insn (mem, fnaddr);
}
/* Implement TARGET_LEGITIMATE_CONSTANT_P
On the MCore, allow anything but a double. */
static bool
mcore_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
{
return GET_CODE (x) != CONST_DOUBLE;
}

7
gcc/config/mcore/mcore.h
View File

@ -529,13 +529,6 @@ extern const enum reg_class regno_reg_class[FIRST_PSEUDO_REGISTER];
/* Recognize any constant value that is a valid address. */
#define CONSTANT_ADDRESS_P(X) (GET_CODE (X) == LABEL_REF)
/* Nonzero if the constant value X is a legitimate general operand.
It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE.
On the MCore, allow anything but a double. */
#define LEGITIMATE_CONSTANT_P(X) (GET_CODE(X) != CONST_DOUBLE \
&& CONSTANT_P (X))
/* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
and check its validity for a certain class.
We have two alternate definitions for each of them.

1
gcc/config/mep/mep-protos.h
View File

@ -43,7 +43,6 @@ extern void mep_split_wide_move (rtx *, enum machine_mode);
#ifdef RTX_CODE
extern bool mep_expand_setcc (rtx *);
extern rtx mep_expand_cbranch (rtx *);
extern bool mep_legitimate_constant_p (rtx);
#endif
extern const char *mep_emit_cbranch (rtx *, int);
extern void mep_expand_call (rtx *, int);

9
gcc/config/mep/mep.c
View File

@ -1195,9 +1195,10 @@ mep_multi_slot (rtx x)
return get_attr_slot (x) == SLOT_MULTI;
}
/* Implement TARGET_LEGITIMATE_CONSTANT_P. */
bool
mep_legitimate_constant_p (rtx x)
static bool
mep_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
{
/* We can't convert symbol values to gp- or tp-rel values after
reload, as reload might have used $gp or $tp for other
@ -1300,7 +1301,7 @@ mep_legitimate_address (enum machine_mode mode, rtx x, int strict)
if ((mode == SImode || mode == SFmode)
&& CONSTANT_P (x)
&& LEGITIMATE_CONSTANT_P (x)
&& mep_legitimate_constant_p (mode, x)
&& the_tag != 't' && the_tag != 'b')
{
if (GET_CODE (x) != CONST_INT
@ -7477,6 +7478,8 @@ mep_asm_init_sections (void)
#define TARGET_CONDITIONAL_REGISTER_USAGE mep_conditional_register_usage
#undef TARGET_TRAMPOLINE_INIT
#define TARGET_TRAMPOLINE_INIT mep_trampoline_init
#undef TARGET_LEGITIMATE_CONSTANT_P
#define TARGET_LEGITIMATE_CONSTANT_P mep_legitimate_constant_p
struct gcc_target targetm = TARGET_INITIALIZER;

3
gcc/config/mep/mep.h
View File

@ -566,9 +566,6 @@ typedef struct
#define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR, LABEL)
#define LEGITIMATE_CONSTANT_P(X) \
mep_legitimate_constant_p(X)
#define SELECT_CC_MODE(OP, X, Y) CCmode

1
gcc/config/microblaze/microblaze-protos.h
View File

@ -35,7 +35,6 @@ extern void microblaze_expand_divide (rtx *);
extern void microblaze_expand_conditional_branch (enum machine_mode, rtx *);
extern void microblaze_expand_conditional_branch_sf (rtx *);
extern int microblaze_can_use_return_insn (void);
extern int microblaze_const_double_ok (rtx, enum machine_mode);
extern void print_operand (FILE *, rtx, int);
extern void print_operand_address (FILE *, rtx);
extern void init_cumulative_args (CUMULATIVE_ARGS *,tree, rtx);

19
gcc/config/microblaze/microblaze.c
View File

@ -152,7 +152,7 @@ int microblaze_no_unsafe_delay;
enum pipeline_type microblaze_pipe = MICROBLAZE_PIPE_5;
/* High and low marks for floating point values which we will accept
as legitimate constants for LEGITIMATE_CONSTANT_P. These are
as legitimate constants for TARGET_LEGITIMATE_CONSTANT_P. These are
initialized in override_options. */
REAL_VALUE_TYPE dfhigh, dflow, sfhigh, sflow;
@ -210,7 +210,7 @@ static int microblaze_interrupt_function_p (tree);
section *sdata2_section;
/* Return truth value if a CONST_DOUBLE is ok to be a legitimate constant. */
int
static bool
microblaze_const_double_ok (rtx op, enum machine_mode mode)
{
REAL_VALUE_TYPE d;
@ -218,7 +218,7 @@ microblaze_const_double_ok (rtx op, enum machine_mode mode)
if (GET_CODE (op) != CONST_DOUBLE)
return 0;
if (mode == VOIDmode)
if (GET_MODE (op) == VOIDmode)
return 1;
if (mode != SFmode && mode != DFmode)
@ -2951,6 +2951,16 @@ microblaze_adjust_cost (rtx insn ATTRIBUTE_UNUSED, rtx link,
return 0;
return cost;
}
/* Implement TARGET_LEGITIMATE_CONSTANT_P.
At present, GAS doesn't understand li.[sd], so don't allow it
to be generated at present. */
static bool
microblaze_legitimate_constant_p (enum machine_mode mode, rtx x)
{
return GET_CODE (x) != CONST_DOUBLE || microblaze_const_double_ok (x, mode);
}
#undef TARGET_ENCODE_SECTION_INFO
#define TARGET_ENCODE_SECTION_INFO microblaze_encode_section_info
@ -3040,6 +3050,9 @@ microblaze_adjust_cost (rtx insn ATTRIBUTE_UNUSED, rtx link,
#undef TARGET_EXCEPT_UNWIND_INFO
#define TARGET_EXCEPT_UNWIND_INFO sjlj_except_unwind_info
#undef TARGET_LEGITIMATE_CONSTANT_P
#define TARGET_LEGITIMATE_CONSTANT_P microblaze_legitimate_constant_p
struct gcc_target targetm = TARGET_INITIALIZER;
#include "gt-microblaze.h"

6
gcc/config/microblaze/microblaze.h
View File

@ -524,12 +524,6 @@ typedef struct microblaze_args
addresses which require two reload registers. */
#define LEGITIMATE_PIC_OPERAND_P(X) (!pic_address_needs_scratch (X))
/* At present, GAS doesn't understand li.[sd], so don't allow it
to be generated at present. */
#define LEGITIMATE_CONSTANT_P(X) \
(GET_CODE (X) != CONST_DOUBLE \
|| microblaze_const_double_ok (X, GET_MODE (X)))
#define CASE_VECTOR_MODE (SImode)
#ifndef DEFAULT_SIGNED_CHAR

15
gcc/config/mips/mips.c
View File

@ -1535,6 +1535,14 @@ mips_build_integer (struct mips_integer_op *codes,
}
}
/* Implement TARGET_LEGITIMATE_CONSTANT_P. */
static bool
mips_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
{
return mips_const_insns (x) > 0;
}
/* Return true if symbols of type TYPE require a GOT access. */
static bool
@ -1997,7 +2005,7 @@ mips_tls_symbol_ref_1 (rtx *x, void *data ATTRIBUTE_UNUSED)
/* Implement TARGET_CANNOT_FORCE_CONST_MEM. */
static bool
mips_cannot_force_const_mem (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
mips_cannot_force_const_mem (enum machine_mode mode, rtx x)
{
enum mips_symbol_type type;
rtx base, offset;
@ -2016,7 +2024,7 @@ mips_cannot_force_const_mem (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
references, reload will consider forcing C into memory and using
one of the instruction's memory alternatives. Returning false
here will force it to use an input reload instead. */
if (CONST_INT_P (x) && LEGITIMATE_CONSTANT_P (x))
if (CONST_INT_P (x) && mips_legitimate_constant_p (mode, x))
return true;
split_const (x, &base, &offset);
@ -16572,6 +16580,9 @@ mips_shift_truncation_mask (enum machine_mode mode)
#undef TARGET_CANNOT_FORCE_CONST_MEM
#define TARGET_CANNOT_FORCE_CONST_MEM mips_cannot_force_const_mem
#undef TARGET_LEGITIMATE_CONSTANT_P
#define TARGET_LEGITIMATE_CONSTANT_P mips_legitimate_constant_p
#undef TARGET_ENCODE_SECTION_INFO
#define TARGET_ENCODE_SECTION_INFO mips_encode_section_info

2
gcc/config/mips/mips.h
View File

@ -2317,8 +2317,6 @@ typedef struct mips_args {
#define CONSTANT_ADDRESS_P(X) \
(CONSTANT_P (X) && memory_address_p (SImode, X))
#define LEGITIMATE_CONSTANT_P(X) (mips_const_insns (X) > 0)
/* This handles the magic '..CURRENT_FUNCTION' symbol, which means
'the start of the function that this code is output in'. */

2
gcc/config/mips/predicates.md
View File

@ -173,7 +173,7 @@
(define_predicate "splittable_const_int_operand"
(match_code "const_int")
{
/* When generating mips16 code, LEGITIMATE_CONSTANT_P rejects
/* When generating mips16 code, TARGET_LEGITIMATE_CONSTANT_P rejects
CONST_INTs that can't be loaded using simple insns. */
if (TARGET_MIPS16)
return false;

1
gcc/config/mmix/mmix-protos.h
View File

@ -73,7 +73,6 @@ extern rtx mmix_return_addr_rtx (int, rtx);
extern rtx mmix_eh_return_stackadj_rtx (void);
extern rtx mmix_eh_return_handler_rtx (void);
extern int mmix_constant_address_p (rtx);
extern int mmix_legitimate_constant_p (rtx);
extern void mmix_print_operand (FILE *, rtx, int);
extern void mmix_print_operand_address (FILE *, rtx);
extern void mmix_expand_prologue (void);

11
gcc/config/mmix/mmix.c
View File

@ -130,6 +130,7 @@ static void mmix_target_asm_function_prologue (FILE *, HOST_WIDE_INT);
static void mmix_target_asm_function_end_prologue (FILE *);
static void mmix_target_asm_function_epilogue (FILE *, HOST_WIDE_INT);
static bool mmix_legitimate_address_p (enum machine_mode, rtx, bool);
static bool mmix_legitimate_constant_p (enum machine_mode, rtx);
static void mmix_reorg (void);
static void mmix_asm_output_mi_thunk
(FILE *, tree, HOST_WIDE_INT, HOST_WIDE_INT, tree);
@ -252,6 +253,8 @@ static const struct default_options mmix_option_optimization_table[] =
#undef TARGET_LEGITIMATE_ADDRESS_P
#define TARGET_LEGITIMATE_ADDRESS_P mmix_legitimate_address_p
#undef TARGET_LEGITIMATE_CONSTANT_P
#define TARGET_LEGITIMATE_CONSTANT_P mmix_legitimate_constant_p
#undef TARGET_FRAME_POINTER_REQUIRED
#define TARGET_FRAME_POINTER_REQUIRED mmix_frame_pointer_required
@ -1152,10 +1155,10 @@ mmix_legitimate_address_p (enum machine_mode mode ATTRIBUTE_UNUSED,
return TARGET_BASE_ADDRESSES && mmix_constant_address_p (x);
}
/* LEGITIMATE_CONSTANT_P. */
/* Implement TARGET_LEGITIMATE_CONSTANT_P. */
int
mmix_legitimate_constant_p (rtx x)
static bool
mmix_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
{
RTX_CODE code = GET_CODE (x);
@ -1829,7 +1832,7 @@ mmix_print_operand_address (FILE *stream, rtx x)
}
}
if (TARGET_BASE_ADDRESSES && mmix_legitimate_constant_p (x))
if (TARGET_BASE_ADDRESSES && mmix_legitimate_constant_p (Pmode, x))
{
output_addr_const (stream, x);
return;

3
gcc/config/mmix/mmix.h
View File

@ -614,9 +614,6 @@ typedef struct { int regs; int lib; } CUMULATIVE_ARGS;
#define REG_OK_FOR_INDEX_P(X) REG_OK_FOR_BASE_P (X)
#define LEGITIMATE_CONSTANT_P(X) \
mmix_legitimate_constant_p (X)
/* Node: Condition Code */

1
gcc/config/mn10300/mn10300-protos.h
View File

@ -30,7 +30,6 @@ extern rtx mn10300_legitimize_reload_address (rtx, Mmode, int, int, int);
extern bool mn10300_function_value_regno_p (const unsigned int);
extern int mn10300_get_live_callee_saved_regs (void);
extern bool mn10300_hard_regno_mode_ok (unsigned int, Mmode);
extern bool mn10300_legitimate_constant_p (rtx);
extern bool mn10300_modes_tieable (Mmode, Mmode);
extern Cstar mn10300_output_add (rtx[3], bool);
extern void mn10300_print_operand (FILE *, rtx, int);

8
gcc/config/mn10300/mn10300.c
View File

@ -2051,13 +2051,13 @@ mn10300_legitimize_reload_address (rtx x,
return any_change ? x : NULL_RTX;
}
/* Used by LEGITIMATE_CONSTANT_P(). Returns TRUE if X is a valid
/* Implement TARGET_LEGITIMATE_CONSTANT_P. Returns TRUE if X is a valid
constant. Note that some "constants" aren't valid, such as TLS
symbols and unconverted GOT-based references, so we eliminate
those here. */
bool
mn10300_legitimate_constant_p (rtx x)
static bool
mn10300_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
{
switch (GET_CODE (x))
{
@ -3209,6 +3209,8 @@ mn10300_reorg (void)
#define TARGET_LEGITIMATE_ADDRESS_P mn10300_legitimate_address_p
#undef TARGET_DELEGITIMIZE_ADDRESS
#define TARGET_DELEGITIMIZE_ADDRESS mn10300_delegitimize_address
#undef TARGET_LEGITIMATE_CONSTANT_P
#define TARGET_LEGITIMATE_CONSTANT_P mn10300_legitimate_constant_p
#undef TARGET_PREFERRED_RELOAD_CLASS
#define TARGET_PREFERRED_RELOAD_CLASS mn10300_preferred_reload_class

4
gcc/config/mn10300/mn10300.h
View File

@ -557,10 +557,6 @@ do { \
} while (0)
/* Nonzero if the constant value X is a legitimate general operand.
It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE. */
#define LEGITIMATE_CONSTANT_P(X) mn10300_legitimate_constant_p (X)
/* Zero if this needs fixing up to become PIC. */
#define LEGITIMATE_PIC_OPERAND_P(X) \

4
gcc/config/moxie/moxie.h
View File

@ -441,10 +441,6 @@ enum reg_class
/* All load operations zero extend. */
#define LOAD_EXTEND_OP(MEM) ZERO_EXTEND
/* A C expression that is nonzero if X is a legitimate constant for
an immediate operand on the target machine. */
#define LEGITIMATE_CONSTANT_P(X) 1
/* A number, the maximum number of registers that can appear in a
valid memory address. */
#define MAX_REGS_PER_ADDRESS 1

40
gcc/config/pa/pa.c
View File

@ -188,6 +188,7 @@ static void pa_conditional_register_usage (void);
static enum machine_mode pa_c_mode_for_suffix (char);
static section *pa_function_section (tree, enum node_frequency, bool, bool);
static bool pa_cannot_force_const_mem (enum machine_mode, rtx);
static bool pa_legitimate_constant_p (enum machine_mode, rtx);
/* The following extra sections are only used for SOM. */
static GTY(()) section *som_readonly_data_section;
@ -397,6 +398,9 @@ static const struct default_options pa_option_optimization_table[] =
#undef TARGET_ASM_FUNCTION_SECTION
#define TARGET_ASM_FUNCTION_SECTION pa_function_section
#undef TARGET_LEGITIMATE_CONSTANT_P
#define TARGET_LEGITIMATE_CONSTANT_P pa_legitimate_constant_p
struct gcc_target targetm = TARGET_INITIALIZER;
/* Parse the -mfixed-range= option string. */
@ -10276,4 +10280,40 @@ pa_function_section (tree decl, enum node_frequency freq,
return default_function_section (decl, freq, startup, exit);
}
/* Implement TARGET_LEGITIMATE_CONSTANT_P.
In 64-bit mode, we reject CONST_DOUBLES. We also reject CONST_INTS
that need more than three instructions to load prior to reload. This
limit is somewhat arbitrary. It takes three instructions to load a
CONST_INT from memory but two are memory accesses. It may be better
to increase the allowed range for CONST_INTS. We may also be able
to handle CONST_DOUBLES. */
static bool
pa_legitimate_constant_p (enum machine_mode mode, rtx x)
{
if (GET_MODE_CLASS (mode) == MODE_FLOAT && x != CONST0_RTX (mode))
return false;
if (!NEW_HP_ASSEMBLER && !TARGET_GAS && GET_CODE (x) == LABEL_REF)
return false;
if (TARGET_64BIT && GET_CODE (x) == CONST_DOUBLE)
return false;
if (TARGET_64BIT
&& HOST_BITS_PER_WIDE_INT > 32
&& GET_CODE (x) == CONST_INT
&& !reload_in_progress
&& !reload_completed
&& !LEGITIMATE_64BIT_CONST_INT_P (INTVAL (x))
&& !cint_ok_for_move (INTVAL (x)))
return false;
if (function_label_operand (x, mode))
return false;
return true;
}
#include "gt-pa.h"

31
gcc/config/pa/pa.h
View File

@ -806,37 +806,6 @@ extern int may_call_alloca;
#define LEGITIMATE_64BIT_CONST_INT_P(X) \
((X) >= MIN_LEGIT_64BIT_CONST_INT && (X) < MAX_LEGIT_64BIT_CONST_INT)
/* A C expression that is nonzero if X is a legitimate constant for an
immediate operand.
We include all constant integers and constant doubles, but not
floating-point, except for floating-point zero. We reject LABEL_REFs
if we're not using gas or the new HP assembler.
In 64-bit mode, we reject CONST_DOUBLES. We also reject CONST_INTS
that need more than three instructions to load prior to reload. This
limit is somewhat arbitrary. It takes three instructions to load a
CONST_INT from memory but two are memory accesses. It may be better
to increase the allowed range for CONST_INTS. We may also be able
to handle CONST_DOUBLES. */
#define LEGITIMATE_CONSTANT_P(X) \
((GET_MODE_CLASS (GET_MODE (X)) != MODE_FLOAT \
|| (X) == CONST0_RTX (GET_MODE (X))) \
&& (NEW_HP_ASSEMBLER \
|| TARGET_GAS \
|| GET_CODE (X) != LABEL_REF) \
&& (!TARGET_64BIT \
|| GET_CODE (X) != CONST_DOUBLE) \
&& (!TARGET_64BIT \
|| HOST_BITS_PER_WIDE_INT <= 32 \
|| GET_CODE (X) != CONST_INT \
|| reload_in_progress \
|| reload_completed \
|| LEGITIMATE_64BIT_CONST_INT_P (INTVAL (X)) \
|| cint_ok_for_move (INTVAL (X))) \
&& !function_label_operand (X, VOIDmode))
/* Target flags set on a symbol_ref. */
/* Set by ASM_OUTPUT_SYMBOL_REF when a symbol_ref is output. */

12
gcc/config/pdp11/pdp11.c
View File

@ -157,6 +157,7 @@ static rtx pdp11_function_arg (CUMULATIVE_ARGS *, enum machine_mode,
static void pdp11_function_arg_advance (CUMULATIVE_ARGS *,
enum machine_mode, const_tree, bool);
static void pdp11_conditional_register_usage (void);
static bool pdp11_legitimate_constant_p (enum machine_mode, rtx);
/* Implement TARGET_OPTION_OPTIMIZATION_TABLE. */
@ -243,6 +244,9 @@ static const struct default_options pdp11_option_optimization_table[] =
#undef TARGET_PRINT_OPERAND_PUNCT_VALID_P
#define TARGET_PRINT_OPERAND_PUNCT_VALID_P pdp11_asm_print_operand_punct_valid_p
#undef TARGET_LEGITIMATE_CONSTANT_P
#define TARGET_LEGITIMATE_CONSTANT_P pdp11_legitimate_constant_p
/* Implement TARGET_HANDLE_OPTION. */
@ -1926,4 +1930,12 @@ pdp11_function_section (tree decl ATTRIBUTE_UNUSED,
return NULL;
}
/* Implement TARGET_LEGITIMATE_CONSTANT_P. */
static bool
pdp11_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
{
return GET_CODE (x) != CONST_DOUBLE || legitimate_const_double_p (x);
}
struct gcc_target targetm = TARGET_INITIALIZER;

6
gcc/config/pdp11/pdp11.h
View File

@ -418,12 +418,6 @@ extern int may_call_alloca;
#define MAX_REGS_PER_ADDRESS 1
/* Nonzero if the constant value X is a legitimate general operand.
It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE. */
#define LEGITIMATE_CONSTANT_P(X) \
(GET_CODE (X) != CONST_DOUBLE || legitimate_const_double_p (X))
/* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
and check its validity for a certain class.
We have two alternate definitions for each of them.

5
gcc/config/picochip/picochip.h
View File

@ -452,11 +452,6 @@ do { \
goto WIN; \
} while(0); \
/* Nonzero if the constant rtx X is a legitimate general operand. X
satisfies CONSTANT_P. */
#define LEGITIMATE_CONSTANT_P(X) 1
/* Condition Code Status */

21
gcc/config/rs6000/rs6000.c
View File

@ -1213,6 +1213,7 @@ static bool rs6000_can_eliminate (const int, const int);
static void rs6000_conditional_register_usage (void);
static void rs6000_trampoline_init (rtx, tree, rtx);
static bool rs6000_cannot_force_const_mem (enum machine_mode, rtx);
static bool rs6000_legitimate_constant_p (enum machine_mode, rtx);
/* Hash table stuff for keeping track of TOC entries. */
@ -1670,6 +1671,9 @@ static const struct default_options rs6000_option_optimization_table[] =
#undef TARGET_SET_CURRENT_FUNCTION
#define TARGET_SET_CURRENT_FUNCTION rs6000_set_current_function
#undef TARGET_LEGITIMATE_CONSTANT_P
#define TARGET_LEGITIMATE_CONSTANT_P rs6000_legitimate_constant_p
struct gcc_target targetm = TARGET_INITIALIZER;
@ -28275,5 +28279,22 @@ rs6000_address_for_altivec (rtx x)
return x;
}
/* Implement TARGET_LEGITIMATE_CONSTANT_P.
On the RS/6000, all integer constants are acceptable, most won't be valid
for particular insns, though. Only easy FP constants are acceptable. */
static bool
rs6000_legitimate_constant_p (enum machine_mode mode, rtx x)
{
if (rs6000_tls_referenced_p (x))
return false;
return ((GET_CODE (x) != CONST_DOUBLE && GET_CODE (x) != CONST_VECTOR)
|| GET_MODE (x) == VOIDmode
|| (TARGET_POWERPC64 && mode == DImode)
|| easy_fp_constant (x, mode)
|| easy_vector_constant (x, mode));
}
#include "gt-rs6000.h"

16
gcc/config/rs6000/rs6000.h
View File

@ -1728,22 +1728,6 @@ typedef struct rs6000_args
|| GET_CODE (X) == CONST_INT || GET_CODE (X) == CONST \
|| GET_CODE (X) == HIGH)
/* Nonzero if the constant value X is a legitimate general operand.
It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE.
On the RS/6000, all integer constants are acceptable, most won't be valid
for particular insns, though. Only easy FP constants are
acceptable. */
#define LEGITIMATE_CONSTANT_P(X) \
(((GET_CODE (X) != CONST_DOUBLE \
&& GET_CODE (X) != CONST_VECTOR) \
|| GET_MODE (X) == VOIDmode \
|| (TARGET_POWERPC64 && GET_MODE (X) == DImode) \
|| easy_fp_constant (X, GET_MODE (X)) \
|| easy_vector_constant (X, GET_MODE (X))) \
&& !rs6000_tls_referenced_p (X))
#define EASY_VECTOR_15(n) ((n) >= -16 && (n) <= 15)
#define EASY_VECTOR_15_ADD_SELF(n) (!EASY_VECTOR_15((n)) \
&& EASY_VECTOR_15((n) >> 1) \

2
gcc/config/rx/rx-protos.h
View File

@ -36,7 +36,7 @@ extern void rx_emit_stack_popm (rtx *, bool);
extern void rx_emit_stack_pushm (rtx *);
extern void rx_expand_epilogue (bool);
extern char * rx_gen_move_template (rtx *, bool);
extern bool rx_is_legitimate_constant (rtx);
extern bool rx_legitimate_constant_p (enum machine_mode, rtx);
extern bool rx_is_restricted_memory_address (rtx, Mmode);
extern bool rx_match_ccmode (rtx, Mmode);
extern void rx_notice_update_cc (rtx body, rtx insn);

7
gcc/config/rx/rx.c
View File

@ -1347,7 +1347,7 @@ gen_safe_add (rtx dest, rtx src, rtx val, bool is_frame_related)
insn = emit_insn (gen_addsi3 (dest, src, val));
else
{
/* Wrap VAL in an UNSPEC so that rx_is_legitimate_constant
/* Wrap VAL in an UNSPEC so that rx_legitimate_constant_p
will not reject it. */
val = gen_rtx_CONST (SImode, gen_rtx_UNSPEC (SImode, gen_rtvec (1, val), UNSPEC_CONST));
insn = emit_insn (gen_addsi3 (dest, src, val));
@ -2446,7 +2446,7 @@ rx_is_ms_bitfield_layout (const_tree record_type ATTRIBUTE_UNUSED)
operand on the RX. X is already known to satisfy CONSTANT_P. */
bool
rx_is_legitimate_constant (rtx x)
rx_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
{
switch (GET_CODE (x))
{
@ -3052,6 +3052,9 @@ rx_adjust_insn_length (rtx insn, int current_length)
#undef TARGET_FLAGS_REGNUM
#define TARGET_FLAGS_REGNUM CC_REG
#undef TARGET_LEGITIMATE_CONSTANT_P
#define TARGET_LEGITIMATE_CONSTANT_P rx_legitimate_constant_p
struct gcc_target targetm = TARGET_INITIALIZER;
/* #include "gt-rx.h" */

2
gcc/config/rx/rx.h
View File

@ -144,8 +144,6 @@
#define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
#define LEGITIMATE_CONSTANT_P(X) rx_is_legitimate_constant (X)
#define HAVE_PRE_DECCREMENT 1
#define HAVE_POST_INCREMENT 1

2
gcc/config/rx/rx.md
View File

@ -556,7 +556,7 @@
if (MEM_P (operand0) && MEM_P (operand1))
operands[1] = copy_to_mode_reg (<register_modes:MODE>mode, operand1);
if (CONST_INT_P (operand1)
&& ! rx_is_legitimate_constant (operand1))
&& ! rx_legitimate_constant_p (<register_modes:MODE>mode, operand1))
FAIL;
}
)

1
gcc/config/s390/s390-protos.h
View File

@ -66,7 +66,6 @@ extern bool tls_symbolic_reference_mentioned_p (rtx);
extern bool legitimate_la_operand_p (rtx);
extern bool preferred_la_operand_p (rtx, rtx);
extern int legitimate_pic_operand_p (rtx);
extern int legitimate_constant_p (rtx);
extern bool legitimate_reload_constant_p (rtx);
extern rtx legitimize_pic_address (rtx, rtx);
extern rtx legitimize_reload_address (rtx, enum machine_mode, int, int);

9
gcc/config/s390/s390.c
View File

@ -2777,15 +2777,15 @@ legitimate_pic_operand_p (rtx op)
/* Returns true if the constant value OP is a legitimate general operand.
It is given that OP satisfies CONSTANT_P or is a CONST_DOUBLE. */
int
legitimate_constant_p (rtx op)
static bool
s390_legitimate_constant_p (enum machine_mode mode, rtx op)
{
/* Accept all non-symbolic constants. */
if (!SYMBOLIC_CONST (op))
return 1;
/* Accept immediate LARL operands. */
if (TARGET_CPU_ZARCH && larl_operand (op, VOIDmode))
if (TARGET_CPU_ZARCH && larl_operand (op, mode))
return 1;
/* Thread-local symbols are never legal constants. This is
@ -10829,6 +10829,9 @@ s390_loop_unroll_adjust (unsigned nunroll, struct loop *loop)
#undef TARGET_LEGITIMATE_ADDRESS_P
#define TARGET_LEGITIMATE_ADDRESS_P s390_legitimate_address_p
#undef TARGET_LEGITIMATE_CONSTANT_P
#define TARGET_LEGITIMATE_CONSTANT_P s390_legitimate_constant_p
#undef TARGET_CAN_ELIMINATE
#define TARGET_CAN_ELIMINATE s390_can_eliminate

5
gcc/config/s390/s390.h
View File

@ -697,11 +697,6 @@ do { \
} \
} while (0)
/* Nonzero if the constant value X is a legitimate general operand.
It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE. */
#define LEGITIMATE_CONSTANT_P(X) \
legitimate_constant_p (X)
/* Helper macro for s390.c and s390.md to check for symbolic constants. */
#define SYMBOLIC_CONST(X) \
(GET_CODE (X) == SYMBOL_REF \

2
gcc/config/score/score.h
View File

@ -598,8 +598,6 @@ typedef struct score_args
#define REG_OK_FOR_INDEX_P(X) 0
#define LEGITIMATE_CONSTANT_P(X) 1
/* Condition Code Status. */
#define SELECT_CC_MODE(OP, X, Y) score_select_cc_mode (OP, X, Y)

20
gcc/config/sh/sh.c
View File

@ -305,6 +305,7 @@ static int sh2a_function_vector_p (tree);
static void sh_trampoline_init (rtx, tree, rtx);
static rtx sh_trampoline_adjust_address (rtx);
static void sh_conditional_register_usage (void);
static bool sh_legitimate_constant_p (enum machine_mode, rtx);
static const struct attribute_spec sh_attribute_table[] =
{
@ -598,6 +599,9 @@ static const struct default_options sh_option_optimization_table[] =
#undef TARGET_TRAMPOLINE_ADJUST_ADDRESS
#define TARGET_TRAMPOLINE_ADJUST_ADDRESS sh_trampoline_adjust_address
#undef TARGET_LEGITIMATE_CONSTANT_P
#define TARGET_LEGITIMATE_CONSTANT_P sh_legitimate_constant_p
/* Machine-specific symbol_ref flags. */
#define SYMBOL_FLAG_FUNCVEC_FUNCTION (SYMBOL_FLAG_MACH_DEP << 0)
@ -12625,6 +12629,22 @@ sh_conditional_register_usage (void)
SET_HARD_REG_BIT (reg_class_contents[SIBCALL_REGS], regno);
}
/* Implement TARGET_LEGITIMATE_CONSTANT_P
can_store_by_pieces constructs VOIDmode CONST_DOUBLEs. */
static bool
sh_legitimate_constant_p (enum machine_mode mode, rtx x)
{
return (TARGET_SHMEDIA
? ((mode != DFmode && GET_MODE_CLASS (mode) != MODE_VECTOR_FLOAT)
|| x == CONST0_RTX (mode)
|| !TARGET_SHMEDIA_FPU
|| TARGET_SHMEDIA64)
: (GET_CODE (x) != CONST_DOUBLE
|| mode == DFmode || mode == SFmode
|| mode == DImode || GET_MODE (x) == VOIDmode));
}
enum sh_divide_strategy_e sh_div_strategy = SH_DIV_STRATEGY_DEFAULT;

14
gcc/config/sh/sh.h
View File

@ -1761,20 +1761,6 @@ struct sh_args {
#define CONSTANT_ADDRESS_P(X) (GET_CODE (X) == LABEL_REF)
/* Nonzero if the constant value X is a legitimate general operand. */
/* can_store_by_pieces constructs VOIDmode CONST_DOUBLEs. */
#define LEGITIMATE_CONSTANT_P(X) \
(TARGET_SHMEDIA \
? ((GET_MODE (X) != DFmode \
&& GET_MODE_CLASS (GET_MODE (X)) != MODE_VECTOR_FLOAT) \
|| (X) == CONST0_RTX (GET_MODE (X)) \
|| ! TARGET_SHMEDIA_FPU \
|| TARGET_SHMEDIA64) \
: (GET_CODE (X) != CONST_DOUBLE \
|| GET_MODE (X) == DFmode || GET_MODE (X) == SFmode \
|| GET_MODE (X) == DImode || GET_MODE (X) == VOIDmode))
/* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
and check its validity for a certain class.
The suitable hard regs are always accepted and all pseudo regs

1
gcc/config/sparc/sparc-protos.h
View File

@ -56,7 +56,6 @@ extern void sparc_emit_fixunsdi (rtx [2], enum machine_mode);
extern void emit_tfmode_binop (enum rtx_code, rtx *);
extern void emit_tfmode_unop (enum rtx_code, rtx *);
extern void emit_tfmode_cvt (enum rtx_code, rtx *);
extern bool legitimate_constant_p (rtx);
extern bool constant_address_p (rtx);
extern bool legitimate_pic_operand_p (rtx);
extern rtx sparc_legitimize_reload_address (rtx, enum machine_mode, int, int,

18
gcc/config/sparc/sparc.c
View File

@ -382,6 +382,7 @@ static void sparc_output_addr_vec (rtx);
static void sparc_output_addr_diff_vec (rtx);
static void sparc_output_deferred_case_vectors (void);
static bool sparc_legitimate_address_p (enum machine_mode, rtx, bool);
static bool sparc_legitimate_constant_p (enum machine_mode, rtx);
static rtx sparc_builtin_saveregs (void);
static int epilogue_renumber (rtx *, int);
static bool sparc_assemble_integer (rtx, unsigned int, int);
@ -660,6 +661,9 @@ static const struct default_options sparc_option_optimization_table[] =
#undef TARGET_LEGITIMATE_ADDRESS_P
#define TARGET_LEGITIMATE_ADDRESS_P sparc_legitimate_address_p
#undef TARGET_LEGITIMATE_CONSTANT_P
#define TARGET_LEGITIMATE_CONSTANT_P sparc_legitimate_constant_p
#undef TARGET_TRAMPOLINE_INIT
#define TARGET_TRAMPOLINE_INIT sparc_trampoline_init
@ -3017,8 +3021,8 @@ pic_address_needs_scratch (rtx x)
/* Determine if a given RTX is a valid constant. We already know this
satisfies CONSTANT_P. */
bool
legitimate_constant_p (rtx x)
static bool
sparc_legitimate_constant_p (enum machine_mode mode, rtx x)
{
switch (GET_CODE (x))
{
@ -3035,8 +3039,8 @@ legitimate_constant_p (rtx x)
/* Floating point constants are generally not ok.
The only exception is 0.0 in VIS. */
if (TARGET_VIS
&& SCALAR_FLOAT_MODE_P (GET_MODE (x))
&& const_zero_operand (x, GET_MODE (x)))
&& SCALAR_FLOAT_MODE_P (mode)
&& const_zero_operand (x, mode))
return true;
return false;
@ -3045,7 +3049,7 @@ legitimate_constant_p (rtx x)
/* Vector constants are generally not ok.
The only exception is 0 in VIS. */
if (TARGET_VIS
&& const_zero_operand (x, GET_MODE (x)))
&& const_zero_operand (x, mode))
return true;
return false;
@ -3072,10 +3076,10 @@ constant_address_p (rtx x)
case CONST:
if (flag_pic && pic_address_needs_scratch (x))
return false;
return legitimate_constant_p (x);
return sparc_legitimate_constant_p (Pmode, x);
case SYMBOL_REF:
return !flag_pic && legitimate_constant_p (x);
return !flag_pic && sparc_legitimate_constant_p (Pmode, x);
default:
return false;

6
gcc/config/sparc/sparc.h
View File

@ -1539,12 +1539,6 @@ do { \
#define LEGITIMATE_PIC_OPERAND_P(X) legitimate_pic_operand_p (X)
/* Nonzero if the constant value X is a legitimate general operand.
Anything can be made to work except floating point constants.
If TARGET_VIS, 0.0 can be made to work as well. */
#define LEGITIMATE_CONSTANT_P(X) legitimate_constant_p (X)
/* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
and check its validity for a certain class.
We have two alternate definitions for each of them.

2
gcc/config/spu/predicates.md
View File

@ -58,7 +58,7 @@
(define_predicate "vec_imm_operand"
(and (match_code "const_int,const_double,const_vector")
(match_test "spu_legitimate_constant_p (op)")))
(match_test "spu_legitimate_constant_p (mode, op)")))
(define_predicate "spu_arith_operand"
(match_code "reg,subreg,const_int,const_vector")

2
gcc/config/spu/spu-protos.h
View File

@ -52,7 +52,7 @@ extern int arith_immediate_p (rtx op, enum machine_mode mode,
extern bool exp2_immediate_p (rtx op, enum machine_mode mode, int low,
int high);
extern int spu_constant_address_p (rtx x);
extern int spu_legitimate_constant_p (rtx x);
extern bool spu_legitimate_constant_p (enum machine_mode, rtx);
extern int spu_initial_elimination_offset (int from, int to);
extern rtx spu_function_value (const_tree type, const_tree func);
extern void spu_setup_incoming_varargs (int *cum, enum machine_mode mode,

11
gcc/config/spu/spu.c
View File

@ -477,6 +477,9 @@ static const struct attribute_spec spu_attribute_table[] =
#undef TARGET_LEGITIMATE_ADDRESS_P
#define TARGET_LEGITIMATE_ADDRESS_P spu_legitimate_address_p
#undef TARGET_LEGITIMATE_CONSTANT_P
#define TARGET_LEGITIMATE_CONSTANT_P spu_legitimate_constant_p
#undef TARGET_TRAMPOLINE_INIT
#define TARGET_TRAMPOLINE_INIT spu_trampoline_init
@ -3733,8 +3736,8 @@ ea_symbol_ref (rtx *px, void *data ATTRIBUTE_UNUSED)
- a 64-bit constant where the high and low bits are identical
(DImode, DFmode)
- a 128-bit constant where the four 32-bit words match. */
int
spu_legitimate_constant_p (rtx x)
bool
spu_legitimate_constant_p (enum machine_mode mode, rtx x)
{
if (GET_CODE (x) == HIGH)
x = XEXP (x, 0);
@ -3746,7 +3749,7 @@ spu_legitimate_constant_p (rtx x)
/* V4SI with all identical symbols is valid. */
if (!flag_pic
&& GET_MODE (x) == V4SImode
&& mode == V4SImode
&& (GET_CODE (CONST_VECTOR_ELT (x, 0)) == SYMBOL_REF
|| GET_CODE (CONST_VECTOR_ELT (x, 0)) == LABEL_REF
|| GET_CODE (CONST_VECTOR_ELT (x, 0)) == CONST))
@ -5439,7 +5442,7 @@ spu_rtx_costs (rtx x, int code, int outer_code ATTRIBUTE_UNUSED, int *total,
of a CONST_VECTOR here (or in CONST_COSTS) doesn't help though
because this cost will only be compared against a single insn.
if (code == CONST_VECTOR)
return (LEGITIMATE_CONSTANT_P(x)) ? cost : COSTS_N_INSNS(6);
return spu_legitimate_constant_p (mode, x) ? cost : COSTS_N_INSNS (6);
*/
/* Use defaults for float operations. Not accurate but good enough. */

2
gcc/config/spu/spu.h
View File

@ -393,8 +393,6 @@ targetm.resolve_overloaded_builtin = spu_resolve_overloaded_builtin; \
#define MAX_REGS_PER_ADDRESS 2
#define LEGITIMATE_CONSTANT_P(X) spu_legitimate_constant_p(X)
/* Costs */

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

@ -342,8 +342,6 @@ enum reg_class
#define MAX_REGS_PER_ADDRESS 1
#define LEGITIMATE_CONSTANT_P(X) 1
/* Describing Relative Costs of Operations. */

16
gcc/config/v850/v850.c
View File

@ -3117,6 +3117,19 @@ v850_issue_rate (void)
{
return (TARGET_V850E2_ALL? 2 : 1);
}
/* Implement TARGET_LEGITIMATE_CONSTANT_P. */
static bool
v850_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
{
return (GET_CODE (x) == CONST_DOUBLE
|| !(GET_CODE (x) == CONST
&& GET_CODE (XEXP (x, 0)) == PLUS
&& GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
&& GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
&& !CONST_OK_FOR_K (INTVAL (XEXP (XEXP (x, 0), 1)))));
}
/* V850 specific attributes. */
@ -3234,6 +3247,9 @@ static const struct attribute_spec v850_attribute_table[] =
#undef TARGET_OPTION_OPTIMIZATION_TABLE
#define TARGET_OPTION_OPTIMIZATION_TABLE v850_option_optimization_table
#undef TARGET_LEGITIMATE_CONSTANT_P
#define TARGET_LEGITIMATE_CONSTANT_P v850_legitimate_constant_p
struct gcc_target targetm = TARGET_INITIALIZER;
#include "gt-v850.h"

11
gcc/config/v850/v850.h
View File

@ -633,17 +633,6 @@ do { \
} while (0)
/* Nonzero if the constant value X is a legitimate general operand.
It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE. */
#define LEGITIMATE_CONSTANT_P(X) \
(GET_CODE (X) == CONST_DOUBLE \
|| !(GET_CODE (X) == CONST \
&& GET_CODE (XEXP (X, 0)) == PLUS \
&& GET_CODE (XEXP (XEXP (X, 0), 0)) == SYMBOL_REF \
&& GET_CODE (XEXP (XEXP (X, 0), 1)) == CONST_INT \
&& ! CONST_OK_FOR_K (INTVAL (XEXP (XEXP (X, 0), 1)))))
/* Given a comparison code (EQ, NE, etc.) and the first operand of a COMPARE,
return the mode to be used for the comparison.

1
gcc/config/vax/vax-protos.h
View File

@ -19,7 +19,6 @@ along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
extern bool legitimate_constant_address_p (rtx);
extern bool legitimate_constant_p (rtx);
extern bool vax_mode_dependent_address_p (rtx);
#ifdef RTX_CODE

9
gcc/config/vax/vax.c
View File

@ -1603,15 +1603,6 @@ legitimate_constant_address_p (rtx x)
return true;
}
/* True if the constant value X is a legitimate general operand.
It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE. */
bool
legitimate_constant_p (rtx x ATTRIBUTE_UNUSED)
{
return true;
}
/* The other macros defined here are used only in legitimate_address_p (). */
/* Nonzero if X is a hard reg that can be used as an index

5
gcc/config/vax/vax.h
View File

@ -412,11 +412,6 @@ enum reg_class { NO_REGS, ALL_REGS, LIM_REG_CLASSES };
#define CONSTANT_ADDRESS_P(X) legitimate_constant_address_p (X)
/* Nonzero if the constant value X is a legitimate general operand.
It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE. */
#define LEGITIMATE_CONSTANT_P(X) legitimate_constant_p (X)
/* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
and check its validity for a certain class.
We have two alternate definitions for each of them.

11
gcc/config/xtensa/xtensa.c
View File

@ -173,6 +173,7 @@ static reg_class_t xtensa_secondary_reload (bool, rtx, reg_class_t,
struct secondary_reload_info *);
static bool constantpool_address_p (const_rtx addr);
static bool xtensa_legitimate_constant_p (enum machine_mode, rtx);
static const int reg_nonleaf_alloc_order[FIRST_PSEUDO_REGISTER] =
REG_ALLOC_ORDER;
@ -309,6 +310,9 @@ static const struct default_options xtensa_option_optimization_table[] =
#undef TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA
#define TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA xtensa_output_addr_const_extra
#undef TARGET_LEGITIMATE_CONSTANT_P
#define TARGET_LEGITIMATE_CONSTANT_P xtensa_legitimate_constant_p
struct gcc_target targetm = TARGET_INITIALIZER;
@ -3719,5 +3723,12 @@ xtensa_trampoline_init (rtx m_tramp, tree fndecl, rtx chain)
LCT_NORMAL, VOIDmode, 1, XEXP (m_tramp, 0), Pmode);
}
/* Implement TARGET_LEGITIMATE_CONSTANT_P. */
static bool
xtensa_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
{
return !xtensa_tls_referenced_p (x);
}
#include "gt-xtensa.h"

4
gcc/config/xtensa/xtensa.h
View File

@ -671,10 +671,6 @@ typedef struct xtensa_args
|| GET_CODE (X) == CONST_INT || GET_CODE (X) == HIGH \
|| (GET_CODE (X) == CONST)))
/* Nonzero if the constant value X is a legitimate general operand.
It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE. */
#define LEGITIMATE_CONSTANT_P(X) (! xtensa_tls_referenced_p (X))
/* A C expression that is nonzero if X is a legitimate immediate
operand on the target machine when generating position independent
code. */

20
gcc/doc/tm.texi
View File

@ -2522,7 +2522,7 @@ instruction for loading an immediate value into a floating-point
register, so @code{TARGET_PREFERRED_RELOAD_CLASS} returns @code{NO_REGS} when
@var{x} is a floating-point constant. If the constant can't be loaded
into any kind of register, code generation will be better if
@code{LEGITIMATE_CONSTANT_P} makes the constant illegitimate instead
@code{TARGET_LEGITIMATE_CONSTANT_P} makes the constant illegitimate instead
of using @code{TARGET_PREFERRED_RELOAD_CLASS}.
If an insn has pseudos in it after register allocation, reload will go
@ -2559,8 +2559,8 @@ instruction for loading an immediate value into a floating-point
register, so @code{PREFERRED_RELOAD_CLASS} returns @code{NO_REGS} when
@var{x} is a floating-point constant. If the constant can't be loaded
into any kind of register, code generation will be better if
@code{LEGITIMATE_CONSTANT_P} makes the constant illegitimate instead
of using @code{PREFERRED_RELOAD_CLASS}.
@code{TARGET_LEGITIMATE_CONSTANT_P} makes the constant illegitimate instead
of using @code{TARGET_PREFERRED_RELOAD_CLASS}.
If an insn has pseudos in it after register allocation, reload will go
through the alternatives and call repeatedly @code{PREFERRED_RELOAD_CLASS}
@ -5535,13 +5535,13 @@ These are obsolete macros, replaced by the
@code{TARGET_MODE_DEPENDENT_ADDRESS_P} target hook.
@end defmac
@defmac LEGITIMATE_CONSTANT_P (@var{x})
A C expression that is nonzero if @var{x} is a legitimate constant for
an immediate operand on the target machine. You can assume that
@var{x} satisfies @code{CONSTANT_P}, so you need not check this. In fact,
@samp{1} is a suitable definition for this macro on machines where
anything @code{CONSTANT_P} is valid.
@end defmac
@deftypefn {Target Hook} bool TARGET_LEGITIMATE_CONSTANT_P (enum machine_mode @var{mode}, rtx @var{x})
This hook returns true if @var{x} is a legitimate constant for a
@var{mode}-mode immediate operand on the target machine. You can assume that
@var{x} satisfies @code{CONSTANT_P}, so you need not check this.
The default definition returns true.
@end deftypefn
@deftypefn {Target Hook} rtx TARGET_DELEGITIMIZE_ADDRESS (rtx @var{x})
This hook is used to undo the possibly obfuscating effects of the

20
gcc/doc/tm.texi.in
View File

@ -2510,7 +2510,7 @@ instruction for loading an immediate value into a floating-point
register, so @code{TARGET_PREFERRED_RELOAD_CLASS} returns @code{NO_REGS} when
@var{x} is a floating-point constant. If the constant can't be loaded
into any kind of register, code generation will be better if
@code{LEGITIMATE_CONSTANT_P} makes the constant illegitimate instead
@code{TARGET_LEGITIMATE_CONSTANT_P} makes the constant illegitimate instead
of using @code{TARGET_PREFERRED_RELOAD_CLASS}.
If an insn has pseudos in it after register allocation, reload will go
@ -2547,8 +2547,8 @@ instruction for loading an immediate value into a floating-point
register, so @code{PREFERRED_RELOAD_CLASS} returns @code{NO_REGS} when
@var{x} is a floating-point constant. If the constant can't be loaded
into any kind of register, code generation will be better if
@code{LEGITIMATE_CONSTANT_P} makes the constant illegitimate instead
of using @code{PREFERRED_RELOAD_CLASS}.
@code{TARGET_LEGITIMATE_CONSTANT_P} makes the constant illegitimate instead
of using @code{TARGET_PREFERRED_RELOAD_CLASS}.
If an insn has pseudos in it after register allocation, reload will go
through the alternatives and call repeatedly @code{PREFERRED_RELOAD_CLASS}
@ -5513,13 +5513,13 @@ These are obsolete macros, replaced by the
@code{TARGET_MODE_DEPENDENT_ADDRESS_P} target hook.
@end defmac
@defmac LEGITIMATE_CONSTANT_P (@var{x})
A C expression that is nonzero if @var{x} is a legitimate constant for
an immediate operand on the target machine. You can assume that
@var{x} satisfies @code{CONSTANT_P}, so you need not check this. In fact,
@samp{1} is a suitable definition for this macro on machines where
anything @code{CONSTANT_P} is valid.
@end defmac
@hook TARGET_LEGITIMATE_CONSTANT_P
This hook returns true if @var{x} is a legitimate constant for a
@var{mode}-mode immediate operand on the target machine. You can assume that
@var{x} satisfies @code{CONSTANT_P}, so you need not check this.
The default definition returns true.
@end deftypefn
@hook TARGET_DELEGITIMIZE_ADDRESS
This hook is used to undo the possibly obfuscating effects of the

14
gcc/expr.c
View File

@ -1485,7 +1485,7 @@ move_block_to_reg (int regno, rtx x, int nregs, enum machine_mode mode)
if (nregs == 0)
return;
if (CONSTANT_P (x) && ! LEGITIMATE_CONSTANT_P (x))
if (CONSTANT_P (x) && !targetm.legitimate_constant_p (mode, x))
x = validize_mem (force_const_mem (mode, x));
/* See if the machine can do this with a load multiple insn. */
@ -2296,7 +2296,7 @@ can_store_by_pieces (unsigned HOST_WIDE_INT len,
offset -= size;
cst = (*constfun) (constfundata, offset, mode);
if (!LEGITIMATE_CONSTANT_P (cst))
if (!targetm.legitimate_constant_p (mode, cst))
return 0;
if (!reverse)
@ -3329,7 +3329,7 @@ emit_move_insn (rtx x, rtx y)
y_cst = y;
if (!LEGITIMATE_CONSTANT_P (y))
if (!targetm.legitimate_constant_p (mode, y))
{
y = force_const_mem (mode, y);
@ -3385,7 +3385,7 @@ compress_float_constant (rtx x, rtx y)
REAL_VALUE_FROM_CONST_DOUBLE (r, y);
if (LEGITIMATE_CONSTANT_P (y))
if (targetm.legitimate_constant_p (dstmode, y))
oldcost = rtx_cost (y, SET, speed);
else
oldcost = rtx_cost (force_const_mem (dstmode, y), SET, speed);
@ -3408,7 +3408,7 @@ compress_float_constant (rtx x, rtx y)
trunc_y = CONST_DOUBLE_FROM_REAL_VALUE (r, srcmode);
if (LEGITIMATE_CONSTANT_P (trunc_y))
if (targetm.legitimate_constant_p (srcmode, trunc_y))
{
/* Skip if the target needs extra instructions to perform
the extension. */
@ -3820,7 +3820,7 @@ emit_push_insn (rtx x, enum machine_mode mode, tree type, rtx size,
by setting SKIP to 0. */
skip = (reg_parm_stack_space == 0) ? 0 : not_stack;
if (CONSTANT_P (x) && ! LEGITIMATE_CONSTANT_P (x))
if (CONSTANT_P (x) && !targetm.legitimate_constant_p (mode, x))
x = validize_mem (force_const_mem (mode, x));
/* If X is a hard register in a non-integer mode, copy it into a pseudo;
@ -9093,7 +9093,7 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
constant and we don't need a memory reference. */
if (CONSTANT_P (op0)
&& mode2 != BLKmode
&& LEGITIMATE_CONSTANT_P (op0)
&& targetm.legitimate_constant_p (mode2, op0)
&& !must_force_mem)
op0 = force_reg (mode2, op0);

8
gcc/hooks.c
View File

@ -109,6 +109,14 @@ hook_bool_mode_rtx_false (enum machine_mode mode ATTRIBUTE_UNUSED,
return false;
}
/* Generic hook that takes (enum machine_mode, rtx) and returns true. */
bool
hook_bool_mode_rtx_true (enum machine_mode mode ATTRIBUTE_UNUSED,
rtx value ATTRIBUTE_UNUSED)
{
return true;
}
/* Generic hook that takes (FILE *, const char *) and does nothing. */
void
hook_void_FILEptr_constcharptr (FILE *a ATTRIBUTE_UNUSED, const char *b ATTRIBUTE_UNUSED)

1
gcc/hooks.h
View File

@ -35,6 +35,7 @@ extern bool hook_bool_mode_true (enum machine_mode);
extern bool hook_bool_mode_const_rtx_false (enum machine_mode, const_rtx);
extern bool hook_bool_mode_const_rtx_true (enum machine_mode, const_rtx);
extern bool hook_bool_mode_rtx_false (enum machine_mode, rtx);
extern bool hook_bool_mode_rtx_true (enum machine_mode, rtx);
extern bool hook_bool_tree_false (tree);
extern bool hook_bool_const_tree_false (const_tree);
extern bool hook_bool_tree_true (tree);

3
gcc/ira-costs.c
View File

@ -1294,7 +1294,8 @@ scan_one_insn (rtx insn)
&& (note = find_reg_note (insn, REG_EQUIV, NULL_RTX)) != NULL_RTX
&& ((MEM_P (XEXP (note, 0)))
|| (CONSTANT_P (XEXP (note, 0))
&& LEGITIMATE_CONSTANT_P (XEXP (note, 0))
&& targetm.legitimate_constant_p (GET_MODE (SET_DEST (set)),
XEXP (note, 0))
&& REG_N_SETS (REGNO (SET_DEST (set))) == 1)))
{
enum reg_class cl = GENERAL_REGS;

8
gcc/recog.c
View File

@ -930,7 +930,9 @@ general_operand (rtx op, enum machine_mode mode)
return ((GET_MODE (op) == VOIDmode || GET_MODE (op) == mode
|| mode == VOIDmode)
&& (! flag_pic || LEGITIMATE_PIC_OPERAND_P (op))
&& LEGITIMATE_CONSTANT_P (op));
&& targetm.legitimate_constant_p (mode == VOIDmode
? GET_MODE (op)
: mode, op));
/* Except for certain constants with VOIDmode, already checked for,
OP's mode must match MODE if MODE specifies a mode. */
@ -1107,7 +1109,9 @@ immediate_operand (rtx op, enum machine_mode mode)
&& (GET_MODE (op) == mode || mode == VOIDmode
|| GET_MODE (op) == VOIDmode)
&& (! flag_pic || LEGITIMATE_PIC_OPERAND_P (op))
&& LEGITIMATE_CONSTANT_P (op));
&& targetm.legitimate_constant_p (mode == VOIDmode
? GET_MODE (op)
: mode, op));
}
/* Returns 1 if OP is an operand that is a CONST_INT. */

7
gcc/reload.c
View File

@ -4721,7 +4721,8 @@ find_reloads_toplev (rtx x, int opnum, enum reload_type type,
simplify_gen_subreg (GET_MODE (x), reg_equiv_constant (regno),
GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
gcc_assert (tem);
if (CONSTANT_P (tem) && !LEGITIMATE_CONSTANT_P (tem))
if (CONSTANT_P (tem)
&& !targetm.legitimate_constant_p (GET_MODE (x), tem))
{
tem = force_const_mem (GET_MODE (x), tem);
i = find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0),
@ -6047,7 +6048,7 @@ find_reloads_address_part (rtx x, rtx *loc, enum reg_class rclass,
enum reload_type type, int ind_levels)
{
if (CONSTANT_P (x)
&& (! LEGITIMATE_CONSTANT_P (x)
&& (!targetm.legitimate_constant_p (mode, x)
|| targetm.preferred_reload_class (x, rclass) == NO_REGS))
{
x = force_const_mem (mode, x);
@ -6057,7 +6058,7 @@ find_reloads_address_part (rtx x, rtx *loc, enum reg_class rclass,
else if (GET_CODE (x) == PLUS
&& CONSTANT_P (XEXP (x, 1))
&& (! LEGITIMATE_CONSTANT_P (XEXP (x, 1))
&& (!targetm.legitimate_constant_p (GET_MODE (x), XEXP (x, 1))
|| targetm.preferred_reload_class (XEXP (x, 1), rclass)
== NO_REGS))
{

8
gcc/reload1.c
View File

@ -4161,6 +4161,9 @@ init_eliminable_invariants (rtx first, bool do_subregs)
}
else if (function_invariant_p (x))
{
enum machine_mode mode;
mode = GET_MODE (SET_DEST (set));
if (GET_CODE (x) == PLUS)
{
/* This is PLUS of frame pointer and a constant,
@ -4173,12 +4176,11 @@ init_eliminable_invariants (rtx first, bool do_subregs)
reg_equiv_invariant (i) = x;
num_eliminable_invariants++;
}
else if (LEGITIMATE_CONSTANT_P (x))
else if (targetm.legitimate_constant_p (mode, x))
reg_equiv_constant (i) = x;
else
{
reg_equiv_memory_loc (i)
= force_const_mem (GET_MODE (SET_DEST (set)), x);
reg_equiv_memory_loc (i) = force_const_mem (mode, x);
if (! reg_equiv_memory_loc (i))
reg_equiv_init (i) = NULL_RTX;
}

Some files were not shown because too many files have changed in this diff Show More