arm.c: Convert to ISO-C.
* config/arm/arm.c: Convert to ISO-C. * config/avr/avr.h: Likewise. * config/fr30/fr30.c: Likewise. * config/ip2k/ip2k.c: Likewise. * config/mn10300/mn10300.c: Likewise. From-SVN: r74901
This commit is contained in:
Kazu Hirata
Kazu Hirata
parent
5785c0ed5d
commit
f177788284
|
|
@ -1,3 +1,11 @@
|
|||
2003-12-21 Kazu Hirata <kazu@cs.umass.edu>
|
||||
|
||||
* config/arm/arm.c: Convert to ISO-C.
|
||||
* config/avr/avr.h: Likewise.
|
||||
* config/fr30/fr30.c: Likewise.
|
||||
* config/ip2k/ip2k.c: Likewise.
|
||||
* config/mn10300/mn10300.c: Likewise.
|
||||
|
||||
2003-12-20 Andrew Pinski <pinskia@gcc.gnu.org>
|
||||
Matt Thomas <matt@3am-software.com>
|
||||
|
||||
|
|
|
|||
|
|
@ -13008,7 +13008,7 @@ aof_globalize_label (FILE *stream, const char *name)
|
|||
}
|
||||
|
||||
static void
|
||||
aof_file_start ()
|
||||
aof_file_start (void)
|
||||
{
|
||||
fputs ("__r0\tRN\t0\n", asm_out_file);
|
||||
fputs ("__a1\tRN\t0\n", asm_out_file);
|
||||
|
|
|
|||
|
|
@ -1644,7 +1644,7 @@ do { \
|
|||
#define EXTRA_SECTION_FUNCTIONS \
|
||||
\
|
||||
void \
|
||||
progmem_section () \
|
||||
progmem_section (void) \
|
||||
{ \
|
||||
if (in_section != in_progmem) \
|
||||
{ \
|
||||
|
|
|
|||
|
|
@ -154,9 +154,7 @@ struct gcc_target targetm = TARGET_INITIALIZER;
|
|||
for the current function. As a side effect it fills in the
|
||||
current_frame_info structure, if the data is available. */
|
||||
unsigned int
|
||||
fr30_compute_frame_size (from_reg, to_reg)
|
||||
int from_reg;
|
||||
int to_reg;
|
||||
fr30_compute_frame_size (int from_reg, int to_reg)
|
||||
{
|
||||
int regno;
|
||||
unsigned int return_value;
|
||||
|
|
@ -219,7 +217,7 @@ fr30_compute_frame_size (from_reg, to_reg)
|
|||
insn to prevent such scheduling. */
|
||||
|
||||
void
|
||||
fr30_expand_prologue ()
|
||||
fr30_expand_prologue (void)
|
||||
{
|
||||
int regno;
|
||||
rtx insn;
|
||||
|
|
@ -347,7 +345,7 @@ fr30_expand_prologue ()
|
|||
In some cases, it might be necessary to emit a barrier instruction as the
|
||||
first insn to prevent such scheduling. */
|
||||
void
|
||||
fr30_expand_epilogue ()
|
||||
fr30_expand_epilogue (void)
|
||||
{
|
||||
int regno;
|
||||
|
||||
|
|
@ -406,11 +404,10 @@ fr30_expand_epilogue ()
|
|||
ARG_REGS_USED_SO_FAR has *not* been updated for the last named argument
|
||||
which has type TYPE and mode MODE, and we rely on this fact. */
|
||||
void
|
||||
fr30_setup_incoming_varargs (arg_regs_used_so_far, int_mode, type, pretend_size)
|
||||
CUMULATIVE_ARGS arg_regs_used_so_far;
|
||||
int int_mode;
|
||||
tree type ATTRIBUTE_UNUSED;
|
||||
int * pretend_size;
|
||||
fr30_setup_incoming_varargs (CUMULATIVE_ARGS arg_regs_used_so_far,
|
||||
int int_mode,
|
||||
tree type ATTRIBUTE_UNUSED,
|
||||
int *pretend_size)
|
||||
{
|
||||
enum machine_mode mode = (enum machine_mode)int_mode;
|
||||
int size;
|
||||
|
|
@ -440,9 +437,7 @@ fr30_setup_incoming_varargs (arg_regs_used_so_far, int_mode, type, pretend_size)
|
|||
/* Print a memory address as an operand to reference that memory location. */
|
||||
|
||||
void
|
||||
fr30_print_operand_address (stream, address)
|
||||
FILE * stream;
|
||||
rtx address;
|
||||
fr30_print_operand_address (FILE *stream, rtx address)
|
||||
{
|
||||
switch (GET_CODE (address))
|
||||
{
|
||||
|
|
@ -461,10 +456,7 @@ fr30_print_operand_address (stream, address)
|
|||
/* Print an operand. */
|
||||
|
||||
void
|
||||
fr30_print_operand (file, x, code)
|
||||
FILE * file;
|
||||
rtx x;
|
||||
int code;
|
||||
fr30_print_operand (FILE *file, rtx x, int code)
|
||||
{
|
||||
rtx x0;
|
||||
|
||||
|
|
@ -665,9 +657,7 @@ fr30_print_operand (file, x, code)
|
|||
/* Compute the number of word sized registers needed to hold a
|
||||
function argument of mode INT_MODE and tree type TYPE. */
|
||||
int
|
||||
fr30_num_arg_regs (int_mode, type)
|
||||
int int_mode;
|
||||
tree type;
|
||||
fr30_num_arg_regs (int int_mode, tree type)
|
||||
{
|
||||
enum machine_mode mode = (enum machine_mode) int_mode;
|
||||
int size;
|
||||
|
|
@ -692,11 +682,8 @@ fr30_num_arg_regs (int_mode, type)
|
|||
parameters to the function. */
|
||||
|
||||
int
|
||||
fr30_function_arg_partial_nregs (cum, int_mode, type, named)
|
||||
CUMULATIVE_ARGS cum;
|
||||
int int_mode;
|
||||
tree type;
|
||||
int named;
|
||||
fr30_function_arg_partial_nregs (CUMULATIVE_ARGS cum, int int_mode,
|
||||
tree type, int named)
|
||||
{
|
||||
/* Unnamed arguments, ie those that are prototyped as ...
|
||||
are always passed on the stack.
|
||||
|
|
@ -718,9 +705,7 @@ fr30_function_arg_partial_nregs (cum, int_mode, type, named)
|
|||
}
|
||||
|
||||
static rtx
|
||||
fr30_pass_by_reference (valist, type)
|
||||
tree valist;
|
||||
tree type;
|
||||
fr30_pass_by_reference (tree valist, tree type)
|
||||
{
|
||||
tree type_ptr;
|
||||
tree type_ptr_ptr;
|
||||
|
|
@ -739,9 +724,7 @@ fr30_pass_by_reference (valist, type)
|
|||
}
|
||||
|
||||
static rtx
|
||||
fr30_pass_by_value (valist, type)
|
||||
tree valist;
|
||||
tree type;
|
||||
fr30_pass_by_value (tree valist, tree type)
|
||||
{
|
||||
HOST_WIDE_INT size = int_size_in_bytes (type);
|
||||
HOST_WIDE_INT rsize;
|
||||
|
|
@ -775,9 +758,7 @@ fr30_pass_by_value (valist, type)
|
|||
/* Implement `va_arg'. */
|
||||
|
||||
rtx
|
||||
fr30_va_arg (valist, type)
|
||||
tree valist;
|
||||
tree type;
|
||||
fr30_va_arg (tree valist, tree type)
|
||||
{
|
||||
HOST_WIDE_INT size;
|
||||
|
||||
|
|
@ -803,9 +784,7 @@ fr30_va_arg (valist, type)
|
|||
/* Returns true if OPERAND is an integer value suitable for use in
|
||||
an ADDSP instruction. */
|
||||
int
|
||||
stack_add_operand (operand, mode)
|
||||
rtx operand;
|
||||
Mmode mode ATTRIBUTE_UNUSED;
|
||||
stack_add_operand (rtx operand, Mmode mode ATTRIBUTE_UNUSED)
|
||||
{
|
||||
return
|
||||
(GET_CODE (operand) == CONST_INT
|
||||
|
|
@ -817,9 +796,7 @@ stack_add_operand (operand, mode)
|
|||
/* Returns true if OPERAND is an integer value suitable for use in
|
||||
an ADD por ADD2 instruction, or if it is a register. */
|
||||
int
|
||||
add_immediate_operand (operand, mode)
|
||||
rtx operand;
|
||||
Mmode mode ATTRIBUTE_UNUSED;
|
||||
add_immediate_operand (rtx operand, Mmode mode ATTRIBUTE_UNUSED)
|
||||
{
|
||||
return
|
||||
(GET_CODE (operand) == REG
|
||||
|
|
@ -830,9 +807,7 @@ add_immediate_operand (operand, mode)
|
|||
|
||||
/* Returns true if OPERAND is hard register in the range 8 - 15. */
|
||||
int
|
||||
high_register_operand (operand, mode)
|
||||
rtx operand;
|
||||
Mmode mode ATTRIBUTE_UNUSED;
|
||||
high_register_operand (rtx operand, Mmode mode ATTRIBUTE_UNUSED)
|
||||
{
|
||||
return
|
||||
(GET_CODE (operand) == REG
|
||||
|
|
@ -842,9 +817,7 @@ high_register_operand (operand, mode)
|
|||
|
||||
/* Returns true if OPERAND is hard register in the range 0 - 7. */
|
||||
int
|
||||
low_register_operand (operand, mode)
|
||||
rtx operand;
|
||||
Mmode mode ATTRIBUTE_UNUSED;
|
||||
low_register_operand (rtx operand, Mmode mode ATTRIBUTE_UNUSED)
|
||||
{
|
||||
return
|
||||
(GET_CODE (operand) == REG
|
||||
|
|
@ -853,9 +826,7 @@ low_register_operand (operand, mode)
|
|||
|
||||
/* Returns true if OPERAND is suitable for use in a CALL insn. */
|
||||
int
|
||||
call_operand (operand, mode)
|
||||
rtx operand;
|
||||
Mmode mode ATTRIBUTE_UNUSED;
|
||||
call_operand (rtx operand, Mmode mode ATTRIBUTE_UNUSED)
|
||||
{
|
||||
return (GET_CODE (operand) == MEM
|
||||
&& (GET_CODE (XEXP (operand, 0)) == SYMBOL_REF
|
||||
|
|
@ -864,9 +835,7 @@ call_operand (operand, mode)
|
|||
|
||||
/* Returns TRUE if OP is a valid operand of a DImode operation. */
|
||||
int
|
||||
di_operand (op, mode)
|
||||
rtx op;
|
||||
Mmode mode;
|
||||
di_operand (rtx op, Mmode mode)
|
||||
{
|
||||
if (register_operand (op, mode))
|
||||
return TRUE;
|
||||
|
|
@ -893,9 +862,7 @@ di_operand (op, mode)
|
|||
|
||||
/* Returns TRUE if OP is a DImode register or MEM. */
|
||||
int
|
||||
nonimmediate_di_operand (op, mode)
|
||||
rtx op;
|
||||
Mmode mode;
|
||||
nonimmediate_di_operand (rtx op, Mmode mode)
|
||||
{
|
||||
if (register_operand (op, mode))
|
||||
return TRUE;
|
||||
|
|
@ -915,10 +882,7 @@ nonimmediate_di_operand (op, mode)
|
|||
/* Returns true iff all the registers in the operands array
|
||||
are in descending or ascending order. */
|
||||
int
|
||||
fr30_check_multiple_regs (operands, num_operands, descending)
|
||||
rtx * operands;
|
||||
int num_operands;
|
||||
int descending;
|
||||
fr30_check_multiple_regs (rtx *operands, int num_operands, int descending)
|
||||
{
|
||||
if (descending)
|
||||
{
|
||||
|
|
@ -955,8 +919,7 @@ fr30_check_multiple_regs (operands, num_operands, descending)
|
|||
}
|
||||
|
||||
int
|
||||
fr30_const_double_is_zero (operand)
|
||||
rtx operand;
|
||||
fr30_const_double_is_zero (rtx operand)
|
||||
{
|
||||
REAL_VALUE_TYPE d;
|
||||
|
||||
|
|
@ -979,8 +942,7 @@ fr30_const_double_is_zero (operand)
|
|||
before we can use it. */
|
||||
|
||||
rtx
|
||||
fr30_move_double (operands)
|
||||
rtx * operands;
|
||||
fr30_move_double (rtx * operands)
|
||||
{
|
||||
rtx src = operands[1];
|
||||
rtx dest = operands[0];
|
||||
|
|
|
|||
|
|
@ -143,8 +143,7 @@ int ip2k_reorg_merge_qimode = 0;
|
|||
/* Set up local allocation order. */
|
||||
|
||||
void
|
||||
ip2k_init_local_alloc (rao)
|
||||
int * rao;
|
||||
ip2k_init_local_alloc (int *rao)
|
||||
{
|
||||
static const int alloc_order[] = REG_ALLOC_ORDER;
|
||||
|
||||
|
|
@ -159,10 +158,7 @@ ip2k_init_local_alloc (rao)
|
|||
SIZE is the number of bytes of arguments passed on the stack. */
|
||||
|
||||
int
|
||||
ip2k_return_pops_args (fundecl, funtype, size)
|
||||
tree fundecl ATTRIBUTE_UNUSED;
|
||||
tree funtype;
|
||||
int size;
|
||||
ip2k_return_pops_args (tree fundecl ATTRIBUTE_UNUSED, tree funtype, int size)
|
||||
{
|
||||
if (TREE_CODE (funtype) == IDENTIFIER_NODE)
|
||||
return size;
|
||||
|
|
@ -177,8 +173,7 @@ ip2k_return_pops_args (fundecl, funtype, size)
|
|||
/* Return nonzero if FUNC is a naked function. */
|
||||
|
||||
static int
|
||||
ip2k_naked_function_p (func)
|
||||
tree func;
|
||||
ip2k_naked_function_p (tree func)
|
||||
{
|
||||
tree a;
|
||||
|
||||
|
|
@ -191,9 +186,7 @@ ip2k_naked_function_p (func)
|
|||
|
||||
/* Output function prologue. */
|
||||
void
|
||||
function_prologue (file, size)
|
||||
FILE *file;
|
||||
HOST_WIDE_INT size;
|
||||
function_prologue (FILE *file, HOST_WIDE_INT size)
|
||||
{
|
||||
int leaf_func_p;
|
||||
int main_p;
|
||||
|
|
@ -314,9 +307,7 @@ function_prologue (file, size)
|
|||
|
||||
/* Output function epilogue. */
|
||||
void
|
||||
function_epilogue (file, size)
|
||||
FILE *file;
|
||||
HOST_WIDE_INT size;
|
||||
function_epilogue (FILE *file, HOST_WIDE_INT size)
|
||||
{
|
||||
int leaf_func_p;
|
||||
int reg,savelimit;
|
||||
|
|
@ -550,9 +541,7 @@ function_epilogue (file, size)
|
|||
STACK ALLOCATION
|
||||
<------ SP ($6:$7) */
|
||||
int
|
||||
ip2k_init_elim_offset (from, to)
|
||||
int from;
|
||||
int to;
|
||||
ip2k_init_elim_offset (int from, int to)
|
||||
{
|
||||
int leaf_func_p = leaf_function_p ();
|
||||
int no_saved_pc = leaf_func_p
|
||||
|
|
@ -597,10 +586,7 @@ ip2k_init_elim_offset (from, to)
|
|||
machine for a memory operand of mode MODE. */
|
||||
|
||||
int
|
||||
legitimate_address_p (mode, x, strict)
|
||||
enum machine_mode mode;
|
||||
rtx x;
|
||||
int strict;
|
||||
legitimate_address_p (enum machine_mode mode, rtx x, int strict)
|
||||
{
|
||||
int off;
|
||||
|
||||
|
|
@ -689,8 +675,7 @@ legitimate_address_p (mode, x, strict)
|
|||
|
||||
/* Is ADDR mode dependent? */
|
||||
int
|
||||
ip2k_mode_dependent_address (addr)
|
||||
rtx addr;
|
||||
ip2k_mode_dependent_address (rtx addr)
|
||||
{
|
||||
switch (GET_CODE (addr))
|
||||
{
|
||||
|
|
@ -712,11 +697,8 @@ ip2k_mode_dependent_address (addr)
|
|||
memory address for an operand of mode MODE. */
|
||||
|
||||
rtx
|
||||
legitimize_address (x, oldx, mode, scratch)
|
||||
rtx x;
|
||||
rtx oldx ATTRIBUTE_UNUSED;
|
||||
rtx scratch;
|
||||
enum machine_mode mode ATTRIBUTE_UNUSED;
|
||||
legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
|
||||
enum machine_mode mode ATTRIBUTE_UNUSED, rtx scratch)
|
||||
{
|
||||
rtx reg;
|
||||
|
||||
|
|
@ -747,8 +729,7 @@ legitimize_address (x, oldx, mode, scratch)
|
|||
data and stack variables reside in data memory. Only code is believed
|
||||
to be in PRAM or FLASH. */
|
||||
int
|
||||
is_regfile_address (x)
|
||||
rtx x;
|
||||
is_regfile_address (rtx x)
|
||||
{
|
||||
while (1)
|
||||
switch (GET_CODE (x))
|
||||
|
|
@ -775,9 +756,7 @@ is_regfile_address (x)
|
|||
/* Output ADDR to FILE as address. */
|
||||
|
||||
void
|
||||
print_operand_address (file, addr)
|
||||
FILE *file;
|
||||
rtx addr;
|
||||
print_operand_address (FILE *file, rtx addr)
|
||||
{
|
||||
switch (GET_CODE (addr))
|
||||
{
|
||||
|
|
@ -848,10 +827,7 @@ print_operand_address (file, addr)
|
|||
/* Output X as assembler operand to file FILE. */
|
||||
|
||||
void
|
||||
print_operand (file, x, code)
|
||||
FILE *file;
|
||||
rtx x;
|
||||
int code;
|
||||
print_operand (FILE *file, rtx x, int code)
|
||||
{
|
||||
int abcd = 0;
|
||||
unsigned long value;
|
||||
|
|
@ -1101,9 +1077,7 @@ print_operand (file, x, code)
|
|||
|
||||
/* Remember the operands for the compare. */
|
||||
const char *
|
||||
ip2k_set_compare (x, y)
|
||||
rtx x;
|
||||
rtx y;
|
||||
ip2k_set_compare (rtx x, rtx y)
|
||||
{
|
||||
ip2k_compare_operands[0] = x;
|
||||
ip2k_compare_operands[1] = y;
|
||||
|
|
@ -1112,10 +1086,7 @@ ip2k_set_compare (x, y)
|
|||
|
||||
/* Emit the code for sCOND instructions. */
|
||||
const char *
|
||||
ip2k_gen_sCOND (insn, code, dest)
|
||||
rtx insn ATTRIBUTE_UNUSED;
|
||||
enum rtx_code code;
|
||||
rtx dest;
|
||||
ip2k_gen_sCOND (rtx insn ATTRIBUTE_UNUSED, enum rtx_code code, rtx dest)
|
||||
{
|
||||
#define operands ip2k_compare_operands
|
||||
enum machine_mode mode;
|
||||
|
|
@ -1326,10 +1297,7 @@ ip2k_gen_sCOND (insn, code, dest)
|
|||
}
|
||||
|
||||
const char *
|
||||
ip2k_gen_signed_comp_branch (insn, code, label)
|
||||
rtx insn;
|
||||
enum rtx_code code;
|
||||
rtx label;
|
||||
ip2k_gen_signed_comp_branch (rtx insn, enum rtx_code code, rtx label)
|
||||
{
|
||||
#define operands ip2k_compare_operands
|
||||
enum machine_mode mode;
|
||||
|
|
@ -1675,10 +1643,7 @@ ip2k_gen_signed_comp_branch (insn, code, label)
|
|||
}
|
||||
|
||||
const char *
|
||||
ip2k_gen_unsigned_comp_branch (insn, code, label)
|
||||
rtx insn;
|
||||
enum rtx_code code;
|
||||
rtx label;
|
||||
ip2k_gen_unsigned_comp_branch (rtx insn, enum rtx_code code, rtx label)
|
||||
{
|
||||
#define operands ip2k_compare_operands
|
||||
enum machine_mode mode;
|
||||
|
|
@ -3043,9 +3008,7 @@ ip2k_gen_unsigned_comp_branch (insn, code, label)
|
|||
/* Output rtx VALUE as .byte to file FILE. */
|
||||
|
||||
void
|
||||
asm_output_char(file, value)
|
||||
FILE *file;
|
||||
rtx value;
|
||||
asm_output_char (FILE *file, rtx value)
|
||||
{
|
||||
fprintf (file, "\t.byte ");
|
||||
output_addr_const (file, value);
|
||||
|
|
@ -3056,9 +3019,7 @@ asm_output_char(file, value)
|
|||
/* Output VALUE as .byte to file FILE. */
|
||||
|
||||
void
|
||||
asm_output_byte (file,value)
|
||||
FILE *file;
|
||||
int value;
|
||||
asm_output_byte (FILE *file, int value)
|
||||
{
|
||||
fprintf (file, "\t.byte 0x%x\n",value & 0xff);
|
||||
}
|
||||
|
|
@ -3067,9 +3028,7 @@ asm_output_byte (file,value)
|
|||
/* Output rtx VALUE as .word to file FILE. */
|
||||
|
||||
void
|
||||
asm_output_short (file, value)
|
||||
FILE *file;
|
||||
rtx value;
|
||||
asm_output_short (FILE *file, rtx value)
|
||||
{
|
||||
fprintf (file, "\t.word ");
|
||||
output_addr_const (file, (value));
|
||||
|
|
@ -3080,9 +3039,7 @@ asm_output_short (file, value)
|
|||
/* Output real N to file FILE. */
|
||||
|
||||
void
|
||||
asm_output_float (file, n)
|
||||
FILE *file;
|
||||
REAL_VALUE_TYPE n;
|
||||
asm_output_float (FILE *file, REAL_VALUE_TYPE n)
|
||||
{
|
||||
long val;
|
||||
char dstr[100];
|
||||
|
|
@ -3096,9 +3053,7 @@ asm_output_float (file, n)
|
|||
/* Sets section name for declaration DECL. */
|
||||
|
||||
void
|
||||
unique_section (decl, reloc)
|
||||
tree decl;
|
||||
int reloc ATTRIBUTE_UNUSED;
|
||||
unique_section (tree decl, int reloc ATTRIBUTE_UNUSED)
|
||||
{
|
||||
int len;
|
||||
const char *name;
|
||||
|
|
@ -3131,11 +3086,8 @@ unique_section (decl, reloc)
|
|||
/* Output section name to file FILE. */
|
||||
|
||||
void
|
||||
asm_output_section_name(file, decl, name, reloc)
|
||||
FILE *file;
|
||||
tree decl ATTRIBUTE_UNUSED;
|
||||
const char *name;
|
||||
int reloc ATTRIBUTE_UNUSED;
|
||||
asm_output_section_name (FILE *file, tree decl ATTRIBUTE_UNUSED,
|
||||
const char *name, int reloc ATTRIBUTE_UNUSED)
|
||||
{
|
||||
fprintf (file, ".section %s\n", name);
|
||||
}
|
||||
|
|
@ -3145,8 +3097,7 @@ asm_output_section_name(file, decl, name, reloc)
|
|||
because registers of CLASS are needed for spill registers. */
|
||||
|
||||
enum reg_class
|
||||
class_likely_spilled_p(c)
|
||||
int c;
|
||||
class_likely_spilled_p (int c)
|
||||
{
|
||||
return (c == IP_REGS
|
||||
|| c == IPL_REGS
|
||||
|
|
@ -3176,12 +3127,10 @@ const struct attribute_spec ip2k_attribute_table[] =
|
|||
/* Handle a "progmem" attribute; arguments as in
|
||||
struct attribute_spec.handler. */
|
||||
static tree
|
||||
ip2k_handle_progmem_attribute (node, name, args, flags, no_add_attrs)
|
||||
tree *node;
|
||||
tree name;
|
||||
tree args ATTRIBUTE_UNUSED;
|
||||
int flags ATTRIBUTE_UNUSED;
|
||||
bool *no_add_attrs;
|
||||
ip2k_handle_progmem_attribute (tree *node, tree name,
|
||||
tree args ATTRIBUTE_UNUSED,
|
||||
int flags ATTRIBUTE_UNUSED,
|
||||
bool *no_add_attrs)
|
||||
{
|
||||
if (DECL_P (*node))
|
||||
{
|
||||
|
|
@ -3220,12 +3169,10 @@ ip2k_handle_progmem_attribute (node, name, args, flags, no_add_attrs)
|
|||
/* Handle an attribute requiring a FUNCTION_DECL; arguments as in
|
||||
struct attribute_spec.handler. */
|
||||
static tree
|
||||
ip2k_handle_fndecl_attribute (node, name, args, flags, no_add_attrs)
|
||||
tree *node;
|
||||
tree name;
|
||||
tree args ATTRIBUTE_UNUSED;
|
||||
int flags ATTRIBUTE_UNUSED;
|
||||
bool *no_add_attrs;
|
||||
ip2k_handle_fndecl_attribute (tree *node, tree name,
|
||||
tree args ATTRIBUTE_UNUSED,
|
||||
int flags ATTRIBUTE_UNUSED,
|
||||
bool *no_add_attrs)
|
||||
{
|
||||
if (TREE_CODE (*node) != FUNCTION_DECL)
|
||||
{
|
||||
|
|
@ -3244,10 +3191,7 @@ ip2k_handle_fndecl_attribute (node, name, args, flags, no_add_attrs)
|
|||
scanned. In either case, *TOTAL contains the cost result. */
|
||||
|
||||
static bool
|
||||
ip2k_rtx_costs (x, code, outer_code, total)
|
||||
rtx x;
|
||||
int code, outer_code;
|
||||
int *total;
|
||||
ip2k_rtx_costs (rtx x, int code, int outer_code, int *total)
|
||||
{
|
||||
enum machine_mode mode = GET_MODE (x);
|
||||
int extra_cost = 0;
|
||||
|
|
@ -3380,8 +3324,7 @@ ip2k_rtx_costs (x, code, outer_code, total)
|
|||
/* Calculate the cost of a memory address. */
|
||||
|
||||
static int
|
||||
ip2k_address_cost (x)
|
||||
rtx x;
|
||||
ip2k_address_cost (rtx x)
|
||||
{
|
||||
switch (legitimate_address_p (VOIDmode, x, 0))
|
||||
{
|
||||
|
|
@ -4160,9 +4103,7 @@ mdr_try_move_dp_reload (first_insn)
|
|||
a fixed constant, offset. If it definitely can then returns nonzero. */
|
||||
|
||||
static int
|
||||
ip2k_check_can_adjust_stack_ref (x, offset)
|
||||
rtx x;
|
||||
int offset;
|
||||
ip2k_check_can_adjust_stack_ref (rtx x, int offset)
|
||||
{
|
||||
if (GET_RTX_CLASS (GET_CODE (x)) == '2'
|
||||
|| GET_RTX_CLASS (GET_CODE (x)) == 'c')
|
||||
|
|
@ -4208,9 +4149,7 @@ ip2k_check_can_adjust_stack_ref (x, offset)
|
|||
a fixed offset. */
|
||||
|
||||
static void
|
||||
ip2k_adjust_stack_ref (x, offset)
|
||||
rtx *x;
|
||||
int offset;
|
||||
ip2k_adjust_stack_ref (rtx *x, int offset)
|
||||
{
|
||||
if (GET_RTX_CLASS (GET_CODE (*x)) == '2'
|
||||
|| GET_RTX_CLASS (GET_CODE (*x)) == 'c')
|
||||
|
|
@ -4699,9 +4638,7 @@ mdr_try_propagate_clr (first_insn)
|
|||
nonzero if we definitely don't have such a memory ref. */
|
||||
|
||||
static int
|
||||
ip2k_xexp_not_uses_reg_for_mem (x, regno)
|
||||
rtx x;
|
||||
unsigned int regno;
|
||||
ip2k_xexp_not_uses_reg_for_mem (rtx x, unsigned int regno)
|
||||
{
|
||||
if (regno & 1)
|
||||
regno &= 0xfffffffe;
|
||||
|
|
@ -5316,7 +5253,7 @@ mdr_try_wreg_elim (first_insn)
|
|||
making the subsequent runs continue to win. */
|
||||
|
||||
static void
|
||||
ip2k_reorg ()
|
||||
ip2k_reorg (void)
|
||||
{
|
||||
#ifdef IP2K_MD_REORG_PASS
|
||||
rtx first_insn, insn, set;
|
||||
|
|
@ -5518,8 +5455,7 @@ ip2k_init_libfuncs (void)
|
|||
/* Returns a bit position if mask contains only a single bit. Returns -1 if
|
||||
there were zero or more than one set bits. */
|
||||
int
|
||||
find_one_set_bit_p (mask)
|
||||
HOST_WIDE_INT mask;
|
||||
find_one_set_bit_p (HOST_WIDE_INT mask)
|
||||
{
|
||||
int i;
|
||||
unsigned HOST_WIDE_INT n = mask;
|
||||
|
|
@ -5540,8 +5476,7 @@ find_one_set_bit_p (mask)
|
|||
/* Returns a bit position if mask contains only a single clear bit.
|
||||
Returns -1 if there were zero or more than one clear bits. */
|
||||
int
|
||||
find_one_clear_bit_p (mask)
|
||||
HOST_WIDE_INT mask;
|
||||
find_one_clear_bit_p (HOST_WIDE_INT mask)
|
||||
{
|
||||
int i;
|
||||
unsigned HOST_WIDE_INT n = mask;
|
||||
|
|
@ -5568,10 +5503,8 @@ find_one_clear_bit_p (mask)
|
|||
and OPERANDS[5]. */
|
||||
|
||||
void
|
||||
ip2k_split_words (nmode, omode, operands)
|
||||
enum machine_mode nmode;
|
||||
enum machine_mode omode;
|
||||
rtx *operands;
|
||||
ip2k_split_words (enum machine_mode nmode, enum machine_mode omode,
|
||||
rtx *operands)
|
||||
{
|
||||
rtx dl, dh; /* src/dest pieces. */
|
||||
rtx sl, sh;
|
||||
|
|
@ -5759,9 +5692,7 @@ ip2k_split_words (nmode, omode, operands)
|
|||
|
||||
/* Get the low half of an operand. */
|
||||
rtx
|
||||
ip2k_get_low_half (x, mode)
|
||||
rtx x;
|
||||
enum machine_mode mode;
|
||||
ip2k_get_low_half (rtx x, enum machine_mode mode)
|
||||
{
|
||||
switch (GET_CODE (x))
|
||||
{
|
||||
|
|
@ -5860,9 +5791,7 @@ ip2k_get_low_half (x, mode)
|
|||
|
||||
/* Get the high half of an operand. */
|
||||
rtx
|
||||
ip2k_get_high_half (x, mode)
|
||||
rtx x;
|
||||
enum machine_mode mode;
|
||||
ip2k_get_high_half (rtx x, enum machine_mode mode)
|
||||
{
|
||||
switch (GET_CODE (x))
|
||||
{
|
||||
|
|
@ -5962,9 +5891,7 @@ ip2k_get_high_half (x, mode)
|
|||
or REG_FP. */
|
||||
|
||||
int
|
||||
ip2k_address_uses_reg_p (x, r)
|
||||
rtx x;
|
||||
unsigned int r;
|
||||
ip2k_address_uses_reg_p (rtx x, unsigned int r)
|
||||
{
|
||||
if (GET_CODE (x) != MEM)
|
||||
return 0;
|
||||
|
|
@ -6011,10 +5938,7 @@ ip2k_address_uses_reg_p (x, r)
|
|||
that it doesn't then we return TRUE otherwise we assume FALSE. */
|
||||
|
||||
int
|
||||
ip2k_xexp_not_uses_reg_p (x, r, rsz)
|
||||
rtx x;
|
||||
unsigned int r;
|
||||
int rsz;
|
||||
ip2k_xexp_not_uses_reg_p (rtx x, unsigned int r, int rsz)
|
||||
{
|
||||
switch (GET_CODE (x))
|
||||
{
|
||||
|
|
@ -6047,10 +5971,7 @@ ip2k_xexp_not_uses_reg_p (x, r, rsz)
|
|||
that it doesn't then we return TRUE otherwise we assume FALSE. */
|
||||
|
||||
int
|
||||
ip2k_composite_xexp_not_uses_reg_p (x, r, rsz)
|
||||
rtx x;
|
||||
unsigned int r;
|
||||
int rsz;
|
||||
ip2k_composite_xexp_not_uses_reg_p (rtx x, unsigned int r, int rsz)
|
||||
{
|
||||
if (GET_RTX_CLASS (GET_CODE (x)) == 'b')
|
||||
return (ip2k_composite_xexp_not_uses_reg_p (XEXP (x, 0), r, rsz)
|
||||
|
|
@ -6074,8 +5995,7 @@ ip2k_composite_xexp_not_uses_reg_p (x, r, rsz)
|
|||
it doesn't then we return TRUE otherwise we assume FALSE. */
|
||||
|
||||
int
|
||||
ip2k_composite_xexp_not_uses_cc0_p (x)
|
||||
rtx x;
|
||||
ip2k_composite_xexp_not_uses_cc0_p (rtx x)
|
||||
{
|
||||
if (GET_RTX_CLASS (GET_CODE (x)) == 'b')
|
||||
return (ip2k_composite_xexp_not_uses_cc0_p (XEXP (x, 0))
|
||||
|
|
@ -6096,17 +6016,13 @@ ip2k_composite_xexp_not_uses_cc0_p (x)
|
|||
}
|
||||
|
||||
int
|
||||
ip2k_split_dest_operand (x, mode)
|
||||
rtx x;
|
||||
enum machine_mode mode;
|
||||
ip2k_split_dest_operand (rtx x, enum machine_mode mode)
|
||||
{
|
||||
return nonimmediate_operand (x, mode) || push_operand (x, mode);
|
||||
}
|
||||
|
||||
int
|
||||
ip2k_nonptr_operand (x, mode)
|
||||
rtx x;
|
||||
enum machine_mode mode;
|
||||
ip2k_nonptr_operand (rtx x, enum machine_mode mode)
|
||||
{
|
||||
return register_operand (x, mode) && !ip2k_ptr_operand (x, mode);
|
||||
}
|
||||
|
|
@ -6114,9 +6030,7 @@ ip2k_nonptr_operand (x, mode)
|
|||
/* Is X a reference to IP or DP or SP? */
|
||||
|
||||
int
|
||||
ip2k_ptr_operand (x, mode)
|
||||
rtx x;
|
||||
enum machine_mode mode;
|
||||
ip2k_ptr_operand (rtx x, enum machine_mode mode)
|
||||
|
||||
{
|
||||
if (GET_CODE (x) == SUBREG)
|
||||
|
|
@ -6130,18 +6044,14 @@ ip2k_ptr_operand (x, mode)
|
|||
}
|
||||
|
||||
int
|
||||
ip2k_sp_operand (x, mode)
|
||||
rtx x;
|
||||
enum machine_mode mode ATTRIBUTE_UNUSED;
|
||||
ip2k_sp_operand (rtx x, enum machine_mode mode ATTRIBUTE_UNUSED)
|
||||
|
||||
{
|
||||
return REG_P (x) && REGNO (x) == REG_SP;
|
||||
}
|
||||
|
||||
int
|
||||
ip2k_ip_operand (x, mode)
|
||||
rtx x;
|
||||
enum machine_mode mode;
|
||||
ip2k_ip_operand (rtx x, enum machine_mode mode)
|
||||
|
||||
{
|
||||
if (GET_CODE (x) != MEM)
|
||||
|
|
@ -6163,9 +6073,7 @@ ip2k_ip_operand (x, mode)
|
|||
|
||||
/* Is X a memory address suitable for SP or DP relative addressing? */
|
||||
int
|
||||
ip2k_short_operand (x, mode)
|
||||
rtx x;
|
||||
enum machine_mode mode;
|
||||
ip2k_short_operand (rtx x, enum machine_mode mode)
|
||||
{
|
||||
int r;
|
||||
unsigned int offs = 0;
|
||||
|
|
@ -6211,9 +6119,7 @@ ip2k_short_operand (x, mode)
|
|||
}
|
||||
|
||||
int
|
||||
ip2k_nonsp_reg_operand (x, mode)
|
||||
rtx x;
|
||||
enum machine_mode mode ATTRIBUTE_UNUSED;
|
||||
ip2k_nonsp_reg_operand (rtx x, enum machine_mode mode ATTRIBUTE_UNUSED)
|
||||
{
|
||||
if (GET_CODE (x) == SUBREG)
|
||||
x = SUBREG_REG (x);
|
||||
|
|
@ -6222,9 +6128,7 @@ ip2k_nonsp_reg_operand (x, mode)
|
|||
}
|
||||
|
||||
int
|
||||
ip2k_gen_operand (x, mode)
|
||||
rtx x;
|
||||
enum machine_mode mode;
|
||||
ip2k_gen_operand (rtx x, enum machine_mode mode)
|
||||
{
|
||||
return ip2k_short_operand (x, mode)
|
||||
|| (GET_CODE (x) == SUBREG
|
||||
|
|
@ -6233,9 +6137,7 @@ ip2k_gen_operand (x, mode)
|
|||
}
|
||||
|
||||
int
|
||||
ip2k_extra_constraint (x, c)
|
||||
rtx x;
|
||||
int c;
|
||||
ip2k_extra_constraint (rtx x, int c)
|
||||
{
|
||||
switch (c)
|
||||
{
|
||||
|
|
@ -6254,18 +6156,14 @@ ip2k_extra_constraint (x, c)
|
|||
}
|
||||
|
||||
int
|
||||
ip2k_unary_operator (op, mode)
|
||||
rtx op;
|
||||
enum machine_mode mode;
|
||||
ip2k_unary_operator (rtx op, enum machine_mode mode)
|
||||
{
|
||||
return ((mode == VOIDmode || GET_MODE (op) == mode)
|
||||
&& GET_RTX_CLASS (GET_CODE (op)) == '1');
|
||||
}
|
||||
|
||||
int
|
||||
ip2k_binary_operator (op, mode)
|
||||
rtx op;
|
||||
enum machine_mode mode;
|
||||
ip2k_binary_operator (rtx op, enum machine_mode mode)
|
||||
{
|
||||
return ((mode == VOIDmode || GET_MODE (op) == mode)
|
||||
&& (GET_RTX_CLASS (GET_CODE (op)) == 'c'
|
||||
|
|
@ -6273,9 +6171,7 @@ ip2k_binary_operator (op, mode)
|
|||
}
|
||||
|
||||
int
|
||||
ip2k_symbol_ref_operand (op, mode)
|
||||
rtx op;
|
||||
enum machine_mode mode ATTRIBUTE_UNUSED;
|
||||
ip2k_symbol_ref_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
|
||||
{
|
||||
/* We define an IP2k symbol ref to be either a direct reference or one
|
||||
with a constant offset. */
|
||||
|
|
@ -6286,18 +6182,14 @@ ip2k_symbol_ref_operand (op, mode)
|
|||
}
|
||||
|
||||
int
|
||||
ip2k_signed_comparison_operator (op, mode)
|
||||
rtx op;
|
||||
enum machine_mode mode;
|
||||
ip2k_signed_comparison_operator (rtx op, enum machine_mode mode)
|
||||
{
|
||||
return (comparison_operator (op, mode)
|
||||
&& signed_condition (GET_CODE (op)) == GET_CODE (op));
|
||||
}
|
||||
|
||||
int
|
||||
ip2k_unsigned_comparison_operator (op, mode)
|
||||
rtx op;
|
||||
enum machine_mode mode;
|
||||
ip2k_unsigned_comparison_operator (rtx op, enum machine_mode mode)
|
||||
{
|
||||
return (comparison_operator (op, mode)
|
||||
&& unsigned_condition (GET_CODE (op)) == GET_CODE (op));
|
||||
|
|
|
|||
|
|
@ -92,7 +92,7 @@ static void mn10300_encode_section_info (tree, rtx, int);
|
|||
struct gcc_target targetm = TARGET_INITIALIZER;
|
||||
|
||||
static void
|
||||
mn10300_file_start ()
|
||||
mn10300_file_start (void)
|
||||
{
|
||||
default_file_start ();
|
||||
|
||||
|
|
@ -107,10 +107,7 @@ mn10300_file_start ()
|
|||
FILE. */
|
||||
|
||||
void
|
||||
print_operand (file, x, code)
|
||||
FILE *file;
|
||||
rtx x;
|
||||
int code;
|
||||
print_operand (FILE *file, rtx x, int code)
|
||||
{
|
||||
switch (code)
|
||||
{
|
||||
|
|
@ -437,9 +434,7 @@ print_operand (file, x, code)
|
|||
/* Output assembly language output for the address ADDR to FILE. */
|
||||
|
||||
void
|
||||
print_operand_address (file, addr)
|
||||
FILE *file;
|
||||
rtx addr;
|
||||
print_operand_address (FILE *file, rtx addr)
|
||||
{
|
||||
switch (GET_CODE (addr))
|
||||
{
|
||||
|
|
@ -477,7 +472,7 @@ print_operand_address (file, addr)
|
|||
|
||||
/* Count the number of FP registers that have to be saved. */
|
||||
static int
|
||||
fp_regs_to_save ()
|
||||
fp_regs_to_save (void)
|
||||
{
|
||||
int i, n = 0;
|
||||
|
||||
|
|
@ -498,9 +493,7 @@ fp_regs_to_save ()
|
|||
bits 14 to 17 must have the same value. */
|
||||
|
||||
void
|
||||
mn10300_print_reg_list (file, mask)
|
||||
FILE *file;
|
||||
int mask;
|
||||
mn10300_print_reg_list (FILE *file, int mask)
|
||||
{
|
||||
int need_comma;
|
||||
int i;
|
||||
|
|
@ -531,7 +524,7 @@ mn10300_print_reg_list (file, mask)
|
|||
}
|
||||
|
||||
int
|
||||
can_use_return_insn ()
|
||||
can_use_return_insn (void)
|
||||
{
|
||||
/* size includes the fixed stack space needed for function calls. */
|
||||
int size = get_frame_size () + current_function_outgoing_args_size;
|
||||
|
|
@ -558,7 +551,7 @@ can_use_return_insn ()
|
|||
all of them will be included in the mask if any one of them is used. */
|
||||
|
||||
int
|
||||
mn10300_get_live_callee_saved_regs ()
|
||||
mn10300_get_live_callee_saved_regs (void)
|
||||
{
|
||||
int mask;
|
||||
int i;
|
||||
|
|
@ -593,8 +586,7 @@ mn10300_get_live_callee_saved_regs ()
|
|||
(reg:SI R1))) */
|
||||
|
||||
void
|
||||
mn10300_gen_multiple_store (mask)
|
||||
int mask;
|
||||
mn10300_gen_multiple_store (int mask)
|
||||
{
|
||||
if (mask != 0)
|
||||
{
|
||||
|
|
@ -642,7 +634,7 @@ mn10300_gen_multiple_store (mask)
|
|||
}
|
||||
|
||||
void
|
||||
expand_prologue ()
|
||||
expand_prologue (void)
|
||||
{
|
||||
HOST_WIDE_INT size;
|
||||
|
||||
|
|
@ -917,7 +909,7 @@ expand_prologue ()
|
|||
}
|
||||
|
||||
void
|
||||
expand_epilogue ()
|
||||
expand_epilogue (void)
|
||||
{
|
||||
HOST_WIDE_INT size;
|
||||
|
||||
|
|
@ -1155,9 +1147,7 @@ expand_epilogue ()
|
|||
/* Update the condition code from the insn. */
|
||||
|
||||
void
|
||||
notice_update_cc (body, insn)
|
||||
rtx body;
|
||||
rtx insn;
|
||||
notice_update_cc (rtx body, rtx insn)
|
||||
{
|
||||
switch (get_attr_cc (insn))
|
||||
{
|
||||
|
|
@ -1220,9 +1210,7 @@ notice_update_cc (body, insn)
|
|||
registers it saves. Return 0 otherwise. */
|
||||
|
||||
int
|
||||
store_multiple_operation (op, mode)
|
||||
rtx op;
|
||||
enum machine_mode mode ATTRIBUTE_UNUSED;
|
||||
store_multiple_operation (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
|
||||
{
|
||||
int count;
|
||||
int mask;
|
||||
|
|
@ -1298,9 +1286,7 @@ store_multiple_operation (op, mode)
|
|||
/* Return true if OP is a valid call operand. */
|
||||
|
||||
int
|
||||
call_address_operand (op, mode)
|
||||
rtx op;
|
||||
enum machine_mode mode ATTRIBUTE_UNUSED;
|
||||
call_address_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
|
||||
{
|
||||
if (flag_pic)
|
||||
return (EXTRA_CONSTRAINT (op, 'S') || GET_CODE (op) == REG);
|
||||
|
|
@ -1313,10 +1299,7 @@ call_address_operand (op, mode)
|
|||
|
||||
We might be able to simplify this. */
|
||||
enum reg_class
|
||||
secondary_reload_class (class, mode, in)
|
||||
enum reg_class class;
|
||||
enum machine_mode mode;
|
||||
rtx in;
|
||||
secondary_reload_class (enum reg_class class, enum machine_mode mode, rtx in)
|
||||
{
|
||||
/* Memory loads less than a full word wide can't have an
|
||||
address or stack pointer destination. They must use
|
||||
|
|
@ -1372,8 +1355,7 @@ secondary_reload_class (class, mode, in)
|
|||
}
|
||||
|
||||
int
|
||||
initial_offset (from, to)
|
||||
int from, to;
|
||||
initial_offset (int from, int to)
|
||||
{
|
||||
/* The difference between the argument pointer and the frame pointer
|
||||
is the size of the callee register save area. */
|
||||
|
|
@ -1426,7 +1408,7 @@ initial_offset (from, to)
|
|||
/* Flush the argument registers to the stack for a stdarg function;
|
||||
return the new argument pointer. */
|
||||
rtx
|
||||
mn10300_builtin_saveregs ()
|
||||
mn10300_builtin_saveregs (void)
|
||||
{
|
||||
rtx offset, mem;
|
||||
tree fntype = TREE_TYPE (current_function_decl);
|
||||
|
|
@ -1456,17 +1438,14 @@ mn10300_builtin_saveregs ()
|
|||
}
|
||||
|
||||
void
|
||||
mn10300_va_start (valist, nextarg)
|
||||
tree valist;
|
||||
rtx nextarg;
|
||||
mn10300_va_start (tree valist, rtx nextarg)
|
||||
{
|
||||
nextarg = expand_builtin_saveregs ();
|
||||
std_expand_builtin_va_start (valist, nextarg);
|
||||
}
|
||||
|
||||
rtx
|
||||
mn10300_va_arg (valist, type)
|
||||
tree valist, type;
|
||||
mn10300_va_arg (tree valist, tree type)
|
||||
{
|
||||
HOST_WIDE_INT align, rsize;
|
||||
tree t, ptr, pptr;
|
||||
|
|
@ -1505,11 +1484,8 @@ mn10300_va_arg (valist, type)
|
|||
from a function. If the result is 0, the argument is pushed. */
|
||||
|
||||
rtx
|
||||
function_arg (cum, mode, type, named)
|
||||
CUMULATIVE_ARGS *cum;
|
||||
enum machine_mode mode;
|
||||
tree type;
|
||||
int named ATTRIBUTE_UNUSED;
|
||||
function_arg (CUMULATIVE_ARGS *cum, enum machine_mode mode,
|
||||
tree type, int named ATTRIBUTE_UNUSED)
|
||||
{
|
||||
rtx result = 0;
|
||||
int size, align;
|
||||
|
|
@ -1558,11 +1534,8 @@ function_arg (cum, mode, type, named)
|
|||
in registers and partially in memory. */
|
||||
|
||||
int
|
||||
function_arg_partial_nregs (cum, mode, type, named)
|
||||
CUMULATIVE_ARGS *cum;
|
||||
enum machine_mode mode;
|
||||
tree type;
|
||||
int named ATTRIBUTE_UNUSED;
|
||||
function_arg_partial_nregs (CUMULATIVE_ARGS *cum, enum machine_mode mode,
|
||||
tree type, int named ATTRIBUTE_UNUSED)
|
||||
{
|
||||
int size, align;
|
||||
|
||||
|
|
@ -1599,8 +1572,7 @@ function_arg_partial_nregs (cum, mode, type, named)
|
|||
|
||||
/* Output a tst insn. */
|
||||
const char *
|
||||
output_tst (operand, insn)
|
||||
rtx operand, insn;
|
||||
output_tst (rtx operand, rtx insn)
|
||||
{
|
||||
rtx temp;
|
||||
int past_call = 0;
|
||||
|
|
@ -1689,9 +1661,7 @@ output_tst (operand, insn)
|
|||
}
|
||||
|
||||
int
|
||||
impossible_plus_operand (op, mode)
|
||||
rtx op;
|
||||
enum machine_mode mode ATTRIBUTE_UNUSED;
|
||||
impossible_plus_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
|
||||
{
|
||||
if (GET_CODE (op) != PLUS)
|
||||
return 0;
|
||||
|
|
@ -1707,9 +1677,7 @@ impossible_plus_operand (op, mode)
|
|||
for the btst insn which may examine memory or a register (the memory
|
||||
variant only allows an unsigned 8 bit integer). */
|
||||
int
|
||||
const_8bit_operand (op, mode)
|
||||
register rtx op;
|
||||
enum machine_mode mode ATTRIBUTE_UNUSED;
|
||||
const_8bit_operand (register rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
|
||||
{
|
||||
return (GET_CODE (op) == CONST_INT
|
||||
&& INTVAL (op) >= 0
|
||||
|
|
@ -1718,9 +1686,7 @@ const_8bit_operand (op, mode)
|
|||
|
||||
/* Return true if the operand is the 1.0f constant. */
|
||||
int
|
||||
const_1f_operand (op, mode)
|
||||
register rtx op;
|
||||
enum machine_mode mode ATTRIBUTE_UNUSED;
|
||||
const_1f_operand (register rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
|
||||
{
|
||||
return (op == CONST1_RTX (SFmode));
|
||||
}
|
||||
|
|
@ -1728,9 +1694,7 @@ const_1f_operand (op, mode)
|
|||
/* Similarly, but when using a zero_extract pattern for a btst where
|
||||
the source operand might end up in memory. */
|
||||
int
|
||||
mask_ok_for_mem_btst (len, bit)
|
||||
int len;
|
||||
int bit;
|
||||
mask_ok_for_mem_btst (int len, int bit)
|
||||
{
|
||||
unsigned int mask = 0;
|
||||
|
||||
|
|
@ -1752,9 +1716,7 @@ mask_ok_for_mem_btst (len, bit)
|
|||
expressions will have one of a few well defined forms, so
|
||||
we need only check those forms. */
|
||||
int
|
||||
symbolic_operand (op, mode)
|
||||
register rtx op;
|
||||
enum machine_mode mode ATTRIBUTE_UNUSED;
|
||||
symbolic_operand (register rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
|
||||
{
|
||||
switch (GET_CODE (op))
|
||||
{
|
||||
|
|
@ -1787,10 +1749,8 @@ symbolic_operand (op, mode)
|
|||
But on a few ports with segmented architectures and indexed addressing
|
||||
(mn10300, hppa) it is used to rewrite certain problematical addresses. */
|
||||
rtx
|
||||
legitimize_address (x, oldx, mode)
|
||||
rtx x;
|
||||
rtx oldx ATTRIBUTE_UNUSED;
|
||||
enum machine_mode mode ATTRIBUTE_UNUSED;
|
||||
legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
|
||||
enum machine_mode mode ATTRIBUTE_UNUSED)
|
||||
{
|
||||
if (flag_pic && ! legitimate_pic_operand_p (x))
|
||||
x = legitimize_pic_address (oldx, NULL_RTX);
|
||||
|
|
@ -1828,9 +1788,7 @@ legitimize_address (x, oldx, mode)
|
|||
/* Convert a non-PIC address in `orig' to a PIC address using @GOT or
|
||||
@GOTOFF in `reg'. */
|
||||
rtx
|
||||
legitimize_pic_address (orig, reg)
|
||||
rtx orig;
|
||||
rtx reg;
|
||||
legitimize_pic_address (rtx orig, rtx reg)
|
||||
{
|
||||
if (GET_CODE (orig) == LABEL_REF
|
||||
|| (GET_CODE (orig) == SYMBOL_REF
|
||||
|
|
@ -1857,8 +1815,7 @@ legitimize_pic_address (orig, reg)
|
|||
/* Return zero if X references a SYMBOL_REF or LABEL_REF whose symbol
|
||||
isn't protected by a PIC unspec; nonzero otherwise. */
|
||||
int
|
||||
legitimate_pic_operand_p (x)
|
||||
rtx x;
|
||||
legitimate_pic_operand_p (rtx x)
|
||||
{
|
||||
register const char *fmt;
|
||||
register int i;
|
||||
|
|
@ -1895,9 +1852,7 @@ legitimate_pic_operand_p (x)
|
|||
}
|
||||
|
||||
static int
|
||||
mn10300_address_cost_1 (x, unsig)
|
||||
rtx x;
|
||||
int *unsig;
|
||||
mn10300_address_cost_1 (rtx x, int *unsig)
|
||||
{
|
||||
switch (GET_CODE (x))
|
||||
{
|
||||
|
|
@ -1976,18 +1931,14 @@ mn10300_address_cost_1 (x, unsig)
|
|||
}
|
||||
|
||||
static int
|
||||
mn10300_address_cost (x)
|
||||
rtx x;
|
||||
mn10300_address_cost (rtx x)
|
||||
{
|
||||
int s = 0;
|
||||
return mn10300_address_cost_1 (x, &s);
|
||||
}
|
||||
|
||||
static bool
|
||||
mn10300_rtx_costs (x, code, outer_code, total)
|
||||
rtx x;
|
||||
int code, outer_code;
|
||||
int *total;
|
||||
mn10300_rtx_costs (rtx x, int code, int outer_code, int *total)
|
||||
{
|
||||
switch (code)
|
||||
{
|
||||
|
|
@ -2039,8 +1990,7 @@ mn10300_rtx_costs (x, code, outer_code, total)
|
|||
movdf and movdi. */
|
||||
|
||||
bool
|
||||
mn10300_wide_const_load_uses_clr (operands)
|
||||
rtx operands[2];
|
||||
mn10300_wide_const_load_uses_clr (rtx operands[2])
|
||||
{
|
||||
long val[2];
|
||||
|
||||
|
|
@ -2085,10 +2035,7 @@ mn10300_wide_const_load_uses_clr (operands)
|
|||
may access it using GOTOFF instead of GOT. */
|
||||
|
||||
static void
|
||||
mn10300_encode_section_info (decl, rtl, first)
|
||||
tree decl;
|
||||
rtx rtl;
|
||||
int first;
|
||||
mn10300_encode_section_info (tree decl, rtx rtl, int first)
|
||||
{
|
||||
rtx symbol;
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue