/* Return TRUE if X is a legitimate address for accessing memory in
mode MODE. */
static bool
-aarch64_legitimate_address_hook_p (machine_mode mode, rtx x, bool strict_p)
+aarch64_legitimate_address_hook_p (machine_mode mode, rtx x, bool strict_p,
+ code_helper = ERROR_MARK)
{
struct aarch64_address_info addr;
low-order three bits; this is an "unaligned" access. */
static bool
-alpha_legitimate_address_p (machine_mode mode, rtx x, bool strict)
+alpha_legitimate_address_p (machine_mode mode, rtx x, bool strict,
+ code_helper = ERROR_MARK)
{
/* If this is an ldq_u type address, discard the outer AND. */
if (mode == DImode
}
static bool
-arc_legitimate_address_p (machine_mode mode, rtx x, bool strict)
+arc_legitimate_address_p (machine_mode mode, rtx x, bool strict,
+ code_helper = ERROR_MARK)
{
if (RTX_OK_FOR_BASE_P (x, strict))
return true;
#define GCC_ARM_PROTOS_H
#include "sbitmap.h"
+#include "tree.h" /* For ERROR_MARK. */
rtl_opt_pass *make_pass_insert_bti (gcc::context *ctxt);
extern int legitimate_pic_operand_p (rtx);
extern rtx legitimize_pic_address (rtx, machine_mode, rtx, rtx, bool);
extern rtx legitimize_tls_address (rtx, rtx);
-extern bool arm_legitimate_address_p (machine_mode, rtx, bool);
+extern bool arm_legitimate_address_p (machine_mode, rtx, bool,
+ code_helper = ERROR_MARK);
extern int arm_legitimate_address_outer_p (machine_mode, rtx, RTX_CODE, int);
extern int thumb_legitimate_offset_p (machine_mode, HOST_WIDE_INT);
extern int thumb1_legitimate_address_p (machine_mode, rtx, int);
}
bool
-arm_legitimate_address_p (machine_mode mode, rtx x, bool strict_p)
+arm_legitimate_address_p (machine_mode mode, rtx x, bool strict_p, code_helper)
{
if (TARGET_ARM)
return arm_legitimate_address_outer_p (mode, x, SET, strict_p);
/* Implement `TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P'. */
static bool
-avr_addr_space_legitimate_address_p (machine_mode mode, rtx x,
- bool strict, addr_space_t as)
+avr_addr_space_legitimate_address_p (machine_mode mode, rtx x, bool strict,
+ addr_space_t as, code_helper = ERROR_MARK)
{
bool ok = false;
*/
static bool
-bfin_legitimate_address_p (machine_mode mode, rtx x, bool strict)
+bfin_legitimate_address_p (machine_mode mode, rtx x, bool strict,
+ code_helper = ERROR_MARK)
{
switch (GET_CODE (x)) {
case REG:
static bool
bpf_legitimate_address_p (machine_mode mode,
rtx x,
- bool strict)
+ bool strict,
+ code_helper = ERROR_MARK)
{
switch (GET_CODE (x))
{
}
static bool
-c6x_legitimate_address_p (machine_mode mode, rtx x, bool strict)
+c6x_legitimate_address_p (machine_mode mode, rtx x, bool strict,
+ code_helper = ERROR_MARK)
{
return c6x_legitimate_address_p_1 (mode, x, strict, false);
}
/* Prototypes for the CRIS port. */
+#include "tree.h" /* For ERROR_MARK. */
+
extern bool cris_simple_epilogue (void);
#ifdef RTX_CODE
extern const char *cris_op_str (rtx);
extern bool cris_bdap_index_p (const_rtx, bool);
extern void cris_reduce_compare (rtx *, rtx *, rtx *);
extern bool cris_biap_index_p (const_rtx, bool);
-extern bool cris_legitimate_address_p (machine_mode, rtx, bool);
+extern bool cris_legitimate_address_p (machine_mode, rtx, bool,
+ code_helper = ERROR_MARK);
extern bool cris_store_multiple_op_p (rtx);
extern bool cris_movem_load_rest_p (rtx);
extern void cris_asm_output_symbol_ref (FILE *, rtx);
/* Worker function for TARGET_LEGITIMATE_ADDRESS_P. */
bool
-cris_legitimate_address_p (machine_mode mode, rtx x, bool strict)
+cris_legitimate_address_p (machine_mode mode, rtx x, bool strict, code_helper)
{
const_rtx x1, x2;
be recognized. */
static bool
-csky_legitimate_address_p (machine_mode mode, rtx addr, bool strict_p)
+csky_legitimate_address_p (machine_mode mode, rtx addr, bool strict_p,
+ code_helper = ERROR_MARK)
{
enum rtx_code code = GET_CODE (addr);
|| RTX_OK_FOR_OFFSET_P (MODE, XEXP (X, 1))))
static bool
-epiphany_legitimate_address_p (machine_mode mode, rtx x, bool strict)
+epiphany_legitimate_address_p (machine_mode mode, rtx x, bool strict,
+ code_helper = ERROR_MARK)
{
#define REG_OK_FOR_BASE_P(X) \
(strict ? GPR_P (REGNO (X)) : GPR_AP_OR_PSEUDO_P (REGNO (X)))
/* Forward references */
static void frv_option_override (void);
-static bool frv_legitimate_address_p (machine_mode, rtx, bool);
+static bool frv_legitimate_address_p (machine_mode, rtx, bool,
+ code_helper = ERROR_MARK);
static int frv_default_flags_for_cpu (void);
static FRV_INLINE bool frv_small_data_reloc_p (rtx, int);
static void frv_print_operand (FILE *, rtx, int);
}
bool
-frv_legitimate_address_p (machine_mode mode, rtx x, bool strict_p)
+frv_legitimate_address_p (machine_mode mode, rtx x, bool strict_p, code_helper)
{
return frv_legitimate_address_p_1 (mode, x, strict_p, FALSE, FALSE);
}
static bool
ft32_addr_space_legitimate_address_p (machine_mode mode, rtx x, bool strict,
- addr_space_t as ATTRIBUTE_UNUSED)
+ addr_space_t as ATTRIBUTE_UNUSED,
+ code_helper = ERROR_MARK)
{
int max_offset = TARGET_FT32B ? 16384 : 128;
static bool
gcn_addr_space_legitimate_address_p (machine_mode mode, rtx x, bool strict,
- addr_space_t as)
+ addr_space_t as, code_helper = ERROR_MARK)
{
/* All vector instructions need to work on addresses in registers. */
if (!TARGET_GCN5_PLUS && (vgpr_vector_mode_p (mode) && !REG_P (x)))
CONSTANT_ADDRESS. */
static bool
-h8300_legitimate_address_p (machine_mode mode, rtx x, bool strict)
+h8300_legitimate_address_p (machine_mode mode, rtx x, bool strict,
+ code_helper = ERROR_MARK)
{
/* The register indirect addresses like @er0 is always valid. */
if (h8300_rtx_ok_for_base_p (x, strict))
be recognized. */
static bool
-ix86_legitimate_address_p (machine_mode, rtx addr, bool strict)
+ix86_legitimate_address_p (machine_mode, rtx addr, bool strict,
+ code_helper = ERROR_MARK)
{
struct ix86_address parts;
rtx base, index, disp;
static bool ia64_scalar_mode_supported_p (scalar_mode mode);
static bool ia64_vector_mode_supported_p (machine_mode mode);
static bool ia64_legitimate_constant_p (machine_mode, rtx);
-static bool ia64_legitimate_address_p (machine_mode, rtx, bool);
+static bool ia64_legitimate_address_p (machine_mode, rtx, bool,
+ code_helper = ERROR_MARK);
static bool ia64_cannot_force_const_mem (machine_mode, rtx);
static const char *ia64_mangle_type (const_tree);
static const char *ia64_invalid_conversion (const_tree, const_tree);
/* Implement TARGET_LEGITIMATE_ADDRESS_P. */
static bool
-ia64_legitimate_address_p (machine_mode mode ATTRIBUTE_UNUSED,
- rtx x, bool strict)
+ia64_legitimate_address_p (machine_mode mode ATTRIBUTE_UNUSED, rtx x,
+ bool strict, code_helper)
{
if (ia64_legitimate_address_reg (x, strict))
return true;
static unsigned int iq2000_function_arg_boundary (machine_mode,
const_tree);
static void iq2000_va_start (tree, rtx);
-static bool iq2000_legitimate_address_p (machine_mode, rtx, bool);
+static bool iq2000_legitimate_address_p (machine_mode, rtx, bool,
+ code_helper = ERROR_MARK);
static bool iq2000_can_eliminate (const int, const int);
static void iq2000_asm_trampoline_template (FILE *);
static void iq2000_trampoline_init (rtx, tree, rtx);
function is called during reload. */
bool
-iq2000_legitimate_address_p (machine_mode mode, rtx xinsn, bool strict)
+iq2000_legitimate_address_p (machine_mode mode, rtx xinsn, bool strict,
+ code_helper)
{
if (TARGET_DEBUG_A_MODE)
{
static bool lm32_rtx_costs (rtx x, machine_mode mode, int outer_code, int opno,
int *total, bool speed);
static bool lm32_can_eliminate (const int, const int);
-static bool
-lm32_legitimate_address_p (machine_mode mode, rtx x, bool strict);
+static bool lm32_legitimate_address_p (machine_mode mode, rtx x, bool strict,
+ code_helper = ERROR_MARK);
static HOST_WIDE_INT lm32_compute_frame_size (int size);
static void lm32_option_override (void);
static rtx lm32_function_arg (cumulative_args_t, const function_arg_info &);
/* Implement TARGET_LEGITIMATE_ADDRESS_P. */
static bool
-lm32_legitimate_address_p (machine_mode mode ATTRIBUTE_UNUSED, rtx x, bool strict)
+lm32_legitimate_address_p (machine_mode mode ATTRIBUTE_UNUSED, rtx x,
+ bool strict, code_helper)
{
/* (rM) */
if (strict && REG_P (x) && STRICT_REG_OK_FOR_BASE_P (x))
/* Implement TARGET_LEGITIMATE_ADDRESS_P. */
static bool
-loongarch_legitimate_address_p (machine_mode mode, rtx x, bool strict_p)
+loongarch_legitimate_address_p (machine_mode mode, rtx x, bool strict_p,
+ code_helper = ERROR_MARK)
{
struct loongarch_address_info addr;
static bool m32c_fixed_condition_code_regs (unsigned int *, unsigned int *);
static struct machine_function *m32c_init_machine_status (void);
static void m32c_insert_attributes (tree, tree *);
-static bool m32c_legitimate_address_p (machine_mode, rtx, bool);
-static bool m32c_addr_space_legitimate_address_p (machine_mode, rtx, bool, addr_space_t);
+static bool m32c_legitimate_address_p (machine_mode, rtx, bool,
+ code_helper = ERROR_MARK);
+static bool m32c_addr_space_legitimate_address_p (machine_mode, rtx, bool,
+ addr_space_t,
+ code_helper = ERROR_MARK);
static rtx m32c_function_arg (cumulative_args_t, const function_arg_info &);
static bool m32c_pass_by_reference (cumulative_args_t,
const function_arg_info &);
#undef TARGET_LEGITIMATE_ADDRESS_P
#define TARGET_LEGITIMATE_ADDRESS_P m32c_legitimate_address_p
bool
-m32c_legitimate_address_p (machine_mode mode, rtx x, bool strict)
+m32c_legitimate_address_p (machine_mode mode, rtx x, bool strict, code_helper)
{
int mode_adjust;
if (CONSTANT_P (x))
#define TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P \
m32c_addr_space_legitimate_address_p
static bool
-m32c_addr_space_legitimate_address_p (machine_mode mode, rtx x,
- bool strict, addr_space_t as)
+m32c_addr_space_legitimate_address_p (machine_mode mode, rtx x, bool strict,
+ addr_space_t as, code_helper ch)
{
if (as == ADDR_SPACE_FAR)
{
else if (as != ADDR_SPACE_GENERIC)
gcc_unreachable ();
- return m32c_legitimate_address_p (mode, x, strict);
+ return m32c_legitimate_address_p (mode, x, strict, ch);
}
/* Like m32c_legitimate_address, except with named address support. */
static void init_reg_tables (void);
static void block_move_call (rtx, rtx, rtx);
static int m32r_is_insn (rtx);
-static bool m32r_legitimate_address_p (machine_mode, rtx, bool);
+static bool m32r_legitimate_address_p (machine_mode, rtx, bool,
+ code_helper = ERROR_MARK);
static rtx m32r_legitimize_address (rtx, rtx, machine_mode);
static bool m32r_mode_dependent_address_p (const_rtx, addr_space_t);
static tree m32r_handle_model_attribute (tree *, tree, tree, int, bool *);
/* Implement TARGET_LEGITIMATE_ADDRESS_P. */
static bool
-m32r_legitimate_address_p (machine_mode mode, rtx x, bool strict)
+m32r_legitimate_address_p (machine_mode mode, rtx x, bool strict, code_helper)
{
if (m32r_rtx_ok_for_base_p (x, strict)
|| m32r_legitimate_offset_addres_p (mode, x, strict)
static bool m68k_can_eliminate (const int, const int);
static void m68k_conditional_register_usage (void);
-static bool m68k_legitimate_address_p (machine_mode, rtx, bool);
+static bool m68k_legitimate_address_p (machine_mode, rtx, bool,
+ code_helper = ERROR_MARK);
static void m68k_option_override (void);
static void m68k_override_options_after_change (void);
static rtx find_addr_reg (rtx);
STRICT_P says whether strict checking is needed. */
bool
-m68k_legitimate_address_p (machine_mode mode, rtx x, bool strict_p)
+m68k_legitimate_address_p (machine_mode mode, rtx x, bool strict_p, code_helper)
{
struct m68k_address address;
static void mcore_option_override (void);
static bool mcore_legitimate_constant_p (machine_mode, rtx);
static bool mcore_legitimate_address_p (machine_mode, rtx, bool,
- addr_space_t);
+ addr_space_t,
+ code_helper = ERROR_MARK);
static bool mcore_hard_regno_mode_ok (unsigned int, machine_mode);
static bool mcore_modes_tieable_p (machine_mode, machine_mode);
\f
static bool
mcore_legitimate_address_p (machine_mode mode, rtx x, bool strict_p,
- addr_space_t as)
+ addr_space_t as, code_helper)
{
gcc_assert (ADDR_SPACE_GENERIC_P (as));
#ifndef GCC_MICROBLAZE_PROTOS_H
#define GCC_MICROBLAZE_PROTOS_H
+#include "tree.h" /* For ERROR_MARK. */
+
#ifdef RTX_CODE
extern int pic_address_needs_scratch (rtx);
extern bool microblaze_constant_address_p (rtx x);
extern void print_operand (FILE *, rtx, int);
extern void print_operand_address (FILE *, rtx);
extern void init_cumulative_args (CUMULATIVE_ARGS *,tree, rtx);
-extern bool microblaze_legitimate_address_p (machine_mode, rtx, bool);
+extern bool microblaze_legitimate_address_p (machine_mode, rtx, bool,
+ code_helper = ERROR_MARK);
extern int microblaze_is_interrupt_variant (void);
extern int microblaze_is_break_handler (void);
extern int microblaze_break_function_p (tree func);
is called during reload. */
bool
-microblaze_legitimate_address_p (machine_mode mode, rtx x, bool strict)
+microblaze_legitimate_address_p (machine_mode mode, rtx x, bool strict,
+ code_helper)
{
struct microblaze_address_info addr;
/* Implement TARGET_LEGITIMATE_ADDRESS_P. */
static bool
-mips_legitimate_address_p (machine_mode mode, rtx x, bool strict_p)
+mips_legitimate_address_p (machine_mode mode, rtx x, bool strict_p,
+ code_helper = ERROR_MARK)
{
struct mips_address_info addr;
static void mmix_target_asm_function_epilogue (FILE *);
static reg_class_t mmix_preferred_reload_class (rtx, reg_class_t);
static reg_class_t mmix_preferred_output_reload_class (rtx, reg_class_t);
-static bool mmix_legitimate_address_p (machine_mode, rtx, bool);
+static bool mmix_legitimate_address_p (machine_mode, rtx, bool,
+ code_helper = ERROR_MARK);
static bool mmix_legitimate_constant_p (machine_mode, rtx);
static void mmix_reorg (void);
static void mmix_asm_output_mi_thunk
bool
mmix_legitimate_address_p (machine_mode mode ATTRIBUTE_UNUSED,
rtx x,
- bool strict_checking)
+ bool strict_checking,
+ code_helper)
{
#define MMIX_REG_OK(X) \
((strict_checking \
function record_unscaled_index_insn_codes. */
static bool
-mn10300_legitimate_address_p (machine_mode mode, rtx x, bool strict)
+mn10300_legitimate_address_p (machine_mode mode, rtx x, bool strict,
+ code_helper = ERROR_MARK)
{
rtx base, index;
static bool
moxie_legitimate_address_p (machine_mode mode ATTRIBUTE_UNUSED,
rtx x, bool strict_p,
- addr_space_t as)
+ addr_space_t as,
+ code_helper = ERROR_MARK)
{
gcc_assert (ADDR_SPACE_GENERIC_P (as));
bool
msp430_legitimate_address_p (machine_mode mode ATTRIBUTE_UNUSED,
rtx x ATTRIBUTE_UNUSED,
- bool strict ATTRIBUTE_UNUSED)
+ bool strict ATTRIBUTE_UNUSED,
+ code_helper = ERROR_MARK)
{
switch (GET_CODE (x))
{
msp430_addr_space_legitimate_address_p (machine_mode mode,
rtx x,
bool strict,
- addr_space_t as ATTRIBUTE_UNUSED)
+ addr_space_t as ATTRIBUTE_UNUSED,
+ code_helper ch = ERROR_MARK)
{
- return msp430_legitimate_address_p (mode, x, strict);
+ return msp430_legitimate_address_p (mode, x, strict, ch);
}
#undef TARGET_ASM_INTEGER
/* Addressing Modes. */
static bool
-nds32_legitimate_address_p (machine_mode mode, rtx x, bool strict)
+nds32_legitimate_address_p (machine_mode mode, rtx x, bool strict,
+ code_helper = ERROR_MARK)
{
if (TARGET_FPU_SINGLE || TARGET_FPU_DOUBLE)
{
/* Implement TARGET_LEGITIMATE_ADDRESS_P. */
static bool
-nios2_legitimate_address_p (machine_mode mode ATTRIBUTE_UNUSED,
- rtx operand, bool strict_p)
+nios2_legitimate_address_p (machine_mode mode ATTRIBUTE_UNUSED, rtx operand,
+ bool strict_p,
+ code_helper = ERROR_MARK)
{
switch (GET_CODE (operand))
{
/* Returns true if X is a valid address for use in a memory reference. */
static bool
-nvptx_legitimate_address_p (machine_mode, rtx x, bool)
+nvptx_legitimate_address_p (machine_mode, rtx x, bool, code_helper)
{
enum rtx_code code = GET_CODE (x);
Returns true if X is a legitimate address RTX on OpenRISC. */
static bool
-or1k_legitimate_address_p (machine_mode, rtx x, bool strict_p)
+or1k_legitimate_address_p (machine_mode, rtx x, bool strict_p,
+ code_helper = ERROR_MARK)
{
rtx base, addend;
static bool pa_cannot_force_const_mem (machine_mode, rtx);
static bool pa_legitimate_constant_p (machine_mode, rtx);
static unsigned int pa_section_type_flags (tree, const char *, int);
-static bool pa_legitimate_address_p (machine_mode, rtx, bool);
+static bool pa_legitimate_address_p (machine_mode, rtx, bool,
+ code_helper = ERROR_MARK);
static bool pa_callee_copies (cumulative_args_t, const function_arg_info &);
static unsigned int pa_hard_regno_nregs (unsigned int, machine_mode);
static bool pa_hard_regno_mode_ok (unsigned int, machine_mode);
output as REG+SMALLINT. */
static bool
-pa_legitimate_address_p (machine_mode mode, rtx x, bool strict)
+pa_legitimate_address_p (machine_mode mode, rtx x, bool strict, code_helper)
{
if ((REG_P (x)
&& (strict ? STRICT_REG_OK_FOR_BASE_P (x)
*/
static bool
-pdp11_legitimate_address_p (machine_mode mode,
- rtx operand, bool strict)
+pdp11_legitimate_address_p (machine_mode mode, rtx operand, bool strict,
+ code_helper = ERROR_MARK)
{
rtx xfoob;
/* Implement TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P. */
static bool
pru_addr_space_legitimate_address_p (machine_mode mode, rtx operand,
- bool strict_p, addr_space_t as)
+ bool strict_p, addr_space_t as,
+ code_helper = ERROR_MARK)
{
if (as == ADDR_SPACE_REGIO)
{
/* Implement TARGET_LEGITIMATE_ADDRESS_P. */
static bool
-riscv_legitimate_address_p (machine_mode mode, rtx x, bool strict_p)
+riscv_legitimate_address_p (machine_mode mode, rtx x, bool strict_p,
+ code_helper = ERROR_MARK)
{
struct riscv_address_info addr;
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
\f
+
+#include "tree.h" /* For ERROR_MARK. */
+
const char * rl78_addsi3_internal (rtx *, unsigned int);
void rl78_emit_eh_epilogue (rtx);
void rl78_expand_compare (rtx *);
bool rl78_hl_b_c_addr_p (rtx);
int rl78_initial_elimination_offset (int, int);
bool rl78_as_legitimate_address (machine_mode, rtx,
- bool, addr_space_t);
+ bool, addr_space_t,
+ code_helper = ERROR_MARK);
int rl78_legitimize_reload_address (rtx *, machine_mode, int,int, int);
enum reg_class rl78_mode_code_base_reg_class (machine_mode, addr_space_t, int, int);
bool rl78_peep_movhi_p (rtx *);
bool
rl78_as_legitimate_address (machine_mode mode ATTRIBUTE_UNUSED, rtx x,
- bool strict ATTRIBUTE_UNUSED, addr_space_t as ATTRIBUTE_UNUSED)
+ bool strict ATTRIBUTE_UNUSED,
+ addr_space_t as ATTRIBUTE_UNUSED, code_helper)
{
rtx base, index, addend;
bool is_far_addr = false;
static tree (*rs6000_veclib_handler) (combined_fn, tree, tree);
\f
-static bool rs6000_debug_legitimate_address_p (machine_mode, rtx, bool);
+static bool rs6000_debug_legitimate_address_p (machine_mode, rtx, bool,
+ code_helper = ERROR_MARK);
static tree rs6000_handle_longcall_attribute (tree *, tree, tree, int, bool *);
static tree rs6000_handle_altivec_attribute (tree *, tree, tree, int, bool *);
static tree rs6000_handle_struct_attribute (tree *, tree, tree, int, bool *);
because adjacent memory cells are accessed by adding word-sized offsets
during assembly output. */
static bool
-rs6000_legitimate_address_p (machine_mode mode, rtx x, bool reg_ok_strict)
+rs6000_legitimate_address_p (machine_mode mode, rtx x, bool reg_ok_strict,
+ code_helper = ERROR_MARK)
{
bool reg_offset_p = reg_offset_addressing_ok_p (mode);
bool quad_offset_p = mode_supports_dq_form (mode);
/* Debug version of rs6000_legitimate_address_p. */
static bool
-rs6000_debug_legitimate_address_p (machine_mode mode, rtx x,
- bool reg_ok_strict)
+rs6000_debug_legitimate_address_p (machine_mode mode, rtx x, bool reg_ok_strict,
+ code_helper ch)
{
- bool ret = rs6000_legitimate_address_p (mode, x, reg_ok_strict);
+ bool ret = rs6000_legitimate_address_p (mode, x, reg_ok_strict, ch);
fprintf (stderr,
"\nrs6000_legitimate_address_p: return = %s, mode = %s, "
"strict = %d, reload = %s, code = %s\n",
static bool
rx_is_legitimate_address (machine_mode mode, rtx x,
- bool strict ATTRIBUTE_UNUSED)
+ bool strict ATTRIBUTE_UNUSED,
+ code_helper = ERROR_MARK)
{
if (RTX_OK_FOR_BASE (x, strict))
/* Register Indirect. */
STRICT specifies whether strict register checking applies. */
static bool
-s390_legitimate_address_p (machine_mode mode, rtx addr, bool strict)
+s390_legitimate_address_p (machine_mode mode, rtx addr, bool strict,
+ code_helper = ERROR_MARK)
{
struct s390_address ad;
static reg_class_t sh_secondary_reload (bool, rtx, reg_class_t,
machine_mode,
struct secondary_reload_info *);
-static bool sh_legitimate_address_p (machine_mode, rtx, bool);
+static bool sh_legitimate_address_p (machine_mode, rtx, bool,
+ code_helper = ERROR_MARK);
static rtx sh_legitimize_address (rtx, rtx, machine_mode);
static rtx sh_delegitimize_address (rtx);
static bool sh_cannot_substitute_mem_equiv_p (rtx);
GBR
GBR+disp */
static bool
-sh_legitimate_address_p (machine_mode mode, rtx x, bool strict)
+sh_legitimate_address_p (machine_mode mode, rtx x, bool strict, code_helper)
{
if (REG_P (x) && REGNO (x) == GBR_REG)
return true;
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 (machine_mode, rtx, bool);
+static bool sparc_legitimate_address_p (machine_mode, rtx, bool,
+ code_helper = ERROR_MARK);
static bool sparc_legitimate_constant_p (machine_mode, rtx);
static rtx sparc_builtin_saveregs (void);
static int epilogue_renumber (rtx *, int);
ordinarily. This changes a bit when generating PIC. */
static bool
-sparc_legitimate_address_p (machine_mode mode, rtx addr, bool strict)
+sparc_legitimate_address_p (machine_mode mode, rtx addr, bool strict,
+ code_helper)
{
rtx rs1 = NULL, rs2 = NULL, imm1 = NULL;
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
-
+#include "tree.h" /* For ERROR_MARK. */
extern struct xstormy16_stack_layout xstormy16_compute_stack_layout (void);
extern void xstormy16_expand_prologue (void);
rtx, rtx, rtx);
extern bool xstormy16_below100_symbol (rtx, machine_mode);
extern bool xstormy16_splittable_below100_operand (rtx, machine_mode);
-extern bool xstormy16_legitimate_address_p (machine_mode, rtx, bool);
+extern bool xstormy16_legitimate_address_p (machine_mode, rtx, bool,
+ code_helper = ERROR_MARK);
#endif
&& (INTVAL (X) + (OFFSET) < 0x100 || INTVAL (X) + (OFFSET) >= 0x7F00))
bool
-xstormy16_legitimate_address_p (machine_mode mode ATTRIBUTE_UNUSED,
- rtx x, bool strict)
+xstormy16_legitimate_address_p (machine_mode mode ATTRIBUTE_UNUSED, rtx x,
+ bool strict, code_helper)
{
if (LEGITIMATE_ADDRESS_CONST_INT_P (x, 0))
return true;
static bool
v850_legitimate_address_p (machine_mode mode, rtx x, bool strict_p,
- addr_space_t as ATTRIBUTE_UNUSED)
+ addr_space_t as ATTRIBUTE_UNUSED,
+ code_helper = ERROR_MARK)
{
gcc_assert (ADDR_SPACE_GENERIC_P (as));
#include "target-def.h"
static void vax_option_override (void);
-static bool vax_legitimate_address_p (machine_mode, rtx, bool);
+static bool vax_legitimate_address_p (machine_mode, rtx, bool,
+ code_helper = ERROR_MARK);
static void vax_file_start (void);
static void vax_init_libfuncs (void);
static void vax_output_mi_thunk (FILE *, tree, HOST_WIDE_INT,
The MODE argument is the machine mode for the MEM expression
that wants to use this address. */
bool
-vax_legitimate_address_p (machine_mode mode, rtx x, bool strict)
+vax_legitimate_address_p (machine_mode mode, rtx x, bool strict, code_helper)
{
rtx xfoo0, xfoo1;
static bool visium_legitimate_constant_p (machine_mode, rtx);
-static bool visium_legitimate_address_p (machine_mode, rtx, bool);
+static bool visium_legitimate_address_p (machine_mode, rtx, bool,
+ code_helper = ERROR_MARK);
static bool visium_print_operand_punct_valid_p (unsigned char);
static void visium_print_operand (FILE *, rtx, int);
kind of register is required. */
static bool
-visium_legitimate_address_p (machine_mode mode, rtx x, bool strict)
+visium_legitimate_address_p (machine_mode mode, rtx x, bool strict, code_helper)
{
rtx base;
unsigned int regno;
static bool xtensa_return_in_msb (const_tree);
static void printx (FILE *, signed int);
static rtx xtensa_builtin_saveregs (void);
-static bool xtensa_legitimate_address_p (machine_mode, rtx, bool);
+static bool xtensa_legitimate_address_p (machine_mode, rtx, bool,
+ code_helper = ERROR_MARK);
static unsigned int xtensa_multibss_section_type_flags (tree, const char *,
int) ATTRIBUTE_UNUSED;
static section *xtensa_select_rtx_section (machine_mode, rtx,
return result;
}
-
bool
-xtensa_legitimate_address_p (machine_mode mode, rtx addr, bool strict)
+xtensa_legitimate_address_p (machine_mode mode, rtx addr, bool strict,
+ code_helper)
{
/* Allow constant pool addresses. */
if (mode != BLKmode && GET_MODE_SIZE (mode) >= UNITS_PER_WORD
struct gimple;
typedef gimple *gimple_seq;
struct gimple_stmt_iterator;
+class code_helper;
/* Forward decls for leaf gimple subclasses (for individual gimple codes).
Keep this in the same order as the corresponding codes in gimple.def. */
accept.
@end defmac
-@deftypefn {Target Hook} bool TARGET_LEGITIMATE_ADDRESS_P (machine_mode @var{mode}, rtx @var{x}, bool @var{strict})
+@deftypefn {Target Hook} bool TARGET_LEGITIMATE_ADDRESS_P (machine_mode @var{mode}, rtx @var{x}, bool @var{strict}, code_helper @var{ch})
A function that returns whether @var{x} (an RTX) is a legitimate memory
address on the target machine for a memory operand of mode @var{mode}.
+If @var{ch} is not @code{ERROR_MARK}, it can be called from middle-end to
+determine if it is valid to use @var{x} as a memory operand for RTX insn
+which is generated for the given code_helper @var{ch}. For example,
+assuming the given @var{ch} is IFN_LEN_LOAD, on some target its underlying
+hardware instructions support fewer addressing modes than what are for the
+normal vector load and store, then with this @var{ch} target can know the
+actual use context and return more exact result.
Legitimate addresses are defined in two variants: a strict variant and a
non-strict one. The @var{strict} parameter chooses which variant is
target hooks for the given address space.
@end deftypefn
-@deftypefn {Target Hook} bool TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P (machine_mode @var{mode}, rtx @var{exp}, bool @var{strict}, addr_space_t @var{as})
+@deftypefn {Target Hook} bool TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P (machine_mode @var{mode}, rtx @var{exp}, bool @var{strict}, addr_space_t @var{as}, code_helper @var{ch})
Define this to return true if @var{exp} is a valid address for mode
-@var{mode} in the named address space @var{as}. The @var{strict}
-parameter says whether strict addressing is in effect after reload has
-finished. This target hook is the same as the
+@var{mode} in the named address space @var{as} with the use context
+@var{ch}. The @var{strict} parameter says whether strict addressing
+is in effect after reload has finished. The @var{ch} indicates what
+context @var{exp} will be used for. This target hook is the same as the
@code{TARGET_LEGITIMATE_ADDRESS_P} target hook, except that it includes
explicit named address space support.
@end deftypefn
win:
return true;
#else
- return targetm.addr_space.legitimate_address_p (mode, addr, 0, as);
+ return targetm.addr_space.legitimate_address_p (mode, addr, 0, as,
+ ERROR_MARK);
#endif
}
win:
return true;
#else
- return targetm.addr_space.legitimate_address_p (mode, addr, 0, as);
+ return targetm.addr_space.legitimate_address_p (mode, addr, 0, as,
+ ERROR_MARK);
#endif
}
win:
return true;
#else
- return targetm.addr_space.legitimate_address_p (mode, addr, 1, as);
+ return targetm.addr_space.legitimate_address_p (mode, addr, 1, as,
+ ERROR_MARK);
#endif
}
\f
(legitimate_address_p,
"A function that returns whether @var{x} (an RTX) is a legitimate memory\n\
address on the target machine for a memory operand of mode @var{mode}.\n\
+If @var{ch} is not @code{ERROR_MARK}, it can be called from middle-end to\n\
+determine if it is valid to use @var{x} as a memory operand for RTX insn\n\
+which is generated for the given code_helper @var{ch}. For example,\n\
+assuming the given @var{ch} is IFN_LEN_LOAD, on some target its underlying\n\
+hardware instructions support fewer addressing modes than what are for the\n\
+normal vector load and store, then with this @var{ch} target can know the\n\
+actual use context and return more exact result.\n\
\n\
Legitimate addresses are defined in two variants: a strict variant and a\n\
non-strict one. The @var{strict} parameter chooses which variant is\n\
\n\
Using the hook is usually simpler because it limits the number of\n\
files that are recompiled when changes are made.",
- bool, (machine_mode mode, rtx x, bool strict),
+ bool, (machine_mode mode, rtx x, bool strict, code_helper ch),
default_legitimate_address_p)
/* True if the given constant can be put into an object_block. */
DEFHOOK
(legitimate_address_p,
"Define this to return true if @var{exp} is a valid address for mode\n\
-@var{mode} in the named address space @var{as}. The @var{strict}\n\
-parameter says whether strict addressing is in effect after reload has\n\
-finished. This target hook is the same as the\n\
+@var{mode} in the named address space @var{as} with the use context\n\
+@var{ch}. The @var{strict} parameter says whether strict addressing\n\
+is in effect after reload has finished. The @var{ch} indicates what\n\
+context @var{exp} will be used for. This target hook is the same as the\n\
@code{TARGET_LEGITIMATE_ADDRESS_P} target hook, except that it includes\n\
explicit named address space support.",
- bool, (machine_mode mode, rtx exp, bool strict, addr_space_t as),
+ bool, (machine_mode mode, rtx exp, bool strict, addr_space_t as, code_helper ch),
default_addr_space_legitimate_address_p)
/* Return an updated address to convert an invalid pointer to a named
bool
default_legitimate_address_p (machine_mode mode ATTRIBUTE_UNUSED,
rtx addr ATTRIBUTE_UNUSED,
- bool strict ATTRIBUTE_UNUSED)
+ bool strict ATTRIBUTE_UNUSED,
+ code_helper ATTRIBUTE_UNUSED)
{
#ifdef GO_IF_LEGITIMATE_ADDRESS
/* Defer to the old implementation using a goto. */
bool
default_addr_space_legitimate_address_p (machine_mode mode, rtx mem,
bool strict,
- addr_space_t as ATTRIBUTE_UNUSED)
+ addr_space_t as ATTRIBUTE_UNUSED,
+ code_helper code)
{
- return targetm.legitimate_address_p (mode, mem, strict);
+ return targetm.legitimate_address_p (mode, mem, strict, code);
}
/* Named address space version of LEGITIMIZE_ADDRESS.
#ifndef GCC_TARGHOOKS_H
#define GCC_TARGHOOKS_H
-extern bool default_legitimate_address_p (machine_mode, rtx, bool);
+extern bool default_legitimate_address_p (machine_mode, rtx, bool, code_helper);
extern void default_external_libcall (rtx);
extern rtx default_legitimize_address (rtx, rtx, machine_mode);
extern scalar_int_mode default_addr_space_address_mode (addr_space_t);
extern bool default_addr_space_valid_pointer_mode (scalar_int_mode,
addr_space_t);
-extern bool default_addr_space_legitimate_address_p (machine_mode, rtx,
- bool, addr_space_t);
+extern bool default_addr_space_legitimate_address_p (machine_mode, rtx, bool,
+ addr_space_t, code_helper);
extern rtx default_addr_space_legitimize_address (rtx, rtx, machine_mode,
addr_space_t);
extern bool default_addr_space_subset_p (addr_space_t, addr_space_t);
projects / thirdparty / gcc.git / commitdiff
