/* Target Definitions for MorphoRISC1
|
/* Target Definitions for MorphoRISC1
|
Copyright (C) 2005, 2007 Free Software Foundation, Inc.
|
Copyright (C) 2005, 2007 Free Software Foundation, Inc.
|
Contributed by Red Hat, Inc.
|
Contributed by Red Hat, Inc.
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it
|
GCC is free software; you can redistribute it and/or modify it
|
under the terms of the GNU General Public License as published
|
under the terms of the GNU General Public License as published
|
by the Free Software Foundation; either version 3, or (at your
|
by the Free Software Foundation; either version 3, or (at your
|
option) any later version.
|
option) any later version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT
|
GCC is distributed in the hope that it will be useful, but WITHOUT
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
|
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
|
License for more details.
|
License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
extern struct rtx_def * mt_ucmpsi3_libcall;
|
extern struct rtx_def * mt_ucmpsi3_libcall;
|
|
|
enum processor_type
|
enum processor_type
|
{
|
{
|
PROCESSOR_MS1_64_001,
|
PROCESSOR_MS1_64_001,
|
PROCESSOR_MS1_16_002,
|
PROCESSOR_MS1_16_002,
|
PROCESSOR_MS1_16_003,
|
PROCESSOR_MS1_16_003,
|
PROCESSOR_MS2
|
PROCESSOR_MS2
|
};
|
};
|
|
|
enum epilogue_type
|
enum epilogue_type
|
{
|
{
|
EH_EPILOGUE,
|
EH_EPILOGUE,
|
NORMAL_EPILOGUE
|
NORMAL_EPILOGUE
|
};
|
};
|
|
|
extern enum processor_type mt_cpu;
|
extern enum processor_type mt_cpu;
|
|
|
|
|
/* Support for a compile-time default CPU, et cetera. The rules are:
|
/* Support for a compile-time default CPU, et cetera. The rules are:
|
--with-arch is ignored if -march is specified. */
|
--with-arch is ignored if -march is specified. */
|
#define OPTION_DEFAULT_SPECS \
|
#define OPTION_DEFAULT_SPECS \
|
{"arch", "%{!march=*:-march=%(VALUE)}" }
|
{"arch", "%{!march=*:-march=%(VALUE)}" }
|
|
|
/* A C string constant that tells the GCC driver program options to pass to
|
/* A C string constant that tells the GCC driver program options to pass to
|
the assembler. */
|
the assembler. */
|
#undef ASM_SPEC
|
#undef ASM_SPEC
|
#define ASM_SPEC "%{march=*} %{!march=*: -march=ms1-16-002}"
|
#define ASM_SPEC "%{march=*} %{!march=*: -march=ms1-16-002}"
|
|
|
/* A string to pass to at the end of the command given to the linker. */
|
/* A string to pass to at the end of the command given to the linker. */
|
#undef LIB_SPEC
|
#undef LIB_SPEC
|
#define LIB_SPEC "--start-group -lc -lsim --end-group \
|
#define LIB_SPEC "--start-group -lc -lsim --end-group \
|
%{msim: ; \
|
%{msim: ; \
|
march=ms1-64-001:-T 64-001.ld%s; \
|
march=ms1-64-001:-T 64-001.ld%s; \
|
march=ms1-16-002:-T 16-002.ld%s; \
|
march=ms1-16-002:-T 16-002.ld%s; \
|
march=ms1-16-003:-T 16-003.ld%s; \
|
march=ms1-16-003:-T 16-003.ld%s; \
|
march=ms2:-T ms2.ld%s; \
|
march=ms2:-T ms2.ld%s; \
|
:-T 16-002.ld}"
|
:-T 16-002.ld}"
|
|
|
/* A string to pass at the very beginning of the command given to the
|
/* A string to pass at the very beginning of the command given to the
|
linker. */
|
linker. */
|
#undef STARTFILE_SPEC
|
#undef STARTFILE_SPEC
|
#define STARTFILE_SPEC "%{msim:crt0.o%s;\
|
#define STARTFILE_SPEC "%{msim:crt0.o%s;\
|
march=ms1-64-001:%{!mno-crt0:crt0-64-001.o%s} startup-64-001.o%s; \
|
march=ms1-64-001:%{!mno-crt0:crt0-64-001.o%s} startup-64-001.o%s; \
|
march=ms1-16-002:%{!mno-crt0:crt0-16-002.o%s} startup-16-002.o%s; \
|
march=ms1-16-002:%{!mno-crt0:crt0-16-002.o%s} startup-16-002.o%s; \
|
march=ms1-16-003:%{!mno-crt0:crt0-16-003.o%s} startup-16-003.o%s; \
|
march=ms1-16-003:%{!mno-crt0:crt0-16-003.o%s} startup-16-003.o%s; \
|
march=ms2:%{!mno-crt0:crt0-ms2.o%s} startup-ms2.o%s; \
|
march=ms2:%{!mno-crt0:crt0-ms2.o%s} startup-ms2.o%s; \
|
:%{!mno-crt0:crt0-16-002.o%s} startup-16-002.o%s} \
|
:%{!mno-crt0:crt0-16-002.o%s} startup-16-002.o%s} \
|
crti.o%s crtbegin.o%s"
|
crti.o%s crtbegin.o%s"
|
|
|
/* A string to pass at the end of the command given to the linker. */
|
/* A string to pass at the end of the command given to the linker. */
|
#undef ENDFILE_SPEC
|
#undef ENDFILE_SPEC
|
#define ENDFILE_SPEC "%{msim:exit.o%s; \
|
#define ENDFILE_SPEC "%{msim:exit.o%s; \
|
march=ms1-64-001:exit-64-001.o%s; \
|
march=ms1-64-001:exit-64-001.o%s; \
|
march=ms1-16-002:exit-16-002.o%s; \
|
march=ms1-16-002:exit-16-002.o%s; \
|
march=ms1-16-003:exit-16-003.o%s; \
|
march=ms1-16-003:exit-16-003.o%s; \
|
march=ms2:exit-ms2.o%s; \
|
march=ms2:exit-ms2.o%s; \
|
:exit-16-002.o%s} \
|
:exit-16-002.o%s} \
|
crtend.o%s crtn.o%s"
|
crtend.o%s crtn.o%s"
|
|
|
/* Run-time target specifications. */
|
/* Run-time target specifications. */
|
|
|
#define TARGET_CPU_CPP_BUILTINS() \
|
#define TARGET_CPU_CPP_BUILTINS() \
|
do \
|
do \
|
{ \
|
{ \
|
builtin_define_with_int_value ("__mt__", mt_cpu); \
|
builtin_define_with_int_value ("__mt__", mt_cpu); \
|
builtin_assert ("machine=mt"); \
|
builtin_assert ("machine=mt"); \
|
} \
|
} \
|
while (0)
|
while (0)
|
|
|
#define TARGET_MS1_64_001 (mt_cpu == PROCESSOR_MS1_64_001)
|
#define TARGET_MS1_64_001 (mt_cpu == PROCESSOR_MS1_64_001)
|
#define TARGET_MS1_16_002 (mt_cpu == PROCESSOR_MS1_16_002)
|
#define TARGET_MS1_16_002 (mt_cpu == PROCESSOR_MS1_16_002)
|
#define TARGET_MS1_16_003 (mt_cpu == PROCESSOR_MS1_16_003)
|
#define TARGET_MS1_16_003 (mt_cpu == PROCESSOR_MS1_16_003)
|
#define TARGET_MS2 (mt_cpu == PROCESSOR_MS2)
|
#define TARGET_MS2 (mt_cpu == PROCESSOR_MS2)
|
|
|
#define TARGET_VERSION fprintf (stderr, " (mt)");
|
#define TARGET_VERSION fprintf (stderr, " (mt)");
|
|
|
#define OVERRIDE_OPTIONS mt_override_options ()
|
#define OVERRIDE_OPTIONS mt_override_options ()
|
|
|
#define CAN_DEBUG_WITHOUT_FP 1
|
#define CAN_DEBUG_WITHOUT_FP 1
|
|
|
|
|
/* Storage Layout. */
|
/* Storage Layout. */
|
|
|
#define BITS_BIG_ENDIAN 0
|
#define BITS_BIG_ENDIAN 0
|
|
|
#define BYTES_BIG_ENDIAN 1
|
#define BYTES_BIG_ENDIAN 1
|
|
|
#define WORDS_BIG_ENDIAN 1
|
#define WORDS_BIG_ENDIAN 1
|
|
|
#define UNITS_PER_WORD 4
|
#define UNITS_PER_WORD 4
|
|
|
/* A macro to update MODE and UNSIGNEDP when an object whose type is TYPE and
|
/* A macro to update MODE and UNSIGNEDP when an object whose type is TYPE and
|
which has the specified mode and signedness is to be stored in a register.
|
which has the specified mode and signedness is to be stored in a register.
|
This macro is only called when TYPE is a scalar type.
|
This macro is only called when TYPE is a scalar type.
|
|
|
On most RISC machines, which only have operations that operate on a full
|
On most RISC machines, which only have operations that operate on a full
|
register, define this macro to set M to `word_mode' if M is an integer mode
|
register, define this macro to set M to `word_mode' if M is an integer mode
|
narrower than `BITS_PER_WORD'. In most cases, only integer modes should be
|
narrower than `BITS_PER_WORD'. In most cases, only integer modes should be
|
widened because wider-precision floating-point operations are usually more
|
widened because wider-precision floating-point operations are usually more
|
expensive than their narrower counterparts.
|
expensive than their narrower counterparts.
|
|
|
For most machines, the macro definition does not change UNSIGNEDP. However,
|
For most machines, the macro definition does not change UNSIGNEDP. However,
|
some machines, have instructions that preferentially handle either signed or
|
some machines, have instructions that preferentially handle either signed or
|
unsigned quantities of certain modes. For example, on the DEC Alpha, 32-bit
|
unsigned quantities of certain modes. For example, on the DEC Alpha, 32-bit
|
loads from memory and 32-bit add instructions sign-extend the result to 64
|
loads from memory and 32-bit add instructions sign-extend the result to 64
|
bits. On such machines, set UNSIGNEDP according to which kind of extension
|
bits. On such machines, set UNSIGNEDP according to which kind of extension
|
is more efficient.
|
is more efficient.
|
|
|
Do not define this macro if it would never modify MODE. */
|
Do not define this macro if it would never modify MODE. */
|
#define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE) \
|
#define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE) \
|
do \
|
do \
|
{ \
|
{ \
|
if (GET_MODE_CLASS (MODE) == MODE_INT \
|
if (GET_MODE_CLASS (MODE) == MODE_INT \
|
&& GET_MODE_SIZE (MODE) < 4) \
|
&& GET_MODE_SIZE (MODE) < 4) \
|
(MODE) = SImode; \
|
(MODE) = SImode; \
|
} \
|
} \
|
while (0)
|
while (0)
|
|
|
/* Normal alignment required for function parameters on the stack, in bits.
|
/* Normal alignment required for function parameters on the stack, in bits.
|
All stack parameters receive at least this much alignment regardless of data
|
All stack parameters receive at least this much alignment regardless of data
|
type. On most machines, this is the same as the size of an integer. */
|
type. On most machines, this is the same as the size of an integer. */
|
#define PARM_BOUNDARY 32
|
#define PARM_BOUNDARY 32
|
|
|
/* Define this macro to the minimum alignment enforced by hardware for
|
/* Define this macro to the minimum alignment enforced by hardware for
|
the stack pointer on this machine. The definition is a C
|
the stack pointer on this machine. The definition is a C
|
expression for the desired alignment (measured in bits). This
|
expression for the desired alignment (measured in bits). This
|
value is used as a default if PREFERRED_STACK_BOUNDARY is not
|
value is used as a default if PREFERRED_STACK_BOUNDARY is not
|
defined. On most machines, this should be the same as
|
defined. On most machines, this should be the same as
|
PARM_BOUNDARY. */
|
PARM_BOUNDARY. */
|
#define STACK_BOUNDARY 32
|
#define STACK_BOUNDARY 32
|
|
|
/* Alignment required for a function entry point, in bits. */
|
/* Alignment required for a function entry point, in bits. */
|
#define FUNCTION_BOUNDARY 32
|
#define FUNCTION_BOUNDARY 32
|
|
|
/* Biggest alignment that any data type can require on this machine,
|
/* Biggest alignment that any data type can require on this machine,
|
in bits. */
|
in bits. */
|
#define BIGGEST_ALIGNMENT 32
|
#define BIGGEST_ALIGNMENT 32
|
|
|
/* If defined, a C expression to compute the alignment for a variable
|
/* If defined, a C expression to compute the alignment for a variable
|
in the static store. TYPE is the data type, and ALIGN is the
|
in the static store. TYPE is the data type, and ALIGN is the
|
alignment that the object would ordinarily have. The value of this
|
alignment that the object would ordinarily have. The value of this
|
macro is used instead of that alignment to align the object.
|
macro is used instead of that alignment to align the object.
|
|
|
If this macro is not defined, then ALIGN is used. */
|
If this macro is not defined, then ALIGN is used. */
|
#define DATA_ALIGNMENT(TYPE, ALIGN) \
|
#define DATA_ALIGNMENT(TYPE, ALIGN) \
|
(TREE_CODE (TYPE) == ARRAY_TYPE \
|
(TREE_CODE (TYPE) == ARRAY_TYPE \
|
&& TYPE_MODE (TREE_TYPE (TYPE)) == QImode \
|
&& TYPE_MODE (TREE_TYPE (TYPE)) == QImode \
|
&& (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
|
&& (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
|
|
|
/* If defined, a C expression to compute the alignment given to a constant that
|
/* If defined, a C expression to compute the alignment given to a constant that
|
is being placed in memory. CONSTANT is the constant and ALIGN is the
|
is being placed in memory. CONSTANT is the constant and ALIGN is the
|
alignment that the object would ordinarily have. The value of this macro is
|
alignment that the object would ordinarily have. The value of this macro is
|
used instead of that alignment to align the object.
|
used instead of that alignment to align the object.
|
|
|
If this macro is not defined, then ALIGN is used.
|
If this macro is not defined, then ALIGN is used.
|
|
|
The typical use of this macro is to increase alignment for string constants
|
The typical use of this macro is to increase alignment for string constants
|
to be word aligned so that `strcpy' calls that copy constants can be done
|
to be word aligned so that `strcpy' calls that copy constants can be done
|
inline. */
|
inline. */
|
#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
|
#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
|
(TREE_CODE (EXP) == STRING_CST \
|
(TREE_CODE (EXP) == STRING_CST \
|
&& (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
|
&& (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
|
|
|
/* Number of bits which any structure or union's size must be a multiple of.
|
/* Number of bits which any structure or union's size must be a multiple of.
|
Each structure or union's size is rounded up to a multiple of this.
|
Each structure or union's size is rounded up to a multiple of this.
|
|
|
If you do not define this macro, the default is the same as `BITS_PER_UNIT'. */
|
If you do not define this macro, the default is the same as `BITS_PER_UNIT'. */
|
#define STRUCTURE_SIZE_BOUNDARY 32
|
#define STRUCTURE_SIZE_BOUNDARY 32
|
|
|
/* Define this macro to be the value 1 if instructions will fail to work if
|
/* Define this macro to be the value 1 if instructions will fail to work if
|
given data not on the nominal alignment. If instructions will merely go
|
given data not on the nominal alignment. If instructions will merely go
|
slower in that case, define this macro as 0. */
|
slower in that case, define this macro as 0. */
|
#define STRICT_ALIGNMENT 1
|
#define STRICT_ALIGNMENT 1
|
|
|
/* Define this if you wish to imitate the way many other C compilers handle
|
/* Define this if you wish to imitate the way many other C compilers handle
|
alignment of bitfields and the structures that contain them. */
|
alignment of bitfields and the structures that contain them. */
|
#define PCC_BITFIELD_TYPE_MATTERS 1
|
#define PCC_BITFIELD_TYPE_MATTERS 1
|
|
|
/* Layout of Source Language Data Types. */
|
/* Layout of Source Language Data Types. */
|
|
|
#define INT_TYPE_SIZE 32
|
#define INT_TYPE_SIZE 32
|
|
|
#define SHORT_TYPE_SIZE 16
|
#define SHORT_TYPE_SIZE 16
|
|
|
#define LONG_TYPE_SIZE 32
|
#define LONG_TYPE_SIZE 32
|
|
|
#define LONG_LONG_TYPE_SIZE 64
|
#define LONG_LONG_TYPE_SIZE 64
|
|
|
#define CHAR_TYPE_SIZE 8
|
#define CHAR_TYPE_SIZE 8
|
|
|
#define FLOAT_TYPE_SIZE 32
|
#define FLOAT_TYPE_SIZE 32
|
|
|
#define DOUBLE_TYPE_SIZE 64
|
#define DOUBLE_TYPE_SIZE 64
|
|
|
#define LONG_DOUBLE_TYPE_SIZE 64
|
#define LONG_DOUBLE_TYPE_SIZE 64
|
|
|
#define DEFAULT_SIGNED_CHAR 1
|
#define DEFAULT_SIGNED_CHAR 1
|
|
|
/* Register Basics. */
|
/* Register Basics. */
|
|
|
/* General purpose registers. */
|
/* General purpose registers. */
|
#define GPR_FIRST 0 /* First gpr */
|
#define GPR_FIRST 0 /* First gpr */
|
#define GPR_LAST 15 /* Last possible gpr */
|
#define GPR_LAST 15 /* Last possible gpr */
|
|
|
#define GPR_R0 0 /* Always 0 */
|
#define GPR_R0 0 /* Always 0 */
|
#define GPR_R7 7 /* Used as a scratch register */
|
#define GPR_R7 7 /* Used as a scratch register */
|
#define GPR_R8 8 /* Used as a scratch register */
|
#define GPR_R8 8 /* Used as a scratch register */
|
#define GPR_R9 9 /* Used as a scratch register */
|
#define GPR_R9 9 /* Used as a scratch register */
|
#define GPR_R10 10 /* Used as a scratch register */
|
#define GPR_R10 10 /* Used as a scratch register */
|
#define GPR_R11 11 /* Used as a scratch register */
|
#define GPR_R11 11 /* Used as a scratch register */
|
#define GPR_FP 12 /* Frame pointer */
|
#define GPR_FP 12 /* Frame pointer */
|
#define GPR_SP 13 /* Stack pointer */
|
#define GPR_SP 13 /* Stack pointer */
|
#define GPR_LINK 14 /* Saved return address as
|
#define GPR_LINK 14 /* Saved return address as
|
seen by the caller */
|
seen by the caller */
|
#define GPR_INTERRUPT_LINK 15 /* hold return addres for interrupts */
|
#define GPR_INTERRUPT_LINK 15 /* hold return addres for interrupts */
|
|
|
#define LOOP_FIRST (GPR_LAST + 1)
|
#define LOOP_FIRST (GPR_LAST + 1)
|
#define LOOP_LAST (LOOP_FIRST + 3)
|
#define LOOP_LAST (LOOP_FIRST + 3)
|
|
|
/* Argument register that is eliminated in favor of the frame and/or stack
|
/* Argument register that is eliminated in favor of the frame and/or stack
|
pointer. Also add register to point to where the return address is
|
pointer. Also add register to point to where the return address is
|
stored. */
|
stored. */
|
#define SPECIAL_REG_FIRST (LOOP_LAST + 1)
|
#define SPECIAL_REG_FIRST (LOOP_LAST + 1)
|
#define SPECIAL_REG_LAST (SPECIAL_REG_FIRST)
|
#define SPECIAL_REG_LAST (SPECIAL_REG_FIRST)
|
#define ARG_POINTER_REGNUM (SPECIAL_REG_FIRST + 0)
|
#define ARG_POINTER_REGNUM (SPECIAL_REG_FIRST + 0)
|
#define SPECIAL_REG_P(R) ((R) == SPECIAL_REG_FIRST)
|
#define SPECIAL_REG_P(R) ((R) == SPECIAL_REG_FIRST)
|
|
|
/* The first/last register that can contain the arguments to a function. */
|
/* The first/last register that can contain the arguments to a function. */
|
#define FIRST_ARG_REGNUM 1
|
#define FIRST_ARG_REGNUM 1
|
#define LAST_ARG_REGNUM 4
|
#define LAST_ARG_REGNUM 4
|
|
|
/* The register used to hold functions return value */
|
/* The register used to hold functions return value */
|
#define RETVAL_REGNUM 11
|
#define RETVAL_REGNUM 11
|
|
|
#define FIRST_PSEUDO_REGISTER (SPECIAL_REG_LAST + 1)
|
#define FIRST_PSEUDO_REGISTER (SPECIAL_REG_LAST + 1)
|
|
|
#define IS_PSEUDO_P(R) (REGNO (R) >= FIRST_PSEUDO_REGISTER)
|
#define IS_PSEUDO_P(R) (REGNO (R) >= FIRST_PSEUDO_REGISTER)
|
|
|
/* R0 always has the value 0
|
/* R0 always has the value 0
|
R10 static link
|
R10 static link
|
R12 FP pointer to active frame
|
R12 FP pointer to active frame
|
R13 SP pointer to top of stack
|
R13 SP pointer to top of stack
|
R14 RA return address
|
R14 RA return address
|
R15 IRA interrupt return address. */
|
R15 IRA interrupt return address. */
|
#define FIXED_REGISTERS { 1, 0, 0, 0, 0, 0, 0, 0, \
|
#define FIXED_REGISTERS { 1, 0, 0, 0, 0, 0, 0, 0, \
|
0, 0, 0, 0, 1, 1, 1, 1, \
|
0, 0, 0, 0, 1, 1, 1, 1, \
|
1, 1, 1, 1, 1 \
|
1, 1, 1, 1, 1 \
|
}
|
}
|
|
|
/* Like `FIXED_REGISTERS' but has 1 for each register that is clobbered (in
|
/* Like `FIXED_REGISTERS' but has 1 for each register that is clobbered (in
|
general) by function calls as well as for fixed registers. This macro
|
general) by function calls as well as for fixed registers. This macro
|
therefore identifies the registers that are not available for general
|
therefore identifies the registers that are not available for general
|
allocation of values that must live across function calls. */
|
allocation of values that must live across function calls. */
|
#define CALL_USED_REGISTERS { 1, 1, 1, 1, 1, 0, 0, 1, \
|
#define CALL_USED_REGISTERS { 1, 1, 1, 1, 1, 0, 0, 1, \
|
1, 1, 1, 1, 1, 1, 1, 1, \
|
1, 1, 1, 1, 1, 1, 1, 1, \
|
1, 1, 1, 1, 1 \
|
1, 1, 1, 1, 1 \
|
}
|
}
|
|
|
|
|
/* How Values Fit in Registers. */
|
/* How Values Fit in Registers. */
|
|
|
#define HARD_REGNO_NREGS(REGNO, MODE) \
|
#define HARD_REGNO_NREGS(REGNO, MODE) \
|
((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
|
((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
|
|
|
#define HARD_REGNO_MODE_OK(REGNO, MODE) 1
|
#define HARD_REGNO_MODE_OK(REGNO, MODE) 1
|
|
|
/* A C expression that is nonzero if a value of mode MODE1 is
|
/* A C expression that is nonzero if a value of mode MODE1 is
|
accessible in mode MODE2 without copying. */
|
accessible in mode MODE2 without copying. */
|
#define MODES_TIEABLE_P(MODE1, MODE2) 1
|
#define MODES_TIEABLE_P(MODE1, MODE2) 1
|
|
|
/* Register Classes. */
|
/* Register Classes. */
|
|
|
enum reg_class
|
enum reg_class
|
{
|
{
|
NO_REGS,
|
NO_REGS,
|
ALL_REGS,
|
ALL_REGS,
|
LIM_REG_CLASSES
|
LIM_REG_CLASSES
|
};
|
};
|
|
|
#define GENERAL_REGS ALL_REGS
|
#define GENERAL_REGS ALL_REGS
|
|
|
#define N_REG_CLASSES ((int) LIM_REG_CLASSES)
|
#define N_REG_CLASSES ((int) LIM_REG_CLASSES)
|
|
|
#define REG_CLASS_NAMES {"NO_REGS", "ALL_REGS" }
|
#define REG_CLASS_NAMES {"NO_REGS", "ALL_REGS" }
|
|
|
#define REG_CLASS_CONTENTS \
|
#define REG_CLASS_CONTENTS \
|
{ \
|
{ \
|
{ 0x0 }, \
|
{ 0x0 }, \
|
{ 0x000fffff }, \
|
{ 0x000fffff }, \
|
}
|
}
|
|
|
/* A C expression whose value is a register class containing hard register
|
/* A C expression whose value is a register class containing hard register
|
REGNO. In general there is more than one such class; choose a class which
|
REGNO. In general there is more than one such class; choose a class which
|
is "minimal", meaning that no smaller class also contains the register. */
|
is "minimal", meaning that no smaller class also contains the register. */
|
#define REGNO_REG_CLASS(REGNO) GENERAL_REGS
|
#define REGNO_REG_CLASS(REGNO) GENERAL_REGS
|
|
|
#define BASE_REG_CLASS GENERAL_REGS
|
#define BASE_REG_CLASS GENERAL_REGS
|
|
|
#define INDEX_REG_CLASS NO_REGS
|
#define INDEX_REG_CLASS NO_REGS
|
|
|
#define REG_CLASS_FROM_LETTER(CHAR) NO_REGS
|
#define REG_CLASS_FROM_LETTER(CHAR) NO_REGS
|
|
|
#define REGNO_OK_FOR_BASE_P(NUM) 1
|
#define REGNO_OK_FOR_BASE_P(NUM) 1
|
|
|
#define REGNO_OK_FOR_INDEX_P(NUM) 1
|
#define REGNO_OK_FOR_INDEX_P(NUM) 1
|
|
|
/* A C expression that places additional restrictions on the register class to
|
/* A C expression that places additional restrictions on the register class to
|
use when it is necessary to copy value X into a register in class CLASS.
|
use when it is necessary to copy value X into a register in class CLASS.
|
The value is a register class; perhaps CLASS, or perhaps another, smaller
|
The value is a register class; perhaps CLASS, or perhaps another, smaller
|
class. On many machines, the following definition is safe:
|
class. On many machines, the following definition is safe:
|
|
|
#define PREFERRED_RELOAD_CLASS(X,CLASS) CLASS
|
#define PREFERRED_RELOAD_CLASS(X,CLASS) CLASS
|
*/
|
*/
|
#define PREFERRED_RELOAD_CLASS(X, CLASS) (CLASS)
|
#define PREFERRED_RELOAD_CLASS(X, CLASS) (CLASS)
|
|
|
#define SECONDARY_RELOAD_CLASS(CLASS,MODE,X) \
|
#define SECONDARY_RELOAD_CLASS(CLASS,MODE,X) \
|
mt_secondary_reload_class((CLASS), (MODE), (X))
|
mt_secondary_reload_class((CLASS), (MODE), (X))
|
|
|
/* A C expression for the maximum number of consecutive registers of
|
/* A C expression for the maximum number of consecutive registers of
|
class CLASS needed to hold a value of mode MODE. */
|
class CLASS needed to hold a value of mode MODE. */
|
#define CLASS_MAX_NREGS(CLASS, MODE) \
|
#define CLASS_MAX_NREGS(CLASS, MODE) \
|
((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
|
((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
|
|
|
/* For MorphoRISC1:
|
/* For MorphoRISC1:
|
|
|
`I' is used for the range of constants an arithmetic insn can
|
`I' is used for the range of constants an arithmetic insn can
|
actually contain (16 bits signed integers).
|
actually contain (16 bits signed integers).
|
|
|
`J' is used for the range which is just zero (ie, $r0).
|
`J' is used for the range which is just zero (ie, $r0).
|
|
|
`K' is used for the range of constants a logical insn can actually
|
`K' is used for the range of constants a logical insn can actually
|
contain (16 bit zero-extended integers).
|
contain (16 bit zero-extended integers).
|
|
|
`L' is used for the range of constants that be loaded with lui
|
`L' is used for the range of constants that be loaded with lui
|
(ie, the bottom 16 bits are zero).
|
(ie, the bottom 16 bits are zero).
|
|
|
`M' is used for the range of constants that take two words to load
|
`M' is used for the range of constants that take two words to load
|
(ie, not matched by `I', `K', and `L').
|
(ie, not matched by `I', `K', and `L').
|
|
|
`N' is used for negative 16 bit constants other than -65536.
|
`N' is used for negative 16 bit constants other than -65536.
|
|
|
`O' is a 15 bit signed integer.
|
`O' is a 15 bit signed integer.
|
|
|
`P' is used for positive 16 bit constants. */
|
`P' is used for positive 16 bit constants. */
|
|
|
#define SMALL_INT(X) ((unsigned HOST_WIDE_INT) (INTVAL (X) + 0x8000) < 0x10000)
|
#define SMALL_INT(X) ((unsigned HOST_WIDE_INT) (INTVAL (X) + 0x8000) < 0x10000)
|
#define SMALL_INT_UNSIGNED(X) ((unsigned HOST_WIDE_INT) (INTVAL (X)) < 0x10000)
|
#define SMALL_INT_UNSIGNED(X) ((unsigned HOST_WIDE_INT) (INTVAL (X)) < 0x10000)
|
|
|
/* A C expression that defines the machine-dependent operand
|
/* A C expression that defines the machine-dependent operand
|
constraint letters that specify particular ranges of integer
|
constraint letters that specify particular ranges of integer
|
values. If C is one of those letters, the expression should check
|
values. If C is one of those letters, the expression should check
|
that VALUE, an integer, is in the appropriate range and return 1 if
|
that VALUE, an integer, is in the appropriate range and return 1 if
|
so, 0 otherwise. If C is not one of those letters, the value
|
so, 0 otherwise. If C is not one of those letters, the value
|
should be 0 regardless of VALUE. */
|
should be 0 regardless of VALUE. */
|
#define CONST_OK_FOR_LETTER_P(VALUE, C) \
|
#define CONST_OK_FOR_LETTER_P(VALUE, C) \
|
((C) == 'I' ? ((unsigned HOST_WIDE_INT) ((VALUE) + 0x8000) < 0x10000) \
|
((C) == 'I' ? ((unsigned HOST_WIDE_INT) ((VALUE) + 0x8000) < 0x10000) \
|
: (C) == 'J' ? ((VALUE) == 0) \
|
: (C) == 'J' ? ((VALUE) == 0) \
|
: (C) == 'K' ? ((unsigned HOST_WIDE_INT) (VALUE) < 0x10000) \
|
: (C) == 'K' ? ((unsigned HOST_WIDE_INT) (VALUE) < 0x10000) \
|
: (C) == 'L' ? (((VALUE) & 0x0000ffff) == 0 \
|
: (C) == 'L' ? (((VALUE) & 0x0000ffff) == 0 \
|
&& (((VALUE) & ~2147483647) == 0 \
|
&& (((VALUE) & ~2147483647) == 0 \
|
|| ((VALUE) & ~2147483647) == ~2147483647)) \
|
|| ((VALUE) & ~2147483647) == ~2147483647)) \
|
: (C) == 'M' ? ((((VALUE) & ~0x0000ffff) != 0) \
|
: (C) == 'M' ? ((((VALUE) & ~0x0000ffff) != 0) \
|
&& (((VALUE) & ~0x0000ffff) != ~0x0000ffff) \
|
&& (((VALUE) & ~0x0000ffff) != ~0x0000ffff) \
|
&& (((VALUE) & 0x0000ffff) != 0 \
|
&& (((VALUE) & 0x0000ffff) != 0 \
|
|| (((VALUE) & ~2147483647) != 0 \
|
|| (((VALUE) & ~2147483647) != 0 \
|
&& ((VALUE) & ~2147483647) != ~2147483647))) \
|
&& ((VALUE) & ~2147483647) != ~2147483647))) \
|
: (C) == 'N' ? ((unsigned HOST_WIDE_INT) ((VALUE) + 0xffff) < 0xffff) \
|
: (C) == 'N' ? ((unsigned HOST_WIDE_INT) ((VALUE) + 0xffff) < 0xffff) \
|
: (C) == 'O' ? ((unsigned HOST_WIDE_INT) ((VALUE) + 0x4000) < 0x8000) \
|
: (C) == 'O' ? ((unsigned HOST_WIDE_INT) ((VALUE) + 0x4000) < 0x8000) \
|
: (C) == 'P' ? ((VALUE) != 0 && (((VALUE) & ~0x0000ffff) == 0)) \
|
: (C) == 'P' ? ((VALUE) != 0 && (((VALUE) & ~0x0000ffff) == 0)) \
|
: 0)
|
: 0)
|
|
|
/* A C expression that defines the machine-dependent operand constraint letters
|
/* A C expression that defines the machine-dependent operand constraint letters
|
(`G', `H') that specify particular ranges of `const_double' values. */
|
(`G', `H') that specify particular ranges of `const_double' values. */
|
#define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) 0
|
#define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) 0
|
|
|
/* Most negative value represent on mt */
|
/* Most negative value represent on mt */
|
#define MT_MIN_INT 0x80000000
|
#define MT_MIN_INT 0x80000000
|
|
|
/* Basic Stack Layout. */
|
/* Basic Stack Layout. */
|
|
|
enum save_direction
|
enum save_direction
|
{
|
{
|
FROM_PROCESSOR_TO_MEM,
|
FROM_PROCESSOR_TO_MEM,
|
FROM_MEM_TO_PROCESSOR
|
FROM_MEM_TO_PROCESSOR
|
};
|
};
|
|
|
/* Tell prologue and epilogue if register REGNO should be saved / restored.
|
/* Tell prologue and epilogue if register REGNO should be saved / restored.
|
The return address and frame pointer are treated separately.
|
The return address and frame pointer are treated separately.
|
Don't consider them here. */
|
Don't consider them here. */
|
#define MUST_SAVE_REGISTER(regno) \
|
#define MUST_SAVE_REGISTER(regno) \
|
( (regno) != GPR_LINK \
|
( (regno) != GPR_LINK \
|
&& (regno) != GPR_FP \
|
&& (regno) != GPR_FP \
|
&& (regno) != GPR_SP \
|
&& (regno) != GPR_SP \
|
&& (regno) != GPR_R0 \
|
&& (regno) != GPR_R0 \
|
&& (( regs_ever_live [regno] && ! call_used_regs [regno] ) \
|
&& (( regs_ever_live [regno] && ! call_used_regs [regno] ) \
|
/* Save ira register in an interrupt handler. */ \
|
/* Save ira register in an interrupt handler. */ \
|
|| (interrupt_handler && (regno) == GPR_INTERRUPT_LINK) \
|
|| (interrupt_handler && (regno) == GPR_INTERRUPT_LINK) \
|
/* Save any register used in an interrupt handler. */ \
|
/* Save any register used in an interrupt handler. */ \
|
|| (interrupt_handler && regs_ever_live [regno]) \
|
|| (interrupt_handler && regs_ever_live [regno]) \
|
/* Save call clobbered registers in non-leaf interrupt \
|
/* Save call clobbered registers in non-leaf interrupt \
|
handlers. */ \
|
handlers. */ \
|
|| (interrupt_handler && call_used_regs[regno] \
|
|| (interrupt_handler && call_used_regs[regno] \
|
&& !current_function_is_leaf) \
|
&& !current_function_is_leaf) \
|
||(current_function_calls_eh_return \
|
||(current_function_calls_eh_return \
|
&& (regno == GPR_R7 || regno == GPR_R8)) \
|
&& (regno == GPR_R7 || regno == GPR_R8)) \
|
) \
|
) \
|
)
|
)
|
|
|
#define STACK_GROWS_DOWNWARD 1
|
#define STACK_GROWS_DOWNWARD 1
|
|
|
/* Offset from the frame pointer to the first local variable slot to be
|
/* Offset from the frame pointer to the first local variable slot to be
|
allocated.
|
allocated.
|
|
|
If `FRAME_GROWS_DOWNWARD', find the next slot's offset by
|
If `FRAME_GROWS_DOWNWARD', find the next slot's offset by
|
subtracting the first slot's length from `STARTING_FRAME_OFFSET'.
|
subtracting the first slot's length from `STARTING_FRAME_OFFSET'.
|
Otherwise, it is found by adding the length of the first slot to
|
Otherwise, it is found by adding the length of the first slot to
|
the value `STARTING_FRAME_OFFSET'. */
|
the value `STARTING_FRAME_OFFSET'. */
|
#define STARTING_FRAME_OFFSET current_function_outgoing_args_size
|
#define STARTING_FRAME_OFFSET current_function_outgoing_args_size
|
|
|
/* Offset from the argument pointer register to the first argument's address.
|
/* Offset from the argument pointer register to the first argument's address.
|
On some machines it may depend on the data type of the function.
|
On some machines it may depend on the data type of the function.
|
|
|
If `ARGS_GROW_DOWNWARD', this is the offset to the location above the first
|
If `ARGS_GROW_DOWNWARD', this is the offset to the location above the first
|
argument's address. */
|
argument's address. */
|
#define FIRST_PARM_OFFSET(FUNDECL) 0
|
#define FIRST_PARM_OFFSET(FUNDECL) 0
|
|
|
#define RETURN_ADDR_RTX(COUNT, FRAMEADDR) \
|
#define RETURN_ADDR_RTX(COUNT, FRAMEADDR) \
|
mt_return_addr_rtx (COUNT)
|
mt_return_addr_rtx (COUNT)
|
|
|
/* A C expression whose value is RTL representing the location of the incoming
|
/* A C expression whose value is RTL representing the location of the incoming
|
return address at the beginning of any function, before the prologue. This
|
return address at the beginning of any function, before the prologue. This
|
RTL is either a `REG', indicating that the return value is saved in `REG',
|
RTL is either a `REG', indicating that the return value is saved in `REG',
|
or a `MEM' representing a location in the stack.
|
or a `MEM' representing a location in the stack.
|
|
|
You only need to define this macro if you want to support call frame
|
You only need to define this macro if you want to support call frame
|
debugging information like that provided by DWARF 2. */
|
debugging information like that provided by DWARF 2. */
|
#define INCOMING_RETURN_ADDR_RTX gen_rtx_REG (SImode, GPR_LINK)
|
#define INCOMING_RETURN_ADDR_RTX gen_rtx_REG (SImode, GPR_LINK)
|
|
|
/* A C expression whose value is an integer giving the offset, in bytes, from
|
/* A C expression whose value is an integer giving the offset, in bytes, from
|
the value of the stack pointer register to the top of the stack frame at the
|
the value of the stack pointer register to the top of the stack frame at the
|
beginning of any function, before the prologue. The top of the frame is
|
beginning of any function, before the prologue. The top of the frame is
|
defined to be the value of the stack pointer in the previous frame, just
|
defined to be the value of the stack pointer in the previous frame, just
|
before the call instruction.
|
before the call instruction.
|
|
|
You only need to define this macro if you want to support call frame
|
You only need to define this macro if you want to support call frame
|
debugging information like that provided by DWARF 2. */
|
debugging information like that provided by DWARF 2. */
|
#define INCOMING_FRAME_SP_OFFSET 0
|
#define INCOMING_FRAME_SP_OFFSET 0
|
|
|
#define STACK_POINTER_REGNUM GPR_SP
|
#define STACK_POINTER_REGNUM GPR_SP
|
|
|
#define FRAME_POINTER_REGNUM GPR_FP
|
#define FRAME_POINTER_REGNUM GPR_FP
|
|
|
/* The register number of the arg pointer register, which is used to
|
/* The register number of the arg pointer register, which is used to
|
access the function's argument list. */
|
access the function's argument list. */
|
#define ARG_POINTER_REGNUM (SPECIAL_REG_FIRST + 0)
|
#define ARG_POINTER_REGNUM (SPECIAL_REG_FIRST + 0)
|
|
|
/* Register numbers used for passing a function's static chain pointer. */
|
/* Register numbers used for passing a function's static chain pointer. */
|
#define STATIC_CHAIN_REGNUM 10
|
#define STATIC_CHAIN_REGNUM 10
|
|
|
/* A C expression which is nonzero if a function must have and use a frame
|
/* A C expression which is nonzero if a function must have and use a frame
|
pointer. */
|
pointer. */
|
#define FRAME_POINTER_REQUIRED 0
|
#define FRAME_POINTER_REQUIRED 0
|
|
|
/* Structure to be filled in by compute_frame_size with register
|
/* Structure to be filled in by compute_frame_size with register
|
save masks, and offsets for the current function. */
|
save masks, and offsets for the current function. */
|
|
|
struct mt_frame_info
|
struct mt_frame_info
|
{
|
{
|
unsigned int total_size; /* # Bytes that the entire frame takes up. */
|
unsigned int total_size; /* # Bytes that the entire frame takes up. */
|
unsigned int pretend_size; /* # Bytes we push and pretend caller did. */
|
unsigned int pretend_size; /* # Bytes we push and pretend caller did. */
|
unsigned int args_size; /* # Bytes that outgoing arguments take up. */
|
unsigned int args_size; /* # Bytes that outgoing arguments take up. */
|
unsigned int extra_size;
|
unsigned int extra_size;
|
unsigned int reg_size; /* # Bytes needed to store regs. */
|
unsigned int reg_size; /* # Bytes needed to store regs. */
|
unsigned int var_size; /* # Bytes that variables take up. */
|
unsigned int var_size; /* # Bytes that variables take up. */
|
unsigned int frame_size; /* # Bytes in current frame. */
|
unsigned int frame_size; /* # Bytes in current frame. */
|
unsigned int reg_mask; /* Mask of saved registers. */
|
unsigned int reg_mask; /* Mask of saved registers. */
|
unsigned int save_fp; /* Nonzero if frame pointer must be saved. */
|
unsigned int save_fp; /* Nonzero if frame pointer must be saved. */
|
unsigned int save_lr; /* Nonzero if return pointer must be saved. */
|
unsigned int save_lr; /* Nonzero if return pointer must be saved. */
|
int initialized; /* Nonzero if frame size already calculated. */
|
int initialized; /* Nonzero if frame size already calculated. */
|
};
|
};
|
|
|
extern struct mt_frame_info current_frame_info;
|
extern struct mt_frame_info current_frame_info;
|
|
|
/* If defined, this macro specifies a table of register pairs used to eliminate
|
/* If defined, this macro specifies a table of register pairs used to eliminate
|
unneeded registers that point into the stack frame. */
|
unneeded registers that point into the stack frame. */
|
#define ELIMINABLE_REGS \
|
#define ELIMINABLE_REGS \
|
{ \
|
{ \
|
{ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \
|
{ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \
|
{ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM}, \
|
{ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM}, \
|
{FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM} \
|
{FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM} \
|
}
|
}
|
|
|
/* A C expression that returns nonzero if the compiler is allowed to try to
|
/* A C expression that returns nonzero if the compiler is allowed to try to
|
replace register number FROM with register number TO. */
|
replace register number FROM with register number TO. */
|
#define CAN_ELIMINATE(FROM, TO) \
|
#define CAN_ELIMINATE(FROM, TO) \
|
((FROM) == ARG_POINTER_REGNUM && (TO) == STACK_POINTER_REGNUM \
|
((FROM) == ARG_POINTER_REGNUM && (TO) == STACK_POINTER_REGNUM \
|
? ! frame_pointer_needed \
|
? ! frame_pointer_needed \
|
: 1)
|
: 1)
|
|
|
/* This macro is similar to `INITIAL_FRAME_POINTER_OFFSET'. It
|
/* This macro is similar to `INITIAL_FRAME_POINTER_OFFSET'. It
|
specifies the initial difference between the specified pair of
|
specifies the initial difference between the specified pair of
|
registers. This macro must be defined if `ELIMINABLE_REGS' is
|
registers. This macro must be defined if `ELIMINABLE_REGS' is
|
defined. */
|
defined. */
|
#define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
|
#define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
|
(OFFSET) = mt_initial_elimination_offset (FROM, TO)
|
(OFFSET) = mt_initial_elimination_offset (FROM, TO)
|
|
|
/* If defined, the maximum amount of space required for outgoing
|
/* If defined, the maximum amount of space required for outgoing
|
arguments will be computed and placed into the variable
|
arguments will be computed and placed into the variable
|
`current_function_outgoing_args_size'. */
|
`current_function_outgoing_args_size'. */
|
#define ACCUMULATE_OUTGOING_ARGS 1
|
#define ACCUMULATE_OUTGOING_ARGS 1
|
|
|
/* Define this if it is the responsibility of the caller to
|
/* Define this if it is the responsibility of the caller to
|
allocate the area reserved for arguments passed in registers. */
|
allocate the area reserved for arguments passed in registers. */
|
#define OUTGOING_REG_PARM_STACK_SPACE
|
#define OUTGOING_REG_PARM_STACK_SPACE
|
|
|
/* The number of register assigned to holding function arguments. */
|
/* The number of register assigned to holding function arguments. */
|
#define MT_NUM_ARG_REGS 4
|
#define MT_NUM_ARG_REGS 4
|
|
|
/* Define this if it is the responsibility of the caller to allocate
|
/* Define this if it is the responsibility of the caller to allocate
|
the area reserved for arguments passed in registers. */
|
the area reserved for arguments passed in registers. */
|
#define REG_PARM_STACK_SPACE(FNDECL) (MT_NUM_ARG_REGS * UNITS_PER_WORD)
|
#define REG_PARM_STACK_SPACE(FNDECL) (MT_NUM_ARG_REGS * UNITS_PER_WORD)
|
|
|
/* Define this macro if `REG_PARM_STACK_SPACE' is defined, but the stack
|
/* Define this macro if `REG_PARM_STACK_SPACE' is defined, but the stack
|
parameters don't skip the area specified by it. */
|
parameters don't skip the area specified by it. */
|
#define STACK_PARMS_IN_REG_PARM_AREA
|
#define STACK_PARMS_IN_REG_PARM_AREA
|
|
|
/* A C expression that should indicate the number of bytes of its own
|
/* A C expression that should indicate the number of bytes of its own
|
arguments that a function pops on returning, or 0 if the function
|
arguments that a function pops on returning, or 0 if the function
|
pops no arguments and the caller must therefore pop them all after
|
pops no arguments and the caller must therefore pop them all after
|
the function returns. */
|
the function returns. */
|
#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACK_SIZE) 0
|
#define RETURN_POPS_ARGS(FUNDECL, FUNTYPE, STACK_SIZE) 0
|
|
|
#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
|
#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
|
mt_function_arg (& (CUM), (MODE), (TYPE), (NAMED), FALSE)
|
mt_function_arg (& (CUM), (MODE), (TYPE), (NAMED), FALSE)
|
|
|
#define CUMULATIVE_ARGS int
|
#define CUMULATIVE_ARGS int
|
|
|
#define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, FNDECL, N_NAMED_ARGS) \
|
#define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, FNDECL, N_NAMED_ARGS) \
|
mt_init_cumulative_args (& (CUM), FNTYPE, LIBNAME, FNDECL, FALSE)
|
mt_init_cumulative_args (& (CUM), FNTYPE, LIBNAME, FNDECL, FALSE)
|
|
|
#define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \
|
#define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \
|
mt_function_arg_advance (&CUM, MODE, TYPE, NAMED)
|
mt_function_arg_advance (&CUM, MODE, TYPE, NAMED)
|
|
|
#define FUNCTION_ARG_BOUNDARY(MODE, TYPE) \
|
#define FUNCTION_ARG_BOUNDARY(MODE, TYPE) \
|
mt_function_arg_boundary (MODE, TYPE)
|
mt_function_arg_boundary (MODE, TYPE)
|
|
|
#define FUNCTION_ARG_REGNO_P(REGNO) \
|
#define FUNCTION_ARG_REGNO_P(REGNO) \
|
((REGNO) >= FIRST_ARG_REGNUM && ((REGNO) <= LAST_ARG_REGNUM))
|
((REGNO) >= FIRST_ARG_REGNUM && ((REGNO) <= LAST_ARG_REGNUM))
|
|
|
#define RETURN_VALUE_REGNUM RETVAL_REGNUM
|
#define RETURN_VALUE_REGNUM RETVAL_REGNUM
|
|
|
#define FUNCTION_VALUE(VALTYPE, FUNC) \
|
#define FUNCTION_VALUE(VALTYPE, FUNC) \
|
mt_function_value (VALTYPE, TYPE_MODE(VALTYPE), FUNC)
|
mt_function_value (VALTYPE, TYPE_MODE(VALTYPE), FUNC)
|
|
|
#define LIBCALL_VALUE(MODE) \
|
#define LIBCALL_VALUE(MODE) \
|
mt_function_value (NULL_TREE, MODE, NULL_TREE)
|
mt_function_value (NULL_TREE, MODE, NULL_TREE)
|
|
|
#define FUNCTION_VALUE_REGNO_P(REGNO) ((REGNO) == RETURN_VALUE_REGNUM)
|
#define FUNCTION_VALUE_REGNO_P(REGNO) ((REGNO) == RETURN_VALUE_REGNUM)
|
|
|
/* A C expression which can inhibit the returning of certain function
|
/* A C expression which can inhibit the returning of certain function
|
values in registers, based on the type of value. */
|
values in registers, based on the type of value. */
|
#define RETURN_IN_MEMORY(TYPE) (int_size_in_bytes (TYPE) > UNITS_PER_WORD)
|
#define RETURN_IN_MEMORY(TYPE) (int_size_in_bytes (TYPE) > UNITS_PER_WORD)
|
|
|
/* Define this macro to be 1 if all structure and union return values must be
|
/* Define this macro to be 1 if all structure and union return values must be
|
in memory. */
|
in memory. */
|
#define DEFAULT_PCC_STRUCT_RETURN 0
|
#define DEFAULT_PCC_STRUCT_RETURN 0
|
|
|
/* Define this macro as a C expression that is nonzero if the return
|
/* Define this macro as a C expression that is nonzero if the return
|
instruction or the function epilogue ignores the value of the stack
|
instruction or the function epilogue ignores the value of the stack
|
pointer; in other words, if it is safe to delete an instruction to
|
pointer; in other words, if it is safe to delete an instruction to
|
adjust the stack pointer before a return from the function. */
|
adjust the stack pointer before a return from the function. */
|
#define EXIT_IGNORE_STACK 1
|
#define EXIT_IGNORE_STACK 1
|
|
|
#define EPILOGUE_USES(REGNO) mt_epilogue_uses(REGNO)
|
#define EPILOGUE_USES(REGNO) mt_epilogue_uses(REGNO)
|
|
|
/* Define this macro if the function epilogue contains delay slots to which
|
/* Define this macro if the function epilogue contains delay slots to which
|
instructions from the rest of the function can be "moved". */
|
instructions from the rest of the function can be "moved". */
|
#define DELAY_SLOTS_FOR_EPILOGUE 1
|
#define DELAY_SLOTS_FOR_EPILOGUE 1
|
|
|
/* A C expression that returns 1 if INSN can be placed in delay slot number N
|
/* A C expression that returns 1 if INSN can be placed in delay slot number N
|
of the epilogue. */
|
of the epilogue. */
|
#define ELIGIBLE_FOR_EPILOGUE_DELAY(INSN, N) 0
|
#define ELIGIBLE_FOR_EPILOGUE_DELAY(INSN, N) 0
|
|
|
#define FUNCTION_PROFILER(FILE, LABELNO) gcc_unreachable ()
|
#define FUNCTION_PROFILER(FILE, LABELNO) gcc_unreachable ()
|
|
|
/* Trampolines are not implemented. */
|
/* Trampolines are not implemented. */
|
#define TRAMPOLINE_SIZE 0
|
#define TRAMPOLINE_SIZE 0
|
|
|
#define INITIALIZE_TRAMPOLINE(ADDR, FNADDR, STATIC_CHAIN)
|
#define INITIALIZE_TRAMPOLINE(ADDR, FNADDR, STATIC_CHAIN)
|
|
|
/* ?? What is this -- aldyh ?? */
|
/* ?? What is this -- aldyh ?? */
|
#define UCMPSI3_LIBCALL "__ucmpsi3"
|
#define UCMPSI3_LIBCALL "__ucmpsi3"
|
|
|
/* Addressing Modes. */
|
/* Addressing Modes. */
|
|
|
/* A C expression that is 1 if the RTX X is a constant which is a valid
|
/* A C expression that is 1 if the RTX X is a constant which is a valid
|
address. */
|
address. */
|
#define CONSTANT_ADDRESS_P(X) CONSTANT_P (X)
|
#define CONSTANT_ADDRESS_P(X) CONSTANT_P (X)
|
|
|
/* A number, the maximum number of registers that can appear in a valid memory
|
/* A number, the maximum number of registers that can appear in a valid memory
|
address. Note that it is up to you to specify a value equal to the maximum
|
address. Note that it is up to you to specify a value equal to the maximum
|
number that `GO_IF_LEGITIMATE_ADDRESS' would ever accept. */
|
number that `GO_IF_LEGITIMATE_ADDRESS' would ever accept. */
|
#define MAX_REGS_PER_ADDRESS 1
|
#define MAX_REGS_PER_ADDRESS 1
|
|
|
#ifdef REG_OK_STRICT
|
#ifdef REG_OK_STRICT
|
#define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \
|
#define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \
|
{ \
|
{ \
|
if (mt_legitimate_address_p (MODE, X, 1)) \
|
if (mt_legitimate_address_p (MODE, X, 1)) \
|
goto ADDR; \
|
goto ADDR; \
|
}
|
}
|
#else
|
#else
|
#define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \
|
#define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \
|
{ \
|
{ \
|
if (mt_legitimate_address_p (MODE, X, 0)) \
|
if (mt_legitimate_address_p (MODE, X, 0)) \
|
goto ADDR; \
|
goto ADDR; \
|
}
|
}
|
#endif
|
#endif
|
|
|
#ifdef REG_OK_STRICT
|
#ifdef REG_OK_STRICT
|
#define REG_OK_FOR_BASE_P(X) mt_reg_ok_for_base_p (X, 1)
|
#define REG_OK_FOR_BASE_P(X) mt_reg_ok_for_base_p (X, 1)
|
#else
|
#else
|
#define REG_OK_FOR_BASE_P(X) mt_reg_ok_for_base_p (X, 0)
|
#define REG_OK_FOR_BASE_P(X) mt_reg_ok_for_base_p (X, 0)
|
#endif
|
#endif
|
|
|
#define REG_OK_FOR_INDEX_P(X) REG_OK_FOR_BASE_P (X)
|
#define REG_OK_FOR_INDEX_P(X) REG_OK_FOR_BASE_P (X)
|
|
|
#define LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN) {}
|
#define LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN) {}
|
|
|
#define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR, LABEL)
|
#define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR, LABEL)
|
|
|
#define LEGITIMATE_CONSTANT_P(X) 1
|
#define LEGITIMATE_CONSTANT_P(X) 1
|
|
|
/* A C expression for the cost of moving data of mode M between a register and
|
/* A C expression for the cost of moving data of mode M between a register and
|
memory. A value of 2 is the default; this cost is relative to those in
|
memory. A value of 2 is the default; this cost is relative to those in
|
`REGISTER_MOVE_COST'.
|
`REGISTER_MOVE_COST'.
|
|
|
If moving between registers and memory is more expensive than between two
|
If moving between registers and memory is more expensive than between two
|
registers, you should define this macro to express the relative cost. */
|
registers, you should define this macro to express the relative cost. */
|
#define MEMORY_MOVE_COST(M,C,I) 10
|
#define MEMORY_MOVE_COST(M,C,I) 10
|
|
|
/* Define this macro as a C expression which is nonzero if accessing less than
|
/* Define this macro as a C expression which is nonzero if accessing less than
|
a word of memory (i.e. a `char' or a `short') is no faster than accessing a
|
a word of memory (i.e. a `char' or a `short') is no faster than accessing a
|
word of memory. */
|
word of memory. */
|
#define SLOW_BYTE_ACCESS 1
|
#define SLOW_BYTE_ACCESS 1
|
|
|
#define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) 1
|
#define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) 1
|
|
|
#define TEXT_SECTION_ASM_OP ".text"
|
#define TEXT_SECTION_ASM_OP ".text"
|
|
|
#define DATA_SECTION_ASM_OP ".data"
|
#define DATA_SECTION_ASM_OP ".data"
|
|
|
#define BSS_SECTION_ASM_OP "\t.section\t.bss"
|
#define BSS_SECTION_ASM_OP "\t.section\t.bss"
|
|
|
/* A C string constant for text to be output before each `asm' statement or
|
/* A C string constant for text to be output before each `asm' statement or
|
group of consecutive ones. Normally this is `"#APP"', which is a comment
|
group of consecutive ones. Normally this is `"#APP"', which is a comment
|
that has no effect on most assemblers but tells the GNU assembler that it
|
that has no effect on most assemblers but tells the GNU assembler that it
|
must check the lines that follow for all valid assembler constructs. */
|
must check the lines that follow for all valid assembler constructs. */
|
#define ASM_APP_ON "#APP\n"
|
#define ASM_APP_ON "#APP\n"
|
|
|
/* A C string constant for text to be output after each `asm' statement or
|
/* A C string constant for text to be output after each `asm' statement or
|
group of consecutive ones. Normally this is `"#NO_APP"', which tells the
|
group of consecutive ones. Normally this is `"#NO_APP"', which tells the
|
GNU assembler to resume making the time-saving assumptions that are valid
|
GNU assembler to resume making the time-saving assumptions that are valid
|
for ordinary compiler output. */
|
for ordinary compiler output. */
|
#define ASM_APP_OFF "#NO_APP\n"
|
#define ASM_APP_OFF "#NO_APP\n"
|
|
|
/* This is how to output an assembler line defining a `char' constant. */
|
/* This is how to output an assembler line defining a `char' constant. */
|
#define ASM_OUTPUT_CHAR(FILE, VALUE) \
|
#define ASM_OUTPUT_CHAR(FILE, VALUE) \
|
do \
|
do \
|
{ \
|
{ \
|
fprintf (FILE, "\t.byte\t"); \
|
fprintf (FILE, "\t.byte\t"); \
|
output_addr_const (FILE, (VALUE)); \
|
output_addr_const (FILE, (VALUE)); \
|
fprintf (FILE, "\n"); \
|
fprintf (FILE, "\n"); \
|
} \
|
} \
|
while (0)
|
while (0)
|
|
|
/* This is how to output an assembler line defining a `short' constant. */
|
/* This is how to output an assembler line defining a `short' constant. */
|
#define ASM_OUTPUT_SHORT(FILE, VALUE) \
|
#define ASM_OUTPUT_SHORT(FILE, VALUE) \
|
do \
|
do \
|
{ \
|
{ \
|
fprintf (FILE, "\t.hword\t"); \
|
fprintf (FILE, "\t.hword\t"); \
|
output_addr_const (FILE, (VALUE)); \
|
output_addr_const (FILE, (VALUE)); \
|
fprintf (FILE, "\n"); \
|
fprintf (FILE, "\n"); \
|
} \
|
} \
|
while (0)
|
while (0)
|
|
|
/* This is how to output an assembler line defining an `int' constant.
|
/* This is how to output an assembler line defining an `int' constant.
|
We also handle symbol output here. */
|
We also handle symbol output here. */
|
#define ASM_OUTPUT_INT(FILE, VALUE) \
|
#define ASM_OUTPUT_INT(FILE, VALUE) \
|
do \
|
do \
|
{ \
|
{ \
|
fprintf (FILE, "\t.word\t"); \
|
fprintf (FILE, "\t.word\t"); \
|
output_addr_const (FILE, (VALUE)); \
|
output_addr_const (FILE, (VALUE)); \
|
fprintf (FILE, "\n"); \
|
fprintf (FILE, "\n"); \
|
} \
|
} \
|
while (0)
|
while (0)
|
|
|
/* A C statement to output to the stdio stream STREAM an assembler instruction
|
/* A C statement to output to the stdio stream STREAM an assembler instruction
|
to assemble a single byte containing the number VALUE.
|
to assemble a single byte containing the number VALUE.
|
|
|
This declaration must be present. */
|
This declaration must be present. */
|
#define ASM_OUTPUT_BYTE(STREAM, VALUE) \
|
#define ASM_OUTPUT_BYTE(STREAM, VALUE) \
|
fprintf (STREAM, "\t%s\t0x%x\n", ASM_BYTE_OP, (VALUE))
|
fprintf (STREAM, "\t%s\t0x%x\n", ASM_BYTE_OP, (VALUE))
|
|
|
/* Globalizing directive for a label. */
|
/* Globalizing directive for a label. */
|
#define GLOBAL_ASM_OP "\t.globl "
|
#define GLOBAL_ASM_OP "\t.globl "
|
|
|
#define REGISTER_NAMES \
|
#define REGISTER_NAMES \
|
{ "R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7", \
|
{ "R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7", \
|
"R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15", \
|
"R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15", \
|
"LOOP1", "LOOP2", "LOOP3", "LOOP4", "ap" }
|
"LOOP1", "LOOP2", "LOOP3", "LOOP4", "ap" }
|
|
|
/* If defined, a C initializer for an array of structures containing a name and
|
/* If defined, a C initializer for an array of structures containing a name and
|
a register number. This macro defines additional names for hard registers,
|
a register number. This macro defines additional names for hard registers,
|
thus allowing the `asm' option in declarations to refer to registers using
|
thus allowing the `asm' option in declarations to refer to registers using
|
alternate names. */
|
alternate names. */
|
#define ADDITIONAL_REGISTER_NAMES \
|
#define ADDITIONAL_REGISTER_NAMES \
|
{ { "FP", 12}, {"SP", 13}, {"RA", 14}, {"IRA", 15} }
|
{ { "FP", 12}, {"SP", 13}, {"RA", 14}, {"IRA", 15} }
|
|
|
/* Define this macro if you are using an unusual assembler that requires
|
/* Define this macro if you are using an unusual assembler that requires
|
different names for the machine instructions.
|
different names for the machine instructions.
|
|
|
The definition is a C statement or statements which output an assembler
|
The definition is a C statement or statements which output an assembler
|
instruction opcode to the stdio stream STREAM. The macro-operand PTR is a
|
instruction opcode to the stdio stream STREAM. The macro-operand PTR is a
|
variable of type `char *' which points to the opcode name in its "internal"
|
variable of type `char *' which points to the opcode name in its "internal"
|
form--the form that is written in the machine description. The definition
|
form--the form that is written in the machine description. The definition
|
should output the opcode name to STREAM, performing any translation you
|
should output the opcode name to STREAM, performing any translation you
|
desire, and increment the variable PTR to point at the end of the opcode so
|
desire, and increment the variable PTR to point at the end of the opcode so
|
that it will not be output twice. */
|
that it will not be output twice. */
|
#define ASM_OUTPUT_OPCODE(STREAM, PTR) \
|
#define ASM_OUTPUT_OPCODE(STREAM, PTR) \
|
(PTR) = mt_asm_output_opcode (STREAM, PTR)
|
(PTR) = mt_asm_output_opcode (STREAM, PTR)
|
|
|
#define FINAL_PRESCAN_INSN(INSN, OPVEC, NOPERANDS) \
|
#define FINAL_PRESCAN_INSN(INSN, OPVEC, NOPERANDS) \
|
mt_final_prescan_insn (INSN, OPVEC, NOPERANDS)
|
mt_final_prescan_insn (INSN, OPVEC, NOPERANDS)
|
|
|
#define PRINT_OPERAND(STREAM, X, CODE) mt_print_operand (STREAM, X, CODE)
|
#define PRINT_OPERAND(STREAM, X, CODE) mt_print_operand (STREAM, X, CODE)
|
|
|
/* A C expression which evaluates to true if CODE is a valid punctuation
|
/* A C expression which evaluates to true if CODE is a valid punctuation
|
character for use in the `PRINT_OPERAND' macro. */
|
character for use in the `PRINT_OPERAND' macro. */
|
/* #: Print nop for delay slot. */
|
/* #: Print nop for delay slot. */
|
#define PRINT_OPERAND_PUNCT_VALID_P(CODE) ((CODE) == '#')
|
#define PRINT_OPERAND_PUNCT_VALID_P(CODE) ((CODE) == '#')
|
|
|
#define PRINT_OPERAND_ADDRESS(STREAM, X) mt_print_operand_address (STREAM, X)
|
#define PRINT_OPERAND_ADDRESS(STREAM, X) mt_print_operand_address (STREAM, X)
|
|
|
/* If defined, C string expressions to be used for the `%R', `%L', `%U', and
|
/* If defined, C string expressions to be used for the `%R', `%L', `%U', and
|
`%I' options of `asm_fprintf' (see `final.c'). These are useful when a
|
`%I' options of `asm_fprintf' (see `final.c'). These are useful when a
|
single `md' file must support multiple assembler formats. In that case, the
|
single `md' file must support multiple assembler formats. In that case, the
|
various `tm.h' files can define these macros differently.
|
various `tm.h' files can define these macros differently.
|
|
|
USER_LABEL_PREFIX is defined in svr4.h. */
|
USER_LABEL_PREFIX is defined in svr4.h. */
|
#define REGISTER_PREFIX "%"
|
#define REGISTER_PREFIX "%"
|
#define LOCAL_LABEL_PREFIX "."
|
#define LOCAL_LABEL_PREFIX "."
|
#define USER_LABEL_PREFIX ""
|
#define USER_LABEL_PREFIX ""
|
#define IMMEDIATE_PREFIX ""
|
#define IMMEDIATE_PREFIX ""
|
|
|
/* This macro should be provided on machines where the addresses in a dispatch
|
/* This macro should be provided on machines where the addresses in a dispatch
|
table are relative to the table's own address.
|
table are relative to the table's own address.
|
|
|
The definition should be a C statement to output to the stdio stream STREAM
|
The definition should be a C statement to output to the stdio stream STREAM
|
an assembler pseudo-instruction to generate a difference between two labels.
|
an assembler pseudo-instruction to generate a difference between two labels.
|
VALUE and REL are the numbers of two internal labels. The definitions of
|
VALUE and REL are the numbers of two internal labels. The definitions of
|
these labels are output using `targetm.asm_out.internal_label', and they
|
these labels are output using `targetm.asm_out.internal_label', and they
|
must be printed in the same way here. */
|
must be printed in the same way here. */
|
#define ASM_OUTPUT_ADDR_DIFF_ELT(STREAM, BODY, VALUE, REL) \
|
#define ASM_OUTPUT_ADDR_DIFF_ELT(STREAM, BODY, VALUE, REL) \
|
fprintf (STREAM, "\t.word .L%d-.L%d\n", VALUE, REL)
|
fprintf (STREAM, "\t.word .L%d-.L%d\n", VALUE, REL)
|
|
|
/* This macro should be provided on machines where the addresses in a dispatch
|
/* This macro should be provided on machines where the addresses in a dispatch
|
table are absolute.
|
table are absolute.
|
|
|
The definition should be a C statement to output to the stdio stream STREAM
|
The definition should be a C statement to output to the stdio stream STREAM
|
an assembler pseudo-instruction to generate a reference to a label. VALUE
|
an assembler pseudo-instruction to generate a reference to a label. VALUE
|
is the number of an internal label whose definition is output using
|
is the number of an internal label whose definition is output using
|
`targetm.asm_out.internal_label'. */
|
`targetm.asm_out.internal_label'. */
|
#define ASM_OUTPUT_ADDR_VEC_ELT(STREAM, VALUE) \
|
#define ASM_OUTPUT_ADDR_VEC_ELT(STREAM, VALUE) \
|
fprintf (STREAM, "\t.word .L%d\n", VALUE)
|
fprintf (STREAM, "\t.word .L%d\n", VALUE)
|
|
|
#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (GPR_LINK)
|
#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (GPR_LINK)
|
|
|
#define EH_RETURN_DATA_REGNO(N) \
|
#define EH_RETURN_DATA_REGNO(N) \
|
((N) == 0 ? GPR_R7 : (N) == 1 ? GPR_R8 : INVALID_REGNUM)
|
((N) == 0 ? GPR_R7 : (N) == 1 ? GPR_R8 : INVALID_REGNUM)
|
|
|
#define EH_RETURN_STACKADJ_REGNO GPR_R11
|
#define EH_RETURN_STACKADJ_REGNO GPR_R11
|
#define EH_RETURN_STACKADJ_RTX \
|
#define EH_RETURN_STACKADJ_RTX \
|
gen_rtx_REG (SImode, EH_RETURN_STACKADJ_REGNO)
|
gen_rtx_REG (SImode, EH_RETURN_STACKADJ_REGNO)
|
#define EH_RETURN_HANDLER_REGNO GPR_R10
|
#define EH_RETURN_HANDLER_REGNO GPR_R10
|
#define EH_RETURN_HANDLER_RTX \
|
#define EH_RETURN_HANDLER_RTX \
|
gen_rtx_REG (SImode, EH_RETURN_HANDLER_REGNO)
|
gen_rtx_REG (SImode, EH_RETURN_HANDLER_REGNO)
|
|
|
#define ASM_OUTPUT_ALIGN(STREAM, POWER) \
|
#define ASM_OUTPUT_ALIGN(STREAM, POWER) \
|
fprintf ((STREAM), "\t.p2align %d\n", (POWER))
|
fprintf ((STREAM), "\t.p2align %d\n", (POWER))
|
|
|
#define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG
|
#define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG
|
|
|
#ifndef DWARF2_DEBUGGING_INFO
|
#ifndef DWARF2_DEBUGGING_INFO
|
#define DWARF2_DEBUGGING_INFO
|
#define DWARF2_DEBUGGING_INFO
|
#endif
|
#endif
|
|
|
/* Define this macro if GCC should produce dwarf version 2-style
|
/* Define this macro if GCC should produce dwarf version 2-style
|
line numbers. This usually requires extending the assembler to
|
line numbers. This usually requires extending the assembler to
|
support them, and #defining DWARF2_LINE_MIN_INSN_LENGTH in the
|
support them, and #defining DWARF2_LINE_MIN_INSN_LENGTH in the
|
assembler configuration header files. */
|
assembler configuration header files. */
|
#define DWARF2_ASM_LINE_DEBUG_INFO 1
|
#define DWARF2_ASM_LINE_DEBUG_INFO 1
|
|
|
/* An alias for a machine mode name. This is the machine mode that
|
/* An alias for a machine mode name. This is the machine mode that
|
elements of a jump-table should have. */
|
elements of a jump-table should have. */
|
#define CASE_VECTOR_MODE SImode
|
#define CASE_VECTOR_MODE SImode
|
|
|
/* Define this macro if operations between registers with integral
|
/* Define this macro if operations between registers with integral
|
mode smaller than a word are always performed on the entire
|
mode smaller than a word are always performed on the entire
|
register. Most RISC machines have this property and most CISC
|
register. Most RISC machines have this property and most CISC
|
machines do not. */
|
machines do not. */
|
#define WORD_REGISTER_OPERATIONS
|
#define WORD_REGISTER_OPERATIONS
|
|
|
/* The maximum number of bytes that a single instruction can move quickly from
|
/* The maximum number of bytes that a single instruction can move quickly from
|
memory to memory. */
|
memory to memory. */
|
#define MOVE_MAX 4
|
#define MOVE_MAX 4
|
|
|
/* A C expression which is nonzero if on this machine it is safe to "convert"
|
/* A C expression which is nonzero if on this machine it is safe to "convert"
|
an integer of INPREC bits to one of OUTPREC bits (where OUTPREC is smaller
|
an integer of INPREC bits to one of OUTPREC bits (where OUTPREC is smaller
|
than INPREC) by merely operating on it as if it had only OUTPREC bits.
|
than INPREC) by merely operating on it as if it had only OUTPREC bits.
|
|
|
On many machines, this expression can be 1.
|
On many machines, this expression can be 1.
|
|
|
When `TRULY_NOOP_TRUNCATION' returns 1 for a pair of sizes for modes for
|
When `TRULY_NOOP_TRUNCATION' returns 1 for a pair of sizes for modes for
|
which `MODES_TIEABLE_P' is 0, suboptimal code can result. If this is the
|
which `MODES_TIEABLE_P' is 0, suboptimal code can result. If this is the
|
case, making `TRULY_NOOP_TRUNCATION' return 0 in such cases may improve
|
case, making `TRULY_NOOP_TRUNCATION' return 0 in such cases may improve
|
things. */
|
things. */
|
#define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
|
#define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
|
|
|
#define Pmode SImode
|
#define Pmode SImode
|
|
|
/* An alias for the machine mode used for memory references to functions being
|
/* An alias for the machine mode used for memory references to functions being
|
called, in `call' RTL expressions. On most machines this should be
|
called, in `call' RTL expressions. On most machines this should be
|
`QImode'. */
|
`QImode'. */
|
#define FUNCTION_MODE QImode
|
#define FUNCTION_MODE QImode
|
|
|
#define HANDLE_SYSV_PRAGMA 1
|
#define HANDLE_SYSV_PRAGMA 1
|
|
|
/* Indicate how many instructions can be issued at the same time. */
|
/* Indicate how many instructions can be issued at the same time. */
|
#define ISSUE_RATE 1
|
#define ISSUE_RATE 1
|
|
|
/* Define the information needed to generate branch and scc insns. This is
|
/* Define the information needed to generate branch and scc insns. This is
|
stored from the compare operation. Note that we can't use "rtx" here
|
stored from the compare operation. Note that we can't use "rtx" here
|
since it hasn't been defined! */
|
since it hasn't been defined! */
|
|
|
extern struct rtx_def * mt_compare_op0;
|
extern struct rtx_def * mt_compare_op0;
|
extern struct rtx_def * mt_compare_op1;
|
extern struct rtx_def * mt_compare_op1;
|
|
|
|
|