Boston, MA 02111-1307, USA. */
-extern int m68hc11_override_options PARAMS((void));
-extern int m68hc11_optimization_options PARAMS((int,int));
-extern void m68hc11_conditional_register_usage PARAMS((void));
-extern int hard_regno_mode_ok PARAMS((int, enum machine_mode));
-extern int m68hc11_hard_regno_rename_ok PARAMS((int, int));
+extern int m68hc11_override_options (void);
+extern int m68hc11_optimization_options (int,int);
+extern void m68hc11_conditional_register_usage (void);
+extern int hard_regno_mode_ok (int, enum machine_mode);
+extern int m68hc11_hard_regno_rename_ok (int, int);
-extern int m68hc11_total_frame_size PARAMS((void));
-extern int m68hc11_initial_frame_pointer_offset PARAMS((void));
-extern int m68hc11_initial_elimination_offset PARAMS((int, int));
+extern int m68hc11_total_frame_size (void);
+extern int m68hc11_initial_frame_pointer_offset (void);
+extern int m68hc11_initial_elimination_offset (int, int);
-extern void expand_prologue PARAMS((void));
-extern void expand_epilogue PARAMS((void));
+extern void expand_prologue (void);
+extern void expand_epilogue (void);
#ifdef TREE_CODE
-extern void m68hc11_function_arg_advance PARAMS((CUMULATIVE_ARGS*,
- enum machine_mode,
- tree,
- int));
+extern void m68hc11_function_arg_advance (CUMULATIVE_ARGS*,
+ enum machine_mode,
+ tree,
+ int);
#endif
#ifdef RTX_CODE
-extern void m68hc11_initialize_trampoline PARAMS((rtx, rtx, rtx));
+extern void m68hc11_initialize_trampoline (rtx, rtx, rtx);
-extern rtx m68hc11_expand_compare_and_branch PARAMS((enum rtx_code,
- rtx, rtx, rtx));
-extern enum reg_class preferred_reload_class PARAMS((rtx, enum reg_class));
+extern rtx m68hc11_expand_compare_and_branch (enum rtx_code, rtx, rtx, rtx);
+extern enum reg_class preferred_reload_class (rtx, enum reg_class);
-extern int m68hc11_go_if_legitimate_address PARAMS((rtx,
- enum machine_mode,
- int));
+extern int m68hc11_go_if_legitimate_address (rtx, enum machine_mode, int);
-extern int m68hc11_legitimize_address PARAMS((rtx*, rtx, enum machine_mode));
+extern int m68hc11_legitimize_address (rtx*, rtx, enum machine_mode);
-extern void m68hc11_notice_update_cc PARAMS((rtx, rtx));
-extern void m68hc11_notice_keep_cc PARAMS((rtx));
+extern void m68hc11_notice_update_cc (rtx, rtx);
+extern void m68hc11_notice_keep_cc (rtx);
-extern void m68hc11_gen_movqi PARAMS((rtx, rtx*));
-extern void m68hc11_gen_movhi PARAMS((rtx, rtx*));
-extern void m68hc11_gen_rotate PARAMS((enum rtx_code, rtx, rtx*));
+extern void m68hc11_gen_movqi (rtx, rtx*);
+extern void m68hc11_gen_movhi (rtx, rtx*);
+extern void m68hc11_gen_rotate (enum rtx_code, rtx, rtx*);
-extern void m68hc11_output_swap PARAMS((rtx,rtx*));
+extern void m68hc11_output_swap (rtx, rtx*);
-extern int next_insn_test_reg PARAMS((rtx,rtx));
+extern int next_insn_test_reg (rtx, rtx);
-extern void print_operand PARAMS((FILE*,rtx,int));
-extern void print_operand_address PARAMS((FILE*,rtx));
+extern void print_operand (FILE*, rtx, int);
+extern void print_operand_address (FILE*, rtx);
-extern int m68hc11_reload_operands PARAMS((rtx*));
+extern int m68hc11_reload_operands (rtx*);
-extern int dead_register_here PARAMS((rtx, rtx));
+extern int dead_register_here (rtx, rtx);
-extern int push_pop_operand_p PARAMS((rtx));
-extern void m68hc11_split_move PARAMS((rtx, rtx, rtx));
-extern void m68hc11_split_compare_and_branch PARAMS((enum rtx_code,
- rtx, rtx, rtx));
-extern void aux_restore_IX_IY PARAMS((rtx));
-extern void aux_validate_IX_IY PARAMS((rtx));
+extern int push_pop_operand_p (rtx);
+extern void m68hc11_split_move (rtx, rtx, rtx);
+extern void m68hc11_split_compare_and_branch (enum rtx_code,
+ rtx, rtx, rtx);
-extern rtx m68hc11_gen_lowpart PARAMS((enum machine_mode, rtx));
-extern rtx m68hc11_gen_highpart PARAMS((enum machine_mode, rtx));
+extern rtx m68hc11_gen_lowpart (enum machine_mode, rtx);
+extern rtx m68hc11_gen_highpart (enum machine_mode, rtx);
#ifdef HAVE_MACHINE_MODES
-extern int m68hc11_memory_move_cost PARAMS((enum machine_mode, enum reg_class,
- int));
-extern int m68hc11_register_move_cost PARAMS((enum machine_mode,
- enum reg_class, enum reg_class));
-
-extern void m68hc11_emit_libcall PARAMS((const char*, enum rtx_code,
- enum machine_mode, enum machine_mode,
- int, rtx*));
-extern int m68hc11_small_indexed_indirect_p PARAMS((rtx, enum machine_mode));
-extern int m68hc11_symbolic_p PARAMS((rtx, enum machine_mode));
-extern int m68hc11_indirect_p PARAMS((rtx, enum machine_mode));
-extern int go_if_legitimate_address2 PARAMS((rtx, enum machine_mode, int));
-
-extern int reg_or_indexed_operand PARAMS((rtx,enum machine_mode));
-extern int tst_operand PARAMS((rtx,enum machine_mode));
-extern int cmp_operand PARAMS((rtx,enum machine_mode));
-extern int memory_indexed_operand PARAMS((rtx, enum machine_mode));
-
-extern void m68hc11_split_logical PARAMS((enum machine_mode, int, rtx*));
-
-extern int m68hc11_register_indirect_p PARAMS((rtx, enum machine_mode));
-
-extern int symbolic_memory_operand PARAMS((rtx, enum machine_mode));
-
-extern int memory_reload_operand PARAMS((rtx, enum machine_mode));
-extern int stack_register_operand PARAMS((rtx, enum machine_mode));
-extern int d_register_operand PARAMS((rtx, enum machine_mode));
-extern int hard_addr_reg_operand PARAMS((rtx, enum machine_mode));
-extern int arith_src_operand PARAMS((rtx, enum machine_mode));
-extern int m68hc11_logical_operator PARAMS((rtx, enum machine_mode));
-extern int m68hc11_arith_operator PARAMS((rtx, enum machine_mode));
-extern int m68hc11_non_shift_operator PARAMS((rtx, enum machine_mode));
-extern int m68hc11_shift_operator PARAMS((rtx, enum machine_mode));
-extern int m68hc11_unary_operator PARAMS((rtx, enum machine_mode));
-extern int m68hc11_eq_compare_operator PARAMS((rtx, enum machine_mode));
-extern int non_push_operand PARAMS((rtx, enum machine_mode));
-extern int hard_reg_operand PARAMS((rtx, enum machine_mode));
-extern int soft_reg_operand PARAMS((rtx, enum machine_mode));
-extern int reg_or_some_mem_operand PARAMS((rtx, enum machine_mode));
+extern int m68hc11_memory_move_cost (enum machine_mode, enum reg_class, int);
+extern int m68hc11_register_move_cost (enum machine_mode,
+ enum reg_class, enum reg_class);
+
+extern void m68hc11_emit_libcall (const char*, enum rtx_code,
+ enum machine_mode, enum machine_mode,
+ int, rtx*);
+extern int m68hc11_small_indexed_indirect_p (rtx, enum machine_mode);
+extern int m68hc11_symbolic_p (rtx, enum machine_mode);
+extern int m68hc11_indirect_p (rtx, enum machine_mode);
+extern int go_if_legitimate_address2 (rtx, enum machine_mode, int);
+
+extern int reg_or_indexed_operand (rtx,enum machine_mode);
+extern int tst_operand (rtx,enum machine_mode);
+extern int cmp_operand (rtx,enum machine_mode);
+extern int memory_indexed_operand (rtx, enum machine_mode);
+
+extern void m68hc11_split_logical (enum machine_mode, int, rtx*);
+
+extern int m68hc11_register_indirect_p (rtx, enum machine_mode);
+
+extern int symbolic_memory_operand (rtx, enum machine_mode);
+
+extern int memory_reload_operand (rtx, enum machine_mode);
+extern int stack_register_operand (rtx, enum machine_mode);
+extern int d_register_operand (rtx, enum machine_mode);
+extern int hard_addr_reg_operand (rtx, enum machine_mode);
+extern int arith_src_operand (rtx, enum machine_mode);
+extern int m68hc11_logical_operator (rtx, enum machine_mode);
+extern int m68hc11_arith_operator (rtx, enum machine_mode);
+extern int m68hc11_non_shift_operator (rtx, enum machine_mode);
+extern int m68hc11_shift_operator (rtx, enum machine_mode);
+extern int m68hc11_unary_operator (rtx, enum machine_mode);
+extern int m68hc11_eq_compare_operator (rtx, enum machine_mode);
+extern int non_push_operand (rtx, enum machine_mode);
+extern int hard_reg_operand (rtx, enum machine_mode);
+extern int soft_reg_operand (rtx, enum machine_mode);
+extern int reg_or_some_mem_operand (rtx, enum machine_mode);
#if defined TREE_CODE
-extern void m68hc11_init_cumulative_args PARAMS((CUMULATIVE_ARGS*,
- tree,
- rtx));
-
-extern rtx m68hc11_function_arg PARAMS((const CUMULATIVE_ARGS* ,
- enum machine_mode,
- tree, int));
-extern int m68hc11_function_arg_pass_by_reference PARAMS((const CUMULATIVE_ARGS*,
- enum machine_mode,
- tree,
- int));
-extern int m68hc11_function_arg_padding PARAMS((enum machine_mode, tree));
-
-extern void m68hc11_function_epilogue PARAMS((FILE*,int));
-
-extern int m68hc11_is_far_symbol PARAMS((rtx));
-extern int m68hc11_is_trap_symbol PARAMS((rtx));
+extern void m68hc11_init_cumulative_args (CUMULATIVE_ARGS*, tree, rtx);
+
+extern rtx m68hc11_function_arg (const CUMULATIVE_ARGS* ,
+ enum machine_mode,
+ tree, int);
+extern int m68hc11_function_arg_pass_by_reference (const CUMULATIVE_ARGS*,
+ enum machine_mode,
+ tree,
+ int);
+extern int m68hc11_function_arg_padding (enum machine_mode, tree);
+
+extern void m68hc11_function_epilogue (FILE*,int);
+
+extern int m68hc11_is_far_symbol (rtx);
+extern int m68hc11_is_trap_symbol (rtx);
#endif /* TREE_CODE */
#include "target.h"
#include "target-def.h"
-static void emit_move_after_reload PARAMS ((rtx, rtx, rtx));
-static rtx simplify_logical PARAMS ((enum machine_mode, int, rtx, rtx *));
-static void m68hc11_emit_logical PARAMS ((enum machine_mode, int, rtx *));
-static void m68hc11_reorg PARAMS ((void));
-static int go_if_legitimate_address_internal PARAMS((rtx, enum machine_mode,
- int));
-static int register_indirect_p PARAMS((rtx, enum machine_mode, int));
-static rtx m68hc11_expand_compare PARAMS((enum rtx_code, rtx, rtx));
-static int must_parenthesize PARAMS ((rtx));
-static int m68hc11_address_cost PARAMS ((rtx));
-static int m68hc11_shift_cost PARAMS ((enum machine_mode, rtx, int));
-static int m68hc11_rtx_costs_1 PARAMS ((rtx, enum rtx_code, enum rtx_code));
-static bool m68hc11_rtx_costs PARAMS ((rtx, int, int, int *));
-static int m68hc11_auto_inc_p PARAMS ((rtx));
-static tree m68hc11_handle_fntype_attribute PARAMS ((tree *, tree, tree, int, bool *));
+static void emit_move_after_reload (rtx, rtx, rtx);
+static rtx simplify_logical (enum machine_mode, int, rtx, rtx *);
+static void m68hc11_emit_logical (enum machine_mode, int, rtx *);
+static void m68hc11_reorg (void);
+static int go_if_legitimate_address_internal (rtx, enum machine_mode, int);
+static int register_indirect_p (rtx, enum machine_mode, int);
+static rtx m68hc11_expand_compare (enum rtx_code, rtx, rtx);
+static int must_parenthesize (rtx);
+static int m68hc11_address_cost (rtx);
+static int m68hc11_shift_cost (enum machine_mode, rtx, int);
+static int m68hc11_rtx_costs_1 (rtx, enum rtx_code, enum rtx_code);
+static bool m68hc11_rtx_costs (rtx, int, int, int *);
+static int m68hc11_auto_inc_p (rtx);
+static tree m68hc11_handle_fntype_attribute (tree *, tree, tree, int, bool *);
const struct attribute_spec m68hc11_attribute_table[];
-void create_regs_rtx PARAMS ((void));
+void create_regs_rtx (void);
-static void asm_print_register PARAMS ((FILE *, int));
-static void m68hc11_output_function_epilogue PARAMS ((FILE *, HOST_WIDE_INT));
-static void m68hc11_asm_out_constructor PARAMS ((rtx, int));
-static void m68hc11_asm_out_destructor PARAMS ((rtx, int));
-static void m68hc11_file_start PARAMS ((void));
-static void m68hc11_encode_section_info PARAMS((tree, rtx, int));
-static int autoinc_mode PARAMS((rtx));
-static int m68hc11_make_autoinc_notes PARAMS((rtx *, void *));
-static void m68hc11_init_libfuncs PARAMS ((void));
+static void asm_print_register (FILE *, int);
+static void m68hc11_output_function_epilogue (FILE *, HOST_WIDE_INT);
+static void m68hc11_asm_out_constructor (rtx, int);
+static void m68hc11_asm_out_destructor (rtx, int);
+static void m68hc11_file_start (void);
+static void m68hc11_encode_section_info (tree, rtx, int);
+static unsigned int m68hc11_section_type_flags (tree, const char*, int);
+static int autoinc_mode (rtx);
+static int m68hc11_make_autoinc_notes (rtx *, void *);
+static void m68hc11_init_libfuncs (void);
/* Must be set to 1 to produce debug messages. */
int debug_m6811 = 0;
#undef TARGET_ENCODE_SECTION_INFO
#define TARGET_ENCODE_SECTION_INFO m68hc11_encode_section_info
+#undef TARGET_SECTION_TYPE_FLAGS
+#define TARGET_SECTION_TYPE_FLAGS m68hc11_section_type_flags
+
#undef TARGET_RTX_COSTS
#define TARGET_RTX_COSTS m68hc11_rtx_costs
#undef TARGET_ADDRESS_COST
struct gcc_target targetm = TARGET_INITIALIZER;
\f
int
-m68hc11_override_options ()
+m68hc11_override_options (void)
{
memset (m68hc11_reg_valid_for_index, 0,
sizeof (m68hc11_reg_valid_for_index));
void
-m68hc11_conditional_register_usage ()
+m68hc11_conditional_register_usage (void)
{
int i;
int cnt = atoi (m68hc11_soft_reg_count);
void
-create_regs_rtx ()
+create_regs_rtx (void)
{
/* regs_inited = 1; */
ix_reg = gen_rtx (REG, HImode, HARD_X_REGNUM);
registers. They may be stored in soft registers if there are
enough of them. */
int
-hard_regno_mode_ok (regno, mode)
- int regno;
- enum machine_mode mode;
+hard_regno_mode_ok (int regno, enum machine_mode mode)
{
switch (GET_MODE_SIZE (mode))
{
}
int
-m68hc11_hard_regno_rename_ok (reg1, reg2)
- int reg1, reg2;
+m68hc11_hard_regno_rename_ok (int reg1, int reg2)
{
/* Don't accept renaming to Z register. We will replace it to
X,Y or D during machine reorg pass. */
}
enum reg_class
-preferred_reload_class (operand, class)
- rtx operand;
- enum reg_class class;
+preferred_reload_class (rtx operand, enum reg_class class)
{
enum machine_mode mode;
For 68hc11: n,r with n in [0..255] and r in A_REGS class
For 68hc12: n,r no constraint on the constant, r in A_REGS class. */
static int
-register_indirect_p (operand, mode, strict)
- rtx operand;
- enum machine_mode mode;
- int strict;
+register_indirect_p (rtx operand, enum machine_mode mode, int strict)
{
rtx base, offset;
/* Returns 1 if the operand fits in a 68HC11 indirect mode or in
a 68HC12 1-byte index addressing mode. */
int
-m68hc11_small_indexed_indirect_p (operand, mode)
- rtx operand;
- enum machine_mode mode;
+m68hc11_small_indexed_indirect_p (rtx operand, enum machine_mode mode)
{
rtx base, offset;
}
int
-m68hc11_register_indirect_p (operand, mode)
- rtx operand;
- enum machine_mode mode;
+m68hc11_register_indirect_p (rtx operand, enum machine_mode mode)
{
if (GET_CODE (operand) != MEM)
return 0;
}
static int
-go_if_legitimate_address_internal (operand, mode, strict)
- rtx operand;
- enum machine_mode mode;
- int strict;
+go_if_legitimate_address_internal (rtx operand, enum machine_mode mode,
+ int strict)
{
if (CONSTANT_ADDRESS_P (operand) && TARGET_M6812)
{
}
int
-m68hc11_go_if_legitimate_address (operand, mode, strict)
- rtx operand;
- enum machine_mode mode;
- int strict;
+m68hc11_go_if_legitimate_address (rtx operand, enum machine_mode mode,
+ int strict)
{
int result;
}
int
-m68hc11_legitimize_address (operand, old_operand, mode)
- rtx *operand ATTRIBUTE_UNUSED;
- rtx old_operand ATTRIBUTE_UNUSED;
- enum machine_mode mode ATTRIBUTE_UNUSED;
+m68hc11_legitimize_address (rtx *operand ATTRIBUTE_UNUSED,
+ rtx old_operand ATTRIBUTE_UNUSED,
+ enum machine_mode mode ATTRIBUTE_UNUSED)
{
return 0;
}
int
-m68hc11_reload_operands (operands)
- rtx operands[];
+m68hc11_reload_operands (rtx operands[])
{
enum machine_mode mode;
}
void
-m68hc11_emit_libcall (name, code, dmode, smode, noperands, operands)
- const char *name;
- enum rtx_code code;
- enum machine_mode dmode;
- enum machine_mode smode;
- int noperands;
- rtx *operands;
+m68hc11_emit_libcall (const char *name, enum rtx_code code,
+ enum machine_mode dmode, enum machine_mode smode,
+ int noperands, rtx *operands)
{
rtx ret;
rtx insns;
(same as auto_inc_p() in rtlanal.c but do not take into
account the stack). */
static int
-m68hc11_auto_inc_p (x)
- rtx x;
+m68hc11_auto_inc_p (rtx x)
{
return GET_CODE (x) == PRE_DEC
|| GET_CODE (x) == POST_INC
/* Predicates for machine description. */
int
-memory_reload_operand (operand, mode)
- rtx operand;
- enum machine_mode mode ATTRIBUTE_UNUSED;
+memory_reload_operand (rtx operand, enum machine_mode mode ATTRIBUTE_UNUSED)
{
return GET_CODE (operand) == MEM
&& GET_CODE (XEXP (operand, 0)) == PLUS
}
int
-tst_operand (operand, mode)
- rtx operand;
- enum machine_mode mode;
+tst_operand (rtx operand, enum machine_mode mode)
{
if (GET_CODE (operand) == MEM && reload_completed == 0)
{
}
int
-cmp_operand (operand, mode)
- rtx operand;
- enum machine_mode mode;
+cmp_operand (rtx operand, enum machine_mode mode)
{
if (GET_CODE (operand) == MEM)
{
}
int
-non_push_operand (operand, mode)
- rtx operand;
- enum machine_mode mode;
+non_push_operand (rtx operand, enum machine_mode mode)
{
if (general_operand (operand, mode) == 0)
return 0;
}
int
-reg_or_some_mem_operand (operand, mode)
- rtx operand;
- enum machine_mode mode;
+reg_or_some_mem_operand (rtx operand, enum machine_mode mode)
{
if (GET_CODE (operand) == MEM)
{
}
int
-m68hc11_symbolic_p (operand, mode)
- rtx operand;
- enum machine_mode mode;
+m68hc11_symbolic_p (rtx operand, enum machine_mode mode)
{
if (GET_CODE (operand) == MEM)
{
}
int
-m68hc11_indirect_p (operand, mode)
- rtx operand;
- enum machine_mode mode;
+m68hc11_indirect_p (rtx operand, enum machine_mode mode)
{
if (GET_CODE (operand) == MEM)
{
}
int
-stack_register_operand (operand, mode)
- rtx operand;
- enum machine_mode mode ATTRIBUTE_UNUSED;
+stack_register_operand (rtx operand, enum machine_mode mode ATTRIBUTE_UNUSED)
{
return SP_REG_P (operand);
}
int
-d_register_operand (operand, mode)
- rtx operand;
- enum machine_mode mode ATTRIBUTE_UNUSED;
+d_register_operand (rtx operand, enum machine_mode mode)
{
if (GET_MODE (operand) != mode && mode != VOIDmode)
return 0;
}
int
-hard_addr_reg_operand (operand, mode)
- rtx operand;
- enum machine_mode mode ATTRIBUTE_UNUSED;
+hard_addr_reg_operand (rtx operand, enum machine_mode mode)
{
if (GET_MODE (operand) != mode && mode != VOIDmode)
return 0;
}
int
-hard_reg_operand (operand, mode)
- rtx operand;
- enum machine_mode mode;
+hard_reg_operand (rtx operand, enum machine_mode mode)
{
if (GET_MODE (operand) != mode && mode != VOIDmode)
return 0;
}
int
-memory_indexed_operand (operand, mode)
- rtx operand;
- enum machine_mode mode ATTRIBUTE_UNUSED;
+memory_indexed_operand (rtx operand, enum machine_mode mode ATTRIBUTE_UNUSED)
{
if (GET_CODE (operand) != MEM)
return 0;
}
int
-push_pop_operand_p (operand)
- rtx operand;
+push_pop_operand_p (rtx operand)
{
if (GET_CODE (operand) != MEM)
{
reference and a constant. */
int
-symbolic_memory_operand (op, mode)
- register rtx op;
- enum machine_mode mode;
+symbolic_memory_operand (rtx op, enum machine_mode mode)
{
switch (GET_CODE (op))
{
}
int
-m68hc11_eq_compare_operator (op, mode)
- register rtx op;
- enum machine_mode mode ATTRIBUTE_UNUSED;
+m68hc11_eq_compare_operator (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
{
return GET_CODE (op) == EQ || GET_CODE (op) == NE;
}
int
-m68hc11_logical_operator (op, mode)
- register rtx op;
- enum machine_mode mode ATTRIBUTE_UNUSED;
+m68hc11_logical_operator (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
{
return GET_CODE (op) == AND || GET_CODE (op) == IOR || GET_CODE (op) == XOR;
}
int
-m68hc11_arith_operator (op, mode)
- register rtx op;
- enum machine_mode mode ATTRIBUTE_UNUSED;
+m68hc11_arith_operator (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
{
return GET_CODE (op) == AND || GET_CODE (op) == IOR || GET_CODE (op) == XOR
|| GET_CODE (op) == PLUS || GET_CODE (op) == MINUS
}
int
-m68hc11_non_shift_operator (op, mode)
- register rtx op;
- enum machine_mode mode ATTRIBUTE_UNUSED;
+m68hc11_non_shift_operator (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
{
return GET_CODE (op) == AND || GET_CODE (op) == IOR || GET_CODE (op) == XOR
|| GET_CODE (op) == PLUS || GET_CODE (op) == MINUS;
/* Return true if op is a shift operator. */
int
-m68hc11_shift_operator (op, mode)
- register rtx op;
- enum machine_mode mode ATTRIBUTE_UNUSED;
+m68hc11_shift_operator (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
{
return GET_CODE (op) == ROTATE || GET_CODE (op) == ROTATERT
|| GET_CODE (op) == LSHIFTRT || GET_CODE (op) == ASHIFT
}
int
-m68hc11_unary_operator (op, mode)
- register rtx op;
- enum machine_mode mode ATTRIBUTE_UNUSED;
+m68hc11_unary_operator (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
{
return GET_CODE (op) == NEG || GET_CODE (op) == NOT
|| GET_CODE (op) == SIGN_EXTEND || GET_CODE (op) == ZERO_EXTEND;
*/
void
-m68hc11_initialize_trampoline (tramp, fnaddr, cxt)
- rtx tramp;
- rtx fnaddr;
- rtx cxt;
+m68hc11_initialize_trampoline (rtx tramp, rtx fnaddr, rtx cxt)
{
const char *static_chain_reg = reg_names[STATIC_CHAIN_REGNUM];
/* Handle an attribute requiring a FUNCTION_TYPE, FIELD_DECL or TYPE_DECL;
arguments as in struct attribute_spec.handler. */
static tree
-m68hc11_handle_fntype_attribute (node, name, args, flags, no_add_attrs)
- tree *node;
- tree name;
- tree args ATTRIBUTE_UNUSED;
- int flags ATTRIBUTE_UNUSED;
- bool *no_add_attrs;
+m68hc11_handle_fntype_attribute (tree *node, tree name,
+ tree args ATTRIBUTE_UNUSED,
+ int flags ATTRIBUTE_UNUSED,
+ bool *no_add_attrs)
{
if (TREE_CODE (*node) != FUNCTION_TYPE
&& TREE_CODE (*node) != METHOD_TYPE
in SYMBOL_REF_FLAG. */
static void
-m68hc11_encode_section_info (decl, rtl, first)
- tree decl;
- rtx rtl;
- int first ATTRIBUTE_UNUSED;
+m68hc11_encode_section_info (tree decl, rtx rtl, int first ATTRIBUTE_UNUSED)
{
tree func_attr;
int trap_handler;
SYMBOL_REF_FLAG (XEXP (rtl, 0)) = is_far;
}
+static unsigned int
+m68hc11_section_type_flags (tree decl, const char *name, int reloc)
+{
+ unsigned int flags = default_section_type_flags (decl, name, reloc);
+
+ if (strncmp (name, ".eeprom", 7) == 0)
+ {
+ flags |= SECTION_WRITE | SECTION_CODE | SECTION_OVERRIDE;
+ }
+
+ return flags;
+}
+
int
-m68hc11_is_far_symbol (sym)
- rtx sym;
+m68hc11_is_far_symbol (rtx sym)
{
if (GET_CODE (sym) == MEM)
sym = XEXP (sym, 0);
}
int
-m68hc11_is_trap_symbol (sym)
- rtx sym;
+m68hc11_is_trap_symbol (rtx sym)
{
if (GET_CODE (sym) == MEM)
sym = XEXP (sym, 0);
SCz: I tried to pass DImode by reference but it seems that this
does not work very well. */
int
-m68hc11_function_arg_pass_by_reference (cum, mode, type, named)
- const CUMULATIVE_ARGS *cum ATTRIBUTE_UNUSED;
- enum machine_mode mode ATTRIBUTE_UNUSED;
- tree type;
- int named ATTRIBUTE_UNUSED;
+m68hc11_function_arg_pass_by_reference (const CUMULATIVE_ARGS *cum ATTRIBUTE_UNUSED,
+ enum machine_mode mode ATTRIBUTE_UNUSED,
+ tree type,
+ int named ATTRIBUTE_UNUSED)
{
return ((type && TREE_CODE (type) == ARRAY_TYPE)
/* Consider complex values as aggregates, so care for TCmode. */
/* Define the offset between two registers, one to be eliminated, and the
other its replacement, at the start of a routine. */
int
-m68hc11_initial_elimination_offset (from, to)
- int from;
- int to;
+m68hc11_initial_elimination_offset (int from, int to)
{
int trap_handler;
tree func_attr;
For a library call, FNTYPE is 0. */
void
-m68hc11_init_cumulative_args (cum, fntype, libname)
- CUMULATIVE_ARGS *cum;
- tree fntype;
- rtx libname;
+m68hc11_init_cumulative_args (CUMULATIVE_ARGS *cum, tree fntype, rtx libname)
{
tree ret_type;
(TYPE is null for libcalls where that information may not be available.) */
void
-m68hc11_function_arg_advance (cum, mode, type, named)
- CUMULATIVE_ARGS *cum;
- enum machine_mode mode;
- tree type;
- int named ATTRIBUTE_UNUSED;
+m68hc11_function_arg_advance (CUMULATIVE_ARGS *cum, enum machine_mode mode,
+ tree type, int named ATTRIBUTE_UNUSED)
{
if (mode != BLKmode)
{
(otherwise it is an extra parameter matching an ellipsis). */
struct rtx_def *
-m68hc11_function_arg (cum, mode, type, named)
- const CUMULATIVE_ARGS *cum;
- enum machine_mode mode;
- tree type ATTRIBUTE_UNUSED;
- int named ATTRIBUTE_UNUSED;
+m68hc11_function_arg (const CUMULATIVE_ARGS *cum, enum machine_mode mode,
+ tree type ATTRIBUTE_UNUSED, int named ATTRIBUTE_UNUSED)
{
if (cum->words != 0)
{
Structures are stored left shifted in their argument slot. */
int
-m68hc11_function_arg_padding (mode, type)
- enum machine_mode mode;
- tree type;
+m68hc11_function_arg_padding (enum machine_mode mode, tree type)
{
if (type != 0 && AGGREGATE_TYPE_P (type))
return upward;
/* Emit a move after the reload pass has completed. This is used to
emit the prologue and epilogue. */
static void
-emit_move_after_reload (to, from, scratch)
- rtx to, from, scratch;
+emit_move_after_reload (rtx to, rtx from, rtx scratch)
{
rtx insn;
}
int
-m68hc11_total_frame_size ()
+m68hc11_total_frame_size (void)
{
int size;
int regno;
}
static void
-m68hc11_output_function_epilogue (out, size)
- FILE *out ATTRIBUTE_UNUSED;
- HOST_WIDE_INT size ATTRIBUTE_UNUSED;
+m68hc11_output_function_epilogue (FILE *out ATTRIBUTE_UNUSED,
+ HOST_WIDE_INT size ATTRIBUTE_UNUSED)
{
/* We catch the function epilogue generation to have a chance
to clear the z_replacement_completed flag. */
}
void
-expand_prologue ()
+expand_prologue (void)
{
tree func_attr;
int size;
}
void
-expand_epilogue ()
+expand_epilogue (void)
{
int size;
register int regno;
fixed to work for constants and 68HC11 specific registers. */
rtx
-m68hc11_gen_lowpart (mode, x)
- enum machine_mode mode;
- rtx x;
+m68hc11_gen_lowpart (enum machine_mode mode, rtx x)
{
/* We assume that the low part of an auto-inc mode is the same with
the mode changed and that the caller split the larger mode in the
}
rtx
-m68hc11_gen_highpart (mode, x)
- enum machine_mode mode;
- rtx x;
+m68hc11_gen_highpart (enum machine_mode mode, rtx x)
{
/* We assume that the high part of an auto-inc mode is the same with
the mode changed and that the caller split the larger mode in the
of code when we know that some register dies or can be clobbered. */
int
-dead_register_here (x, reg)
- rtx x;
- rtx reg;
+dead_register_here (rtx x, rtx reg)
{
rtx x_reg;
rtx p;
/* Print the name of register 'regno' in the assembly file. */
static void
-asm_print_register (file, regno)
- FILE *file;
- int regno;
+asm_print_register (FILE *file, int regno)
{
const char *name = reg_names[regno];
ignored. */
void
-print_operand (file, op, letter)
- FILE *file;
- rtx op;
- int letter;
+print_operand (FILE *file, rtx op, int letter)
{
if (letter == 't')
{
around it. This must be done only if there is a symbol whose name
is a processor register. */
static int
-must_parenthesize (op)
- rtx op;
+must_parenthesize (rtx op)
{
const char *name;
reference whose address is ADDR. ADDR is an RTL expression. */
void
-print_operand_address (file, addr)
- FILE *file;
- rtx addr;
+print_operand_address (FILE *file, rtx addr)
{
rtx base;
rtx offset;
/* Splitting of some instructions. */
static rtx
-m68hc11_expand_compare (code, op0, op1)
- enum rtx_code code;
- rtx op0, op1;
+m68hc11_expand_compare (enum rtx_code code, rtx op0, rtx op1)
{
rtx ret = 0;
}
rtx
-m68hc11_expand_compare_and_branch (code, op0, op1, label)
- enum rtx_code code;
- rtx op0, op1, label;
+m68hc11_expand_compare_and_branch (enum rtx_code code, rtx op0, rtx op1,
+ rtx label)
{
rtx tmp;
/* Return the increment/decrement mode of a MEM if it is such.
Return CONST if it is anything else. */
static int
-autoinc_mode (x)
- rtx x;
+autoinc_mode (rtx x)
{
if (GET_CODE (x) != MEM)
return CONST;
}
static int
-m68hc11_make_autoinc_notes (x, data)
- rtx *x;
- void *data;
+m68hc11_make_autoinc_notes (rtx *x, void *data)
{
rtx insn;
The scratch register 'scratch' is used as a temporary to load
store intermediate values. It must be a hard register. */
void
-m68hc11_split_move (to, from, scratch)
- rtx to, from, scratch;
+m68hc11_split_move (rtx to, rtx from, rtx scratch)
{
rtx low_to, low_from;
rtx high_to, high_from;
}
static rtx
-simplify_logical (mode, code, operand, result)
- enum machine_mode mode;
- int code;
- rtx operand;
- rtx *result;
+simplify_logical (enum machine_mode mode, int code, rtx operand, rtx *result)
{
int val;
int mask;
}
static void
-m68hc11_emit_logical (mode, code, operands)
- enum machine_mode mode;
- int code;
- rtx *operands;
+m68hc11_emit_logical (enum machine_mode mode, int code, rtx *operands)
{
rtx result;
int need_copy;
}
void
-m68hc11_split_logical (mode, code, operands)
- enum machine_mode mode;
- int code;
- rtx *operands;
+m68hc11_split_logical (enum machine_mode mode, int code, rtx *operands)
{
rtx low[4];
rtx high[4];
/* Code generation. */
void
-m68hc11_output_swap (insn, operands)
- rtx insn ATTRIBUTE_UNUSED;
- rtx operands[];
+m68hc11_output_swap (rtx insn ATTRIBUTE_UNUSED, rtx operands[])
{
/* We have to be careful with the cc_status. An address register swap
is generated for some comparison. The comparison is made with D
This is used to decide whether a move that set flags should be used
instead. */
int
-next_insn_test_reg (insn, reg)
- rtx insn;
- rtx reg;
+next_insn_test_reg (rtx insn, rtx reg)
{
rtx body;
/* Generate the code to move a 16-bit operand into another one. */
void
-m68hc11_gen_movhi (insn, operands)
- rtx insn;
- rtx *operands;
+m68hc11_gen_movhi (rtx insn, rtx *operands)
{
int reg;
}
void
-m68hc11_gen_movqi (insn, operands)
- rtx insn;
- rtx *operands;
+m68hc11_gen_movqi (rtx insn, rtx *operands)
{
/* Move a register or memory to the same location.
This is possible because such insn can appear
The source and destination must be D or A and the shift must
be a constant. */
void
-m68hc11_gen_rotate (code, insn, operands)
- enum rtx_code code;
- rtx insn;
- rtx operands[];
+m68hc11_gen_rotate (enum rtx_code code, rtx insn, rtx operands[])
{
int val;
Do not alter them if the instruction would not alter the cc's. */
void
-m68hc11_notice_update_cc (exp, insn)
- rtx exp;
- rtx insn ATTRIBUTE_UNUSED;
+m68hc11_notice_update_cc (rtx exp, rtx insn ATTRIBUTE_UNUSED)
{
/* recognize SET insn's. */
if (GET_CODE (exp) == SET)
the register 'reg'. See if the previous flags can be kept for the
next instruction to avoid a comparison. */
void
-m68hc11_notice_keep_cc (reg)
- rtx reg;
+m68hc11_notice_keep_cc (rtx reg)
{
if (reg == 0
|| cc_prev_status.value1 == 0
int z_loaded_with_sp;
};
-static int m68hc11_check_z_replacement PARAMS ((rtx, struct replace_info *));
-static void m68hc11_find_z_replacement PARAMS ((rtx, struct replace_info *));
-static void m68hc11_z_replacement PARAMS ((rtx));
-static void m68hc11_reassign_regs PARAMS ((rtx));
+static int m68hc11_check_z_replacement (rtx, struct replace_info *);
+static void m68hc11_find_z_replacement (rtx, struct replace_info *);
+static void m68hc11_z_replacement (rtx);
+static void m68hc11_reassign_regs (rtx);
int z_replacement_completed = 0;
continue replacement in next insns. */
static int
-m68hc11_check_z_replacement (insn, info)
- rtx insn;
- struct replace_info *info;
+m68hc11_check_z_replacement (rtx insn, struct replace_info *info)
{
int this_insn_uses_ix;
int this_insn_uses_iy;
}
static void
-m68hc11_find_z_replacement (insn, info)
- rtx insn;
- struct replace_info *info;
+m68hc11_find_z_replacement (rtx insn, struct replace_info *info)
{
int reg;
Z and of the replacement register. */
static void
-m68hc11_z_replacement (insn)
- rtx insn;
+m68hc11_z_replacement (rtx insn)
{
rtx replace_reg_qi;
rtx replace_reg;
on the instruction. */
static void
-m68hc11_reassign_regs (first)
- rtx first;
+m68hc11_reassign_regs (rtx first)
{
rtx insn;
'z_replacement_completed' is set to 2. */
static void
-m68hc11_reorg ()
+m68hc11_reorg (void)
{
int split_done = 0;
rtx insn, first;
/* Cost of moving memory. */
int
-m68hc11_memory_move_cost (mode, class, in)
- enum machine_mode mode;
- enum reg_class class;
- int in ATTRIBUTE_UNUSED;
+m68hc11_memory_move_cost (enum machine_mode mode, enum reg_class class,
+ int in ATTRIBUTE_UNUSED)
{
if (class <= H_REGS && class > NO_REGS)
{
have a move cost of 2. Setting a higher cost will force reload to check
the constraints. */
int
-m68hc11_register_move_cost (mode, from, to)
- enum machine_mode mode;
- enum reg_class from;
- enum reg_class to;
+m68hc11_register_move_cost (enum machine_mode mode, enum reg_class from,
+ enum reg_class to)
{
/* All costs are symmetric, so reduce cases by putting the
lower number class as the destination. */
If ADDR is not a valid address, its cost is irrelevant. */
static int
-m68hc11_address_cost (addr)
- rtx addr;
+m68hc11_address_cost (rtx addr)
{
int cost = 4;
}
static int
-m68hc11_shift_cost (mode, x, shift)
- enum machine_mode mode;
- rtx x;
- int shift;
+m68hc11_shift_cost (enum machine_mode mode, rtx x, int shift)
{
int total;
}
static int
-m68hc11_rtx_costs_1 (x, code, outer_code)
- rtx x;
- enum rtx_code code;
- enum rtx_code outer_code ATTRIBUTE_UNUSED;
+m68hc11_rtx_costs_1 (rtx x, enum rtx_code code,
+ enum rtx_code outer_code ATTRIBUTE_UNUSED)
{
enum machine_mode mode = GET_MODE (x);
int extra_cost = 0;
}
static bool
-m68hc11_rtx_costs (x, code, outer_code, total)
- rtx x;
- int code, outer_code;
- int *total;
+m68hc11_rtx_costs (rtx x, int code, int outer_code, int *total)
{
switch (code)
{
\f
static void
-m68hc11_file_start ()
+m68hc11_file_start (void)
{
default_file_start ();
static void
-m68hc11_asm_out_constructor (symbol, priority)
- rtx symbol;
- int priority;
+m68hc11_asm_out_constructor (rtx symbol, int priority)
{
default_ctor_section_asm_out_constructor (symbol, priority);
fprintf (asm_out_file, "\t.globl\t__do_global_ctors\n");
}
static void
-m68hc11_asm_out_destructor (symbol, priority)
- rtx symbol;
- int priority;
+m68hc11_asm_out_destructor (rtx symbol, int priority)
{
default_dtor_section_asm_out_destructor (symbol, priority);
fprintf (asm_out_file, "\t.globl\t__do_global_dtors\n");
projects / gcc.git / commitdiff