/* Definitions of target machine for GNU compiler,
for ATMEL AVR at90s8515, ATmega103/103L, ATmega603/603L microcontrollers.
- Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+ Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
Contributed by Denis Chertykov (denisc@overta.ru)
This file is part of GNU CC.
/* Names to predefine in the preprocessor for this target machine. */
-#define CPP_PREDEFINES "-DAVR"
-/* Define this to be a string constant containing `-D' options to
- define the predefined macros that identify this machine and system.
- These macros will be predefined unless the `-ansi' option is
- specified.
-
- In addition, a parallel set of macros are predefined, whose names
- are made by appending `__' at the beginning and at the end. These
- `__' macros are permitted by the ANSI standard, so they are
- predefined regardless of whether `-ansi' is specified.
-
- For example, on the Sun, one can use the following value:
-
- "-Dmc68000 -Dsun -Dunix"
-
- The result is to define the macros `__mc68000__', `__sun__' and
- `__unix__' unconditionally, and the macros `mc68000', `sun' and
- `unix' provided `-ansi' is not specified. */
-
+#define TARGET_CPU_CPP_BUILTINS() \
+ do \
+ { \
+ builtin_define_std ("AVR"); \
+ if (avr_base_arch_macro) \
+ builtin_define (avr_base_arch_macro); \
+ if (avr_extra_arch_macro) \
+ builtin_define (avr_extra_arch_macro); \
+ if (avr_asm_only_p) \
+ builtin_define ("__AVR_ASM_ONLY__"); \
+ if (avr_enhanced_p) \
+ builtin_define ("__AVR_ENHANCED__"); \
+ if (avr_mega_p) \
+ builtin_define ("__AVR_MEGA__"); \
+ if (TARGET_NO_INTERRUPTS) \
+ builtin_define ("__NO_INTERRUPTS__"); \
+ } \
+ while (0)
/* This declaration should be present. */
extern int target_flags;
#define MASK_NO_INTERRUPTS 0x00020000
#define MASK_CALL_PROLOGUES 0x00040000
#define MASK_TINY_STACK 0x00080000
+#define MASK_SHORT_CALLS 0x00100000
#define TARGET_ORDER_1 (target_flags & MASK_ORDER_1)
#define TARGET_ORDER_2 (target_flags & MASK_ORDER_2)
-#define TARGET_INT8 (target_flags & MASK_INT8)
+#define TARGET_INT8 (target_flags & MASK_INT8)
#define TARGET_NO_INTERRUPTS (target_flags & MASK_NO_INTERRUPTS)
#define TARGET_INSN_SIZE_DUMP (target_flags & MASK_INSN_SIZE_DUMP)
#define TARGET_CALL_PROLOGUES (target_flags & MASK_CALL_PROLOGUES)
#define TARGET_TINY_STACK (target_flags & MASK_TINY_STACK)
#define TARGET_NO_TABLEJUMP (target_flags & MASK_NO_TABLEJUMP)
+#define TARGET_SHORT_CALLS (target_flags & MASK_SHORT_CALLS)
/* Dump each assembler insn's rtl into the output file.
This is for debugging the compiler itself. */
#define TARGET_RTL_DUMP (target_flags & MASK_RTL_DUMP)
-#define TARGET_ALL_DEBUG (target_flags & MASK_ALL_DEBUG)
-
-/* `TARGET_...'
- This series of macros is to allow compiler command arguments to
- enable or disable the use of optional features of the target
- machine. For example, one machine description serves both the
- 68000 and the 68020; a command argument tells the compiler whether
- it should use 68020-only instructions or not. This command
- argument works by means of a macro `TARGET_68020' that tests a bit
- in `target_flags'.
-
- Define a macro `TARGET_FEATURENAME' for each such option. Its
- definition should test a bit in `target_flags'; for example:
-
- #define TARGET_68020 (target_flags & 1)
-
- One place where these macros are used is in the
- condition-expressions of instruction patterns. Note how
- `TARGET_68020' appears frequently in the 68000 machine description
- file, `m68k.md'. Another place they are used is in the
- definitions of the other macros in the `MACHINE.h' file. */
-
-
+#define TARGET_ALL_DEBUG (target_flags & MASK_ALL_DEBUG)
#define TARGET_SWITCHES { \
{ "order1", MASK_ORDER_1, NULL }, \
N_("Change only the low 8 bits of the stack pointer") }, \
{ "no-tablejump", MASK_NO_TABLEJUMP, \
N_("Do not generate tablejump insns") }, \
+ { "short-calls", MASK_SHORT_CALLS, \
+ N_("Use rjmp/rcall (limited range) on >8K devices") }, \
{ "rtl", MASK_RTL_DUMP, NULL }, \
{ "size", MASK_INSN_SIZE_DUMP, \
N_("Output instruction sizes to the asm file") }, \
{ "deb", MASK_ALL_DEBUG, NULL }, \
{ "", 0, NULL } }
-/* This macro defines names of command options to set and clear bits
- in `target_flags'. Its definition is an initializer with a
- subgrouping for each command option.
-
- Each subgrouping contains a string constant, that defines the
- option name, and a number, which contains the bits to set in
- `target_flags'. A negative number says to clear bits instead; the
- negative of the number is which bits to clear. The actual option
- name is made by appending `-m' to the specified name.
-
- One of the subgroupings should have a null string. The number in
- this grouping is the default value for `target_flags'. Any target
- options act starting with that value.
-
- Here is an example which defines `-m68000' and `-m68020' with
- opposite meanings, and picks the latter as the default:
-
- #define TARGET_SWITCHES \
- { { "68020", 1}, \
- { "68000", -1}, \
- { "", 1}} */
extern const char *avr_init_stack;
extern const char *avr_mcu_name;
+
+extern const char *avr_base_arch_macro;
+extern const char *avr_extra_arch_macro;
extern int avr_mega_p;
extern int avr_enhanced_p;
+extern int avr_asm_only_p;
-#define AVR_MEGA (avr_mega_p)
+#define AVR_MEGA (avr_mega_p && !TARGET_SHORT_CALLS)
#define AVR_ENHANCED (avr_enhanced_p)
#define TARGET_OPTIONS { \
{ "init-stack=", &avr_init_stack, N_("Specify the initial stack address") }, \
{ "mcu=", &avr_mcu_name, N_("Specify the MCU name") } }
-/* This macro is similar to `TARGET_SWITCHES' but defines names of
- command options that have values. Its definition is an
- initializer with a subgrouping for each command option.
-
- Each subgrouping contains a string constant, that defines the
- fixed part of the option name, and the address of a variable. The
- variable, type `char *', is set to the variable part of the given
- option if the fixed part matches. The actual option name is made
- by appending `-m' to the specified name.
-
- Here is an example which defines `-mshort-data-NUMBER'. If the
- given option is `-mshort-data-512', the variable `m88k_short_data'
- will be set to the string `"512"'.
-
- extern char *m88k_short_data;
- #define TARGET_OPTIONS \
- { { "short-data-", &m88k_short_data } } */
#define TARGET_VERSION fprintf (stderr, " (GNU assembler syntax)");
/* This macro is a C statement to print on `stderr' a string
fprintf (stderr, " (68k, MIT syntax)");
#endif */
-#define OVERRIDE_OPTIONS avr_override_options()
+#define OVERRIDE_OPTIONS avr_override_options ()
/* `OVERRIDE_OPTIONS'
Sometimes certain combinations of command options do not make
sense on a particular target machine. You can define a macro
numbered. */
#define WORDS_BIG_ENDIAN 0
-/* number of bits in an addressable storage unit */
-#define BITS_PER_UNIT 8
-
-/* Width in bits of a "word", which is the contents of a machine register.
- Note that this is not necessarily the width of data type `int'; */
-#define BITS_PER_WORD 8
-
#ifdef IN_LIBGCC2
/* This is to get correct SI and DI modes in libgcc2.c (32 and 64 bits). */
#define UNITS_PER_WORD 4
of macro must be at least 64. */
-#define CHAR_TYPE_SIZE 8
-/* A C expression for the size in bits of the type `char' on the
- target machine. If you don't define this, the default is one
- quarter of a word. (If this would be less than one storage unit,
- it is rounded up to one unit.) */
-
#define FLOAT_TYPE_SIZE 32
/* A C expression for the size in bits of the type `float' on the
target machine. If you don't define this, the default is one word. */
/* A C expression for a string describing the name of the data type
to use for size values. The typedef name `size_t' is defined
using the contents of the string.
-
+
The string can contain more than one keyword. If so, separate
them with spaces, and write first any length keyword, then
`unsigned' if appropriate, and finally `int'. The string must
`init_decl_processing' in the file `c-decl.c'. You may not omit
`int' or change the order--that would cause the compiler to crash
on startup.
-
+
If you don't define this macro, the default is `"long unsigned
int"'. */
to use for the result of subtracting two pointers. The typedef
name `ptrdiff_t' is defined using the contents of the string. See
`SIZE_TYPE' above for more information.
-
+
If you don't define this macro, the default is `"long int"'. */
/* If defined, an initializer for a vector of integers, containing the
numbers of hard registers in the order in which GNU CC should
prefer to use them (from most preferred to least).
-
+
If this macro is not defined, registers are used lowest numbered
first (all else being equal).
-
+
One use of this macro is on machines where the highest numbered
registers must always be saved and the save-multiple-registers
instruction supports only sequences of consetionve registers. On
0x00000000}, /* POINTER_REGS, r26 - r31 */ \
{(3 << REG_X) | (3 << REG_Y) | (3 << REG_Z) | (3 << REG_W), \
0x00000000}, /* ADDW_REGS, r24 - r31 */ \
- {0x00ff0000,0x00000000}, /* SIMPLE_LD_REGS r16 - r23 */ \
+ {0x00ff0000,0x00000000}, /* SIMPLE_LD_REGS r16 - r23 */ \
{(3 << REG_X)|(3 << REG_Y)|(3 << REG_Z)|(3 << REG_W)|(0xff << 16), \
0x00000000}, /* LD_REGS, r16 - r31 */ \
- {0x0000ffff,0x00000000}, /* NO_LD_REGS r0 - r15 */ \
- {0xffffffffu,0x00000000}, /* GENERAL_REGS, r0 - r31 */ \
- {0xffffffffu,0x00000003} /* ALL_REGS */ \
+ {0x0000ffff,0x00000000}, /* NO_LD_REGS r0 - r15 */ \
+ {0xffffffff,0x00000000}, /* GENERAL_REGS, r0 - r31 */ \
+ {0xffffffff,0x00000003} /* ALL_REGS */ \
}
/* An initializer containing the contents of the register classes, as
integers which are bit masks. The Nth integer specifies the
machines allow copying all registers to and from memory, but
require a scratch register for stores to some memory locations
(e.g., those with symbolic address on the RT, and those with
- certain symbolic address on the Sparc when compiling PIC). In
+ certain symbolic address on the SPARC when compiling PIC). In
some cases, both an intermediate and a scratch register are
required.
class of registers. In that case, secondary reload registers are
not needed and would not be helpful. Instead, a stack location
must be used to perform the copy and the `movM' pattern should use
- memory as a intermediate storage. This case often occurs between
+ memory as an intermediate storage. This case often occurs between
floating-point and general registers. */
/* `SECONDARY_MEMORY_NEEDED (CLASS1, CLASS2, M)'
Certain machines have the property that some registers cannot be
copied to some other registers without using memory. Define this
- macro on those machines to be a C expression that is non-zero if
+ macro on those machines to be a C expression that is nonzero if
objects of mode M in registers of CLASS1 can only be copied to
registers of class CLASS2 by storing a register of CLASS1 into
memory and loading that memory location into a register of CLASS2.
classes that there would not be enough registers to use as spill
registers if this were done.
- Define `SMALL_REGISTER_CLASSES' to be an expression with a non-zero
- value on these machines. When this macro has a non-zero value, the
+ Define `SMALL_REGISTER_CLASSES' to be an expression with a nonzero
+ value on these machines. When this macro has a nonzero value, the
compiler allows registers explicitly used in the rtl to be used as
spill registers but avoids extending the lifetime of these
registers.
- It is always safe to define this macro with a non-zero value, but
+ It is always safe to define this macro with a nonzero value, but
if you unnecessarily define it, you will reduce the amount of
optimizations that can be performed in some cases. If you do not
- define this macro with a non-zero value when it is required, the
+ define this macro with a nonzero value when it is required, the
compiler will run out of spill registers and print a fatal error
message. For most machines, you should not define this macro at
all. */
|| (FROM) == FRAME_POINTER_REGNUM+1) \
&& ! FRAME_POINTER_REQUIRED \
))
-/* A C expression that returns non-zero if the compiler is allowed to
+/* A C expression that returns nonzero if the compiler is allowed to
try to replace register number FROM-REG with register number
TO-REG. This macro need only be defined if `ELIMINABLE_REGS' is
defined, and will usually be the constant 1, since most of the
FUNDECL is a C variable whose value is a tree node that describes
the function in question. Normally it is a node of type
`FUNCTION_DECL' that describes the declaration of the function.
- From this you can obtain the DECL_MACHINE_ATTRIBUTES of the
+ From this you can obtain the DECL_ATTRIBUTES of the
function.
FUNTYPE is a C variable whose value is a tree node that describes
argument popping will always be the responsibility of the calling
function.
- On the Vax, all functions always pop their arguments, so the
+ On the VAX, all functions always pop their arguments, so the
definition of this macro is STACK-SIZE. On the 68000, using the
standard calling convention, no functions pop their arguments, so
the value of the macro is always 0 in this case. But an
hard register in which to pass the argument, or zero to pass the
argument on the stack.
- For machines like the Vax and 68000, where normally all arguments
+ For machines like the VAX and 68000, where normally all arguments
are pushed, zero suffices as a definition.
The value of the expression can also be a `parallel' RTX. This is
You may use the macro `MUST_PASS_IN_STACK (MODE, TYPE)' in the
definition of this macro to determine if this argument is of a
type that must be passed in the stack. If `REG_PARM_STACK_SPACE'
- is not defined and `FUNCTION_ARG' returns non-zero for such an
+ is not defined and `FUNCTION_ARG' returns nonzero for such an
argument, the compiler will abort. If `REG_PARM_STACK_SPACE' is
defined, the argument will be computed in the stack and then
loaded into a register. */
is zero for a call to an explicitly named function, a library
function call, or when `INIT_CUMULATIVE_ARGS' is used to find
arguments for the function being compiled.
-
+
When processing a call to a compiler support library function,
LIBNAME identifies which one. It is a `symbol_ref' rtx which
contains the name of the function, as a string. LIBNAME is 0 when
MODE, TYPE and NAMED describe that argument. Once this is done,
the variable CUM is suitable for analyzing the *following*
argument with `FUNCTION_ARG', etc.
-
+
This macro need not do anything if the argument in question was
passed on the stack. The compiler knows how to track the amount
of stack space used for arguments without any special help. */
the frame pointer. A definition of 0 means that the address is
passed as an "invisible" first argument. */
-#define FUNCTION_PROLOGUE(FILE, SIZE) function_prologue (FILE, SIZE)
-/* A C compound statement that outputs the assembler code for entry
- to a function. The prologue is responsible for setting up the
- stack frame, initializing the frame pointer register, saving
- registers that must be saved, and allocating SIZE additional bytes
- of storage for the local variables. SIZE is an integer. FILE is
- a stdio stream to which the assembler code should be output.
-
- The label for the beginning of the function need not be output by
- this macro. That has already been done when the macro is run.
-
- To determine which registers to save, the macro can refer to the
- array `regs_ever_live': element R is nonzero if hard register R is
- used anywhere within the function. This implies the function
- prologue should save register R, provided it is not one of the
- call-used registers. (`FUNCTION_EPILOGUE' must likewise use
- `regs_ever_live'.)
-
- On machines that have "register windows", the function entry code
- does not save on the stack the registers that are in the windows,
- even if they are supposed to be preserved by function calls;
- instead it takes appropriate steps to "push" the register stack,
- if any non-call-used registers are used in the function.
-
- On machines where functions may or may not have frame-pointers, the
- function entry code must vary accordingly; it must set up the frame
- pointer if one is wanted, and not otherwise. To determine whether
- a frame pointer is in wanted, the macro can refer to the variable
- `frame_pointer_needed'. The variable's value will be 1 at run
- time in a function that needs a frame pointer. *Note
- Elimination::.
-
- The function entry code is responsible for allocating any stack
- space required for the function. This stack space consists of the
- regions listed below. In most cases, these regions are allocated
- in the order listed, with the last listed region closest to the
- top of the stack (the lowest address if `STACK_GROWS_DOWNWARD' is
- defined, and the highest address if it is not defined). You can
- use a different order for a machine if doing so is more convenient
- or required for compatibility reasons. Except in cases where
- required by standard or by a debugger, there is no reason why the
- stack layout used by GCC need agree with that used by other
- compilers for a machine.
-
- * A region of `current_function_pretend_args_size' bytes of
- uninitialized space just underneath the first argument
- arriving on the stack. (This may not be at the very start of
- the allocated stack region if the calling sequence has pushed
- anything else since pushing the stack arguments. But
- usually, on such machines, nothing else has been pushed yet,
- because the function prologue itself does all the pushing.)
- This region is used on machines where an argument may be
- passed partly in registers and partly in memory, and, in some
- cases to support the features in `varargs.h' and `stdargs.h'.
-
- * An area of memory used to save certain registers used by the
- function. The size of this area, which may also include
- space for such things as the return address and pointers to
- previous stack frames, is machine-specific and usually
- depends on which registers have been used in the function.
- Machines with register windows often do not require a save
- area.
-
- * A region of at least SIZE bytes, possibly rounded up to an
- allocation boundary, to contain the local variables of the
- function. On some machines, this region and the save area
- may occur in the opposite order, with the save area closer to
- the top of the stack.
-
- * Optionally, when `ACCUMULATE_OUTGOING_ARGS' is defined, a
- region of `current_function_outgoing_args_size' bytes to be
- used for outgoing argument lists of the function. *Note
- Stack Arguments::.
-
- Normally, it is necessary for the macros `FUNCTION_PROLOGUE' and
- `FUNCTION_EPILOGE' to treat leaf functions specially. The C
- variable `leaf_function' is nonzero for such a function. */
-
#define EPILOGUE_USES(REGNO) 0
/* Define this macro as a C expression that is nonzero for registers
are used by the epilogue or the `return' pattern. The stack and
frame pointer registers are already be assumed to be used as
needed. */
-#define FUNCTION_EPILOGUE(FILE, SIZE) function_epilogue (FILE, SIZE)
-/* A C compound statement that outputs the assembler code for exit
- from a function. The epilogue is responsible for restoring the
- saved registers and stack pointer to their values when the
- function was called, and returning control to the caller. This
- macro takes the same arguments as the macro `FUNCTION_PROLOGUE',
- and the registers to restore are determined from `regs_ever_live'
- and `CALL_USED_REGISTERS' in the same way.
-
- On some machines, there is a single instruction that does all the
- work of returning from the function. On these machines, give that
- instruction the name `return' and do not define the macro
- `FUNCTION_EPILOGUE' at all.
-
- Do not define a pattern named `return' if you want the
- `FUNCTION_EPILOGUE' to be used. If you want the target switches
- to control whether return instructions or epilogues are used,
- define a `return' pattern with a validity condition that tests the
- target switches appropriately. If the `return' pattern's validity
- condition is false, epilogues will be used.
-
- On machines where functions may or may not have frame-pointers, the
- function exit code must vary accordingly. Sometimes the code for
- these two cases is completely different. To determine whether a
- frame pointer is wanted, the macro can refer to the variable
- `frame_pointer_needed'. The variable's value will be 1 when
- compiling a function that needs a frame pointer.
-
- Normally, `FUNCTION_PROLOGUE' and `FUNCTION_EPILOGUE' must treat
- leaf functions specially. The C variable `leaf_function' is
- nonzero for such a function. *Note Leaf Functions::.
-
- On some machines, some functions pop their arguments on exit while
- others leave that for the caller to do. For example, the 68020
- when given `-mrtd' pops arguments in functions that take a fixed
- number of arguments.
-
- Your definition of the macro `RETURN_POPS_ARGS' decides which
- functions pop their own arguments. `FUNCTION_EPILOGUE' needs to
- know what was decided. The variable that is called
- `current_function_pops_args' is the number of bytes of its
- arguments that a function should pop. *Note Scalar Return::. */
-
#define STRICT_ARGUMENT_NAMING 1
/* Define this macro if the location where a function argument is
passed depends on whether or not it is a named argument.
addressing. */
#define HAVE_PRE_DECREMENT 1
-/* #define HAVE_PRE_INCREMENT
- #define HAVE_POST_DECREMENT */
/* Similar for other kinds of addressing. */
#define CONSTANT_ADDRESS_P(X) CONSTANT_P (X)
#endif
/* A C compound statement with a conditional `goto LABEL;' executed
if X (an RTX) is a legitimate memory address on the target machine
- for a memory operand of mode MODE.
-
- It usually pays to define several simpler macros to serve as
- subroutines for this one. Otherwise it may be too complicated to
- understand.
-
- This macro must exist in two variants: a strict variant and a
- non-strict one. The strict variant is used in the reload pass. It
- must be defined so that any pseudo-register that has not been
- allocated a hard register is considered a memory reference. In
- contexts where some kind of register is required, a pseudo-register
- with no hard register must be rejected.
-
- The non-strict variant is used in other passes. It must be
- defined to accept all pseudo-registers in every context where some
- kind of register is required.
-
- Compiler source files that want to use the strict variant of this
- macro define the macro `REG_OK_STRICT'. You should use an `#ifdef
- REG_OK_STRICT' conditional to define the strict variant in that
- case and the non-strict variant otherwise.
-
- Subroutines to check for acceptable registers for various purposes
- (one for base registers, one for index registers, and so on) are
- typically among the subroutines used to define
- `GO_IF_LEGITIMATE_ADDRESS'. Then only these subroutine macros
- need have two variants; the higher levels of macros may be the
- same whether strict or not.
-
- Normally, constant addresses which are the sum of a `symbol_ref'
- and an integer are stored inside a `const' RTX to mark them as
- constant. Therefore, there is no need to recognize such sums
- specifically as legitimate addresses. Normally you would simply
- recognize any `const' as legitimate.
-
- Usually `PRINT_OPERAND_ADDRESS' is not prepared to handle constant
- sums that are not marked with `const'. It assumes that a naked
- `plus' indicates indexing. If so, then you *must* reject such
- naked constant sums as illegitimate addresses, so that none of
- them will be given to `PRINT_OPERAND_ADDRESS'.
-
- On some machines, whether a symbolic address is legitimate depends
- on the section that the address refers to. On these machines,
- define the macro `ENCODE_SECTION_INFO' to store the information
- into the `symbol_ref', and then check for it here. When you see a
- `const', you will have to look inside it to find the `symbol_ref'
- in order to determine the section. *Note Assembler Format::.
-
- The best way to modify the name string is by adding text to the
- beginning, with suitable punctuation to prevent any ambiguity.
- Allocate the new name in `saveable_obstack'. You will have to
- modify `ASM_OUTPUT_LABELREF' to remove and decode the added text
- and output the name accordingly, and define `STRIP_NAME_ENCODING'
- to access the original name string.
-
- You can check the information stored here into the `symbol_ref' in
- the definitions of the macros `GO_IF_LEGITIMATE_ADDRESS' and
- `PRINT_OPERAND_ADDRESS'. */
+ for a memory operand of mode MODE. */
/* `REG_OK_FOR_BASE_P (X)'
A C expression that is nonzero if X (assumed to be a `reg' RTX) is
{ \
int regno = REGNO (XEXP (X, 0)); \
rtx mem = make_memloc (X, regno); \
- push_reload (XEXP (mem,0), NULL_PTR, &XEXP (mem,0), NULL_PTR, \
+ push_reload (XEXP (mem,0), NULL, &XEXP (mem,0), NULL, \
POINTER_REGS, Pmode, VOIDmode, 0, 0, \
1, ADDR_TYPE (TYPE)); \
- push_reload (mem, NULL_RTX, &XEXP (X, 0), NULL_PTR, \
+ push_reload (mem, NULL_RTX, &XEXP (X, 0), NULL, \
BASE_POINTER_REGS, GET_MODE (X), VOIDmode, 0, 0, \
OPNUM, TYPE); \
goto WIN; \
} \
- push_reload (XEXP (X, 0), NULL_RTX, &XEXP (X, 0), NULL_PTR, \
+ push_reload (XEXP (X, 0), NULL_RTX, &XEXP (X, 0), NULL, \
BASE_POINTER_REGS, GET_MODE (X), VOIDmode, 0, 0, \
OPNUM, TYPE); \
goto WIN; \
} \
else if (! (frame_pointer_needed && XEXP (X,0) == frame_pointer_rtx)) \
{ \
- push_reload (X, NULL_RTX, &X, NULL_PTR, \
+ push_reload (X, NULL_RTX, &X, NULL, \
POINTER_REGS, GET_MODE (X), VOIDmode, 0, 0, \
OPNUM, TYPE); \
goto WIN; \
top level, you'll need to replace first the top leve It is not
necessary for this macro to come up with a legitimate address;
but often a machine-dependent strategy can generate better code. */
-
+
#define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL) \
if (GET_CODE (ADDR) == POST_INC || GET_CODE (ADDR) == PRE_DEC) \
goto LABEL
{ \
int cst = default_rtx_costs (x, code, outer_code); \
if (cst>0) \
- return cst; \
+ return cst; \
else if (cst<0) \
- total += -cst; \
+ total += -cst; \
break; \
}
subsequent accesses occur to other fields in the same word of the
structure, but to different bytes.
- `SLOW_ZERO_EXTEND'
- Define this macro if zero-extension (of a `char' or `short' to an
- `int') can be done faster if the destination is a register that is
- known to be zero.
-
- If you define this macro, you must have instruction patterns that
- recognize RTL structures like this:
-
- (set (strict_low_part (subreg:QI (reg:SI ...) 0)) ...)
-
- and likewise for `HImode'.
-
`SLOW_UNALIGNED_ACCESS'
Define this macro to be the value 1 if unaligned accesses have a
cost many times greater than aligned accesses, for example if they
are emulated in a trap handler.
- When this macro is non-zero, the compiler will act as if
- `STRICT_ALIGNMENT' were non-zero when generating code for block
+ When this macro is nonzero, the compiler will act as if
+ `STRICT_ALIGNMENT' were nonzero when generating code for block
moves. This can cause significantly more instructions to be
- produced. Therefore, do not set this macro non-zero if unaligned
+ produced. Therefore, do not set this macro nonzero if unaligned
accesses only add a cycle or two to the time for a memory access.
If the value of this macro is always zero, it need not be defined.
#define NO_RECURSIVE_FUNCTION_CSE
/* Define this macro if it is as good or better for a function to call
itself with an explicit address than to call an address kept in a
- register.
-
- `ADJUST_COST (INSN, LINK, DEP_INSN, COST)'
- A C statement (sans semicolon) to update the integer variable COST
- based on the relationship between INSN that is dependent on
- DEP_INSN through the dependence LINK. The default is to make no
- adjustment to COST. This can be used for example to specify to
- the scheduler that an output- or anti-dependence does not incur
- the same cost as a data-dependence.
-
- `ADJUST_PRIORITY (INSN)'
- A C statement (sans semicolon) to update the integer scheduling
- priority `INSN_PRIORITY(INSN)'. Reduce the priority to execute
- the INSN earlier, increase the priority to execute INSN later.
- Do not define this macro if you do not need to adjust the
- scheduling priorities of insns. */
-
+ register. */
#define TEXT_SECTION_ASM_OP "\t.text"
/* A C expression whose value is a string containing the assembler
operation to identify the following data as writable initialized
data. Normally `"\t.data"' is right. */
+#define BSS_SECTION_ASM_OP "\t.section .bss"
+/* If defined, a C expression whose value is a string, including
+ spacing, containing the assembler operation to identify the
+ following data as uninitialized global data. If not defined, and
+ neither `ASM_OUTPUT_BSS' nor `ASM_OUTPUT_ALIGNED_BSS' are defined,
+ uninitialized global data will be output in the data section if
+ `-fno-common' is passed, otherwise `ASM_OUTPUT_COMMON' will be
+ used. */
+
+/* Define the pseudo-ops used to switch to the .ctors and .dtors sections.
+ There are no shared libraries on this target, and these sections are
+ placed in the read-only program memory, so they are not writable. */
+
+#undef CTORS_SECTION_ASM_OP
+#define CTORS_SECTION_ASM_OP "\t.section .ctors,\"a\",@progbits"
+
+#undef DTORS_SECTION_ASM_OP
+#define DTORS_SECTION_ASM_OP "\t.section .dtors,\"a\",@progbits"
+
+#define TARGET_ASM_CONSTRUCTOR avr_asm_out_ctor
+/* If defined, a function that outputs assembler code to arrange to
+ call the function referenced by SYMBOL at initialization time. */
+
+#define TARGET_ASM_DESTRUCTOR avr_asm_out_dtor
+/* This is like `TARGET_ASM_CONSTRUCTOR' but used for termination
+ functions rather than initialization functions. */
+
#define EXTRA_SECTIONS in_progmem
/* A list of names for sections other than the standard two, which are
`in_text' and `in_data'. You need not define this macro on a
#define EXTRA_SECTION_FUNCTIONS \
\
void \
-progmem_section (void) \
+progmem_section () \
{ \
if (in_section != in_progmem) \
{ \
fprintf (asm_out_file, \
"\t.section .progmem.gcc_sw_table, \"%s\", @progbits\n", \
- AVR_MEGA ? "a" : "ax"); \
+ AVR_MEGA ? "a" : "ax"); \
/* Should already be aligned, this is just to be safe if it isn't. */ \
fprintf (asm_out_file, "\t.p2align 1\n"); \
in_section = in_progmem; \
If these items should be placed in the text section, this macro
should not be defined. */
-/* `SELECT_SECTION (EXP, RELOC)'
- A C statement or statements to switch to the appropriate section
- for output of EXP. You can assume that EXP is either a `VAR_DECL'
- node or a constant of some sort. RELOC indicates whether the
- initial value of EXP requires link-time relocations. Select the
- section by calling `text_section' or one of the alternatives for
- other sections.
-
- Do not define this macro if you put all read-only variables and
- constants in the read-only data section (usually the text section). */
-
-/* `SELECT_RTX_SECTION (MODE, RTX)'
- A C statement or statements to switch to the appropriate section
- for output of RTX in mode MODE. You can assume that RTX is some
- kind of constant in RTL. The argument MODE is redundant except in
- the case of a `const_int' rtx. Select the section by calling
- `text_section' or one of the alternatives for other sections.
-
- Do not define this macro if you put all constants in the read-only
- data section. */
-
#define JUMP_TABLES_IN_TEXT_SECTION 0
/* Define this macro if jump tables (for `tablejump' insns) should be
output in the text section, along with the assembler instructions.
This macro is irrelevant if there is no separate readonly data
section. */
-#define ENCODE_SECTION_INFO(DECL) encode_section_info(DECL)
-/* Define this macro if references to a symbol must be treated
- differently depending on something about the variable or function
- named by the symbol (such as what section it is in).
-
- The macro definition, if any, is executed immediately after the
- rtl for DECL has been created and stored in `DECL_RTL (DECL)'.
- The value of the rtl will be a `mem' whose address is a
- `symbol_ref'.
-
- The usual thing for this macro to do is to record a flag in the
- `symbol_ref' (such as `SYMBOL_REF_FLAG') or to store a modified
- name string in the `symbol_ref' (if one bit is not enough
- information). */
-
-#define STRIP_NAME_ENCODING(VAR,SYMBOL_NAME) \
- (VAR) = (SYMBOL_NAME) + ((SYMBOL_NAME)[0] == '*' || (SYMBOL_NAME)[0] == '@');
-/* `STRIP_NAME_ENCODING (VAR, SYM_NAME)'
- Decode SYM_NAME and store the real name part in VAR, sans the
- characters that encode section info. Define this macro if
- `ENCODE_SECTION_INFO' alters the symbol's name string. */
-/* `UNIQUE_SECTION_P (DECL)'
- A C expression which evaluates to true if DECL should be placed
- into a unique section for some target-specific reason. If you do
- not define this macro, the default is `0'. Note that the flag
- `-ffunction-sections' will also cause functions to be placed into
- unique sections. */
-
-#define UNIQUE_SECTION(DECL, RELOC) unique_section (DECL, RELOC)
-/* `UNIQUE_SECTION (DECL, RELOC)'
- A C statement to build up a unique section name, expressed as a
- STRING_CST node, and assign it to `DECL_SECTION_NAME (DECL)'.
- RELOC indicates whether the initial value of EXP requires
- link-time relocations. If you do not define this macro, GNU CC
- will use the symbol name prefixed by `.' as the section name. */
-
-
#define ASM_FILE_START(STREAM) asm_file_start (STREAM)
/* A C expression which outputs to the stdio stream STREAM some
appropriate text to go at the start of an assembler file.
This macro need not be defined if the standard form of debugging
information for the debugger in use is appropriate. */
-#define ASM_OUTPUT_SECTION_NAME(FILE, DECL, NAME, RELOC) \
- asm_output_section_name(FILE, DECL, NAME, RELOC)
-
-/* `ASM_OUTPUT_SECTION_NAME (STREAM, DECL, NAME, RELOC)'
- A C statement to output something to the assembler file to switch
- to section NAME for object DECL which is either a `FUNCTION_DECL',
- a `VAR_DECL' or `NULL_TREE'. RELOC indicates whether the initial
- value of EXP requires link-time relocations. Some target formats
- do not support arbitrary sections. Do not define this macro in
- such cases.
-
- At present this macro is only used to support section attributes.
- When this macro is undefined, section attributes are disabled. */
+/* Switch into a generic section. */
+#define TARGET_ASM_NAMED_SECTION default_elf_asm_named_section
#define OBJC_PROLOGUE {}
/* A C statement to output any assembler statements which are
- required to precede any Objective C object definitions or message
+ required to precede any Objective-C object definitions or message
sending. The statement is executed only when compiling an
- Objective C program. */
-
-
-
-#define ASM_OUTPUT_DOUBLE(STREAM, VALUE) fprintf (STREAM, "no double float %.20e\n", VALUE)
-#define ASM_OUTPUT_FLOAT(STREAM, VALUE) asm_output_float (STREAM, VALUE)
-/* `ASM_OUTPUT_LONG_DOUBLE (STREAM, VALUE)'
- `ASM_OUTPUT_THREE_QUARTER_FLOAT (STREAM, VALUE)'
- `ASM_OUTPUT_SHORT_FLOAT (STREAM, VALUE)'
- `ASM_OUTPUT_BYTE_FLOAT (STREAM, VALUE)'
- A C statement to output to the stdio stream STREAM an assembler
- instruction to assemble a floating-point constant of `TFmode',
- `DFmode', `SFmode', `TQFmode', `HFmode', or `QFmode',
- respectively, whose value is VALUE. VALUE will be a C expression
- of type `REAL_VALUE_TYPE'. Macros such as
- `REAL_VALUE_TO_TARGET_DOUBLE' are useful for writing these
- definitions. */
-
-
-#define ASM_OUTPUT_INT(FILE, VALUE) \
- ( fprintf (FILE, "\t.long "), \
- output_addr_const (FILE, (VALUE)), \
- fputs ("\n", FILE))
-
- /* Likewise for `short' and `char' constants. */
-
-#define ASM_OUTPUT_SHORT(FILE,VALUE) asm_output_short(FILE,VALUE)
-#define ASM_OUTPUT_CHAR(FILE,VALUE) asm_output_char(FILE,VALUE)
-
-/* `ASM_OUTPUT_QUADRUPLE_INT (STREAM, EXP)'
- A C statement to output to the stdio stream STREAM an assembler
- instruction to assemble an integer of 16, 8, 4, 2 or 1 bytes,
- respectively, whose value is VALUE. The argument EXP will be an
- RTL expression which represents a constant value. Use
- `output_addr_const (STREAM, EXP)' to output this value as an
- assembler expression.
+ Objective-C program. */
- For sizes larger than `UNITS_PER_WORD', if the action of a macro
- would be identical to repeatedly calling the macro corresponding to
- a size of `UNITS_PER_WORD', once for each word, you need not define
- the macro. */
-
-
-#define ASM_OUTPUT_BYTE(FILE,VALUE) asm_output_byte (FILE,VALUE)
-/* A C statement to output to the stdio stream STREAM an assembler
- instruction to assemble a single byte containing the number VALUE. */
-
-#define ASM_BYTE_OP "\t.byte "
-/* A C string constant giving the pseudo-op to use for a sequence of
- single-byte constants. If this macro is not defined, the default
- is `"\t.byte\t"'. */
#define ASM_OUTPUT_ASCII(FILE, P, SIZE) gas_output_ascii (FILE,P,SIZE)
/* `ASM_OUTPUT_ASCII (STREAM, PTR, LEN)'
If you do not define this macro, the default is that only the
character `;' is treated as a logical line separator. */
-#define ASM_OPEN_PAREN "("
-#define ASM_CLOSE_PAREN ")"
-/* These macros are defined as C string constant, describing the
- syntax in the assembler for grouping arithmetic expressions. The
- following definitions are correct for most assemblers:
-
- #define ASM_OPEN_PAREN "("
- #define ASM_CLOSE_PAREN ")"
-
- These macros are provided by `real.h' for writing the definitions of
+/* These macros are provided by `real.h' for writing the definitions of
`ASM_OUTPUT_DOUBLE' and the like: */
#define ASM_OUTPUT_COMMON(STREAM, NAME, SIZE, ROUNDED) \
This macro controls how the assembler definitions of uninitialized
common global variables are output. */
+#define ASM_OUTPUT_BSS(FILE, DECL, NAME, SIZE, ROUNDED) \
+ asm_output_bss ((FILE), (DECL), (NAME), (SIZE), (ROUNDED))
+/* A C statement (sans semicolon) to output to the stdio stream
+ STREAM the assembler definition of uninitialized global DECL named
+ NAME whose size is SIZE bytes. The variable ROUNDED is the size
+ rounded up to whatever alignment the caller wants. */
+
#define ASM_OUTPUT_LOCAL(STREAM, NAME, SIZE, ROUNDED) \
do { \
fputs ("\t.lcomm ", (STREAM)); \
This macro controls how the assembler definitions of uninitialized
static variables are output. */
-#define ASM_OUTPUT_LABEL(STREAM, NAME) \
-{ \
- assemble_name (STREAM, NAME); \
- fprintf (STREAM, ":\n"); \
-}
-/* A C statement (sans semicolon) to output to the stdio stream
- STREAM the assembler definition of a label named NAME. Use the
- expression `assemble_name (STREAM, NAME)' to output the name
- itself; before and after that, output the additional assembler
- syntax for defining the name, and a newline. */
-
#undef TYPE_ASM_OP
#undef SIZE_ASM_OP
#undef WEAK_ASM_OP
is just a default. You may need to override it in your machine-
specific tm.h file (depending upon the particulars of your assembler). */
-
-#define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL) \
-do { \
- fprintf (FILE, "%s", TYPE_ASM_OP); \
- assemble_name (FILE, NAME); \
- putc (',', FILE); \
- fprintf (FILE, TYPE_OPERAND_FMT, "function"); \
- putc ('\n', FILE); \
- ASM_OUTPUT_LABEL (FILE, NAME); \
+#define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL) \
+do { \
+ ASM_OUTPUT_TYPE_DIRECTIVE (FILE, NAME, "function"); \
+ ASM_OUTPUT_LABEL (FILE, NAME); \
} while (0)
+
/* A C statement (sans semicolon) to output to the stdio stream
STREAM any text necessary for declaring the name NAME of a
function which is being defined. This macro is responsible for
#define ASM_DECLARE_FUNCTION_SIZE(FILE, FNAME, DECL) \
do { \
if (!flag_inhibit_size_directive) \
- { \
- char label[256]; \
- static int labelno; \
- labelno++; \
- ASM_GENERATE_INTERNAL_LABEL (label, "Lfe", labelno); \
- ASM_OUTPUT_INTERNAL_LABEL (FILE, "Lfe", labelno); \
- fprintf (FILE, "%s", SIZE_ASM_OP); \
- assemble_name (FILE, (FNAME)); \
- fprintf (FILE, ","); \
- assemble_name (FILE, label); \
- fprintf (FILE, "-"); \
- assemble_name (FILE, (FNAME)); \
- putc ('\n', FILE); \
- } \
+ ASM_OUTPUT_MEASURED_SIZE (FILE, FNAME); \
} while (0)
/* A C statement (sans semicolon) to output to the stdio stream
STREAM any text necessary for declaring the size of a function
If this macro is not defined, then the function size is not
defined. */
-#define ASM_DECLARE_OBJECT_NAME(FILE, NAME, DECL) \
-do { \
- fprintf (FILE, "%s", TYPE_ASM_OP); \
- assemble_name (FILE, NAME); \
- putc (',', FILE); \
- fprintf (FILE, TYPE_OPERAND_FMT, "object"); \
- putc ('\n', FILE); \
- size_directive_output = 0; \
- if (!flag_inhibit_size_directive && DECL_SIZE (DECL)) \
- { \
- size_directive_output = 1; \
- fprintf (FILE, "%s", SIZE_ASM_OP); \
- assemble_name (FILE, NAME); \
- fprintf (FILE, ",%d\n", int_size_in_bytes (TREE_TYPE (DECL))); \
- } \
- ASM_OUTPUT_LABEL(FILE, NAME); \
+#define ASM_DECLARE_OBJECT_NAME(FILE, NAME, DECL) \
+do { \
+ ASM_OUTPUT_TYPE_DIRECTIVE (FILE, NAME, "object"); \
+ size_directive_output = 0; \
+ if (!flag_inhibit_size_directive && DECL_SIZE (DECL)) \
+ { \
+ size_directive_output = 1; \
+ ASM_OUTPUT_SIZE_DIRECTIVE (FILE, NAME, \
+ int_size_in_bytes (TREE_TYPE (DECL))); \
+ } \
+ ASM_OUTPUT_LABEL(FILE, NAME); \
} while (0)
/* A C statement (sans semicolon) to output to the stdio stream
STREAM any text necessary for declaring the name NAME of an
If this macro is not defined, then the variable name is defined in
the usual manner as a label (by means of `ASM_OUTPUT_LABEL'). */
+#undef ASM_FINISH_DECLARE_OBJECT
#define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP_LEVEL, AT_END) \
do { \
const char *name = XSTR (XEXP (DECL_RTL (DECL), 0), 0); \
+ HOST_WIDE_INT size; \
if (!flag_inhibit_size_directive && DECL_SIZE (DECL) \
&& ! AT_END && TOP_LEVEL \
&& DECL_INITIAL (DECL) == error_mark_node \
&& !size_directive_output) \
{ \
size_directive_output = 1; \
- fprintf (FILE, "%s", SIZE_ASM_OP); \
- assemble_name (FILE, name); \
- fprintf (FILE, ",%d\n", int_size_in_bytes (TREE_TYPE (DECL))); \
+ size = int_size_in_bytes (TREE_TYPE (DECL)); \
+ ASM_OUTPUT_SIZE_DIRECTIVE (FILE, name, size); \
} \
} while (0)
+
/* A C statement (sans semicolon) to finish up declaring a variable
name once the compiler has processed its initializer fully and
thus has had a chance to determine the size of an array when
If your target assembler doesn't support the .string directive, you
should define this to zero. */
-#define ASM_GLOBALIZE_LABEL(STREAM, NAME) \
-do { \
- fprintf (STREAM, ".global\t"); \
- assemble_name (STREAM, NAME); \
- fprintf (STREAM, "\n"); \
-} \
-while (0)
-
-/* A C statement (sans semicolon) to output to the stdio stream
- STREAM some commands that will make the label NAME global; that
- is, available for reference from other files. Use the expression
- `assemble_name (STREAM, NAME)' to output the name itself; before
- and after that, output the additional assembler syntax for making
- that name global, and a newline. */
+/* Globalizing directive for a label. */
+#define GLOBAL_ASM_OP ".global\t"
-#define ASM_WEAKEN_LABEL(FILE, NAME) \
+#define ASM_WEAKEN_LABEL(FILE, NAME) \
do \
{ \
fputs ("\t.weak\t", (FILE)); \
- assemble_name ((FILE), (NAME)); \
+ assemble_name ((FILE), (NAME)); \
fputc ('\n', (FILE)); \
} \
while (0)
setting the `DECL_ONE_ONLY' flag is enough to mark a declaration to
be emitted as one-only. */
-#define ASM_OUTPUT_INTERNAL_LABEL(STREAM, PREFIX, NUM) \
-fprintf(STREAM, ".%s%d:\n", PREFIX, NUM)
-/* A C statement to output to the stdio stream STREAM a label whose
- name is made from the string PREFIX and the number NUM.
-
- It is absolutely essential that these labels be distinct from the
- labels used for user-level functions and variables. Otherwise,
- certain programs will have name conflicts with internal labels.
-
- It is desirable to exclude internal labels from the symbol table
- of the object file. Most assemblers have a naming convention for
- labels that should be excluded; on many systems, the letter `L' at
- the beginning of a label has this effect. You should find out what
- convention your system uses, and follow it.
-
- The usual definition of this macro is as follows:
-
- fprintf (STREAM, "L%s%d:\n", PREFIX, NUM) */
-
#define ASM_GENERATE_INTERNAL_LABEL(STRING, PREFIX, NUM) \
sprintf (STRING, "*.%s%d", PREFIX, NUM)
/* A C statement to store into the string STRING a label whose name
is made from the string PREFIX and the number NUM.
This string, when output subsequently by `assemble_name', should
- produce the output that `ASM_OUTPUT_INTERNAL_LABEL' would produce
+ produce the output that `(*targetm.asm_out.internal_label)' would produce
with the same PREFIX and NUM.
If the string begins with `*', then `assemble_name' will output
`ASM_OUTPUT_LABELREF' is also part of your machine description, so
you should know what it does on your machine.) */
-#define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO) \
-( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 10), \
- sprintf ((OUTPUT), "%s.%d", (NAME), (LABELNO)))
-
-/* A C expression to assign to OUTVAR (which is a variable of type
- `char *') a newly allocated string made from the string NAME and
- the number NUMBER, with some suitable punctuation added. Use
- `alloca' to get space for the string.
-
- The string will be used as an argument to `ASM_OUTPUT_LABELREF' to
- produce an assembler label for an internal static variable whose
- name is NAME. Therefore, the string must be such as to result in
- valid assembler code. The argument NUMBER is different each time
- this macro is executed; it prevents conflicts between
- similarly-named internal static variables in different scopes.
-
- Ideally this string should not be a valid C identifier, to prevent
- any conflict with the user's own symbols. Most assemblers allow
- periods or percent signs in assembler symbols; putting at least
- one of these between the name and the number will suffice. */
-
/* `ASM_OUTPUT_WEAK_ALIAS (STREAM, NAME, VALUE)'
A C statement to output to the stdio stream STREAM assembler code
which defines (equates) the weak symbol NAME to have the value
#define PRINT_OPERAND_ADDRESS(STREAM, X) print_operand_address(STREAM, X)
/* A C compound statement to output to stdio stream STREAM the
assembler syntax for an instruction operand that is a memory
- reference whose address is X. X is an RTL expression.
-
- On some machines, the syntax for a symbolic address depends on the
- section that the address refers to. On these machines, define the
- macro `ENCODE_SECTION_INFO' to store the information into the
- `symbol_ref', and then check for it here. *Note Assembler
- Format::. */
+ reference whose address is X. X is an RTL expression. */
#define USER_LABEL_PREFIX ""
/* `LOCAL_LABEL_PREFIX'
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 is the number of an internal label
- whose definition is output using `ASM_OUTPUT_INTERNAL_LABEL'. For
+ whose definition is output using `(*targetm.asm_out.internal_label)'. For
example,
fprintf (STREAM, "\t.word L%d\n", VALUE) */
#define ASM_OUTPUT_CASE_LABEL(STREAM, PREFIX, NUM, TABLE) \
- progmem_section (), ASM_OUTPUT_INTERNAL_LABEL (STREAM, PREFIX, NUM)
+ progmem_section (), (*targetm.asm_out.internal_label) (STREAM, PREFIX, NUM)
/* `ASM_OUTPUT_CASE_LABEL (STREAM, PREFIX, NUM, TABLE)'
Define this if the label before a jump-table needs to be output
specially. The first three arguments are the same as for
- `ASM_OUTPUT_INTERNAL_LABEL'; the fourth argument is the jump-table
+ `(*targetm.asm_out.internal_label)'; the fourth argument is the jump-table
which follows (a `jump_insn' containing an `addr_vec' or
`addr_diff_vec').
the table.
If this macro is not defined, these labels are output with
- `ASM_OUTPUT_INTERNAL_LABEL'. */
+ `(*targetm.asm_out.internal_label)'. */
/* `ASM_OUTPUT_CASE_END (STREAM, NUM, TABLE)'
Define this if something special must be output at the end of a
If this macro is not defined, nothing special is output at the end
of the jump-table. */
-#define ASM_OUTPUT_SKIP(STREAM, n) \
-fprintf (STREAM, "\t.skip %d,0\n", n)
+#define ASM_OUTPUT_SKIP(STREAM, N) \
+fprintf (STREAM, "\t.skip %d,0\n", N)
/* A C statement to output to the stdio stream STREAM an assembler
instruction to advance the location counter by NBYTES bytes.
Those bytes should be zero when loaded. NBYTES will be a C
register. Most RISC machines have this property and most CISC
machines do not. */
-#define EASY_DIV_EXPR TRUNC_DIV_EXPR
-/* An alias for a tree code that is the easiest kind of division to
- compile code for in the general case. It may be `TRUNC_DIV_EXPR',
- `FLOOR_DIV_EXPR', `CEIL_DIV_EXPR' or `ROUND_DIV_EXPR'. These four
- division operators differ in how they round the result to an
- integer. `EASY_DIV_EXPR' is used when it is permissible to use
- any of those kinds of division and the choice should be made on
- the basis of efficiency. */
-
#define MOVE_MAX 4
/* The maximum number of bytes that a single instruction can move
quickly between memory and registers or between two memory
of arguments that the function accepts. Some people think a larger
threshold should be used on RISC machines. */
-#define VALID_MACHINE_DECL_ATTRIBUTE(DECL, ATTRIBUTES, IDENTIFIER, ARGS) \
-valid_machine_decl_attribute (DECL, ATTRIBUTES, IDENTIFIER, ARGS)
-/* `VALID_MACHINE_DECL_ATTRIBUTE (DECL, ATTRIBUTES, IDENTIFIER, ARGS)'
- If defined, a C expression whose value is nonzero if IDENTIFIER
- with arguments ARGS is a valid machine specific attribute for DECL.
- The attributes in ATTRIBUTES have previously been assigned to DECL. */
-
-#define VALID_MACHINE_TYPE_ATTRIBUTE(TYPE, ATTRIBUTES, IDENTIFIER, ARGS) \
- valid_machine_type_attribute(TYPE, ATTRIBUTES, IDENTIFIER, ARGS)
-/* `VALID_MACHINE_TYPE_ATTRIBUTE (TYPE, ATTRIBUTES, IDENTIFIER, ARGS)'
- If defined, a C expression whose value is nonzero if IDENTIFIER
- with arguments ARGS is a valid machine specific attribute for TYPE.
- The attributes in ATTRIBUTES have previously been assigned to TYPE. */
-
#define DOLLARS_IN_IDENTIFIERS 0
/* Define this macro to control use of the character `$' in identifier
names. 0 means `$' is not allowed by default; 1 means it is
addresses. Thus sorting to put the smallest address first allows
the most combinations to be found. */
-/* Define results of standard character escape sequences. */
-#define TARGET_BELL 007
-#define TARGET_BS 010
-#define TARGET_TAB 011
-#define TARGET_NEWLINE 012
-#define TARGET_VT 013
-#define TARGET_FF 014
-#define TARGET_CR 015
-
-
-
#define TRAMPOLINE_TEMPLATE(FILE) \
- internal_error ("Trampolines not supported\n")
+ internal_error ("trampolines not supported")
/* Length in units of the trampoline for entering a nested function. */
(and ANSI C) library functions `memcpy' and `memset' rather than
the BSD functions `bcopy' and `bzero'. */
-#define CPP_SPEC "\
-%{!mmcu*|mmcu=avr2:%(cpp_avr2)} \
-%{mmcu=at90s2313:%(cpp_avr2) -D__AVR_AT90S2313__} \
-%{mmcu=at90s2323:%(cpp_avr2) -D__AVR_AT90S2323__} \
-%{mmcu=at90s2333:%(cpp_avr2) -D__AVR_AT90S2333__} \
-%{mmcu=at90s2343:%(cpp_avr2) -D__AVR_AT90S2343__} \
-%{mmcu=attiny22: %(cpp_avr2) -D__AVR_ATtiny22__} \
-%{mmcu=at90s4433:%(cpp_avr2) -D__AVR_AT90S4433__} \
-%{mmcu=at90s4414:%(cpp_avr2) -D__AVR_AT90S4414__} \
-%{mmcu=at90s4434:%(cpp_avr2) -D__AVR_AT90S4434__} \
-%{mmcu=at90s8515:%(cpp_avr2) -D__AVR_AT90S8515__} \
-%{mmcu=at90s8535:%(cpp_avr2) -D__AVR_AT90S8535__} \
-%{mmcu=at90c8534:%(cpp_avr2) -D__AVR_AT90C8534__} \
-%{mmcu=avr3:%(cpp_avr3)} \
-%{mmcu=atmega603:%(cpp_avr3) -D__AVR_ATmega603__} \
-%{mmcu=atmega103:%(cpp_avr3) -D__AVR_ATmega103__} \
-%{mmcu=avr4:%(cpp_avr4)} \
-%{mmcu=atmega83: %(cpp_avr4) -D__AVR_ATmega83__} \
-%{mmcu=atmega85: %(cpp_avr4) -D__AVR_ATmega85__} \
-%{mmcu=avr5:%(cpp_avr5)} \
-%{mmcu=atmega161:%(cpp_avr5) -D__AVR_ATmega161__} \
-%{mmcu=atmega163:%(cpp_avr5) -D__AVR_ATmega163__} \
-%{mmcu=atmega32: %(cpp_avr5) -D__AVR_ATmega32__} \
-%{mmcu=at94k: %(cpp_avr5) -D__AVR_AT94K__} \
-%{mmcu=avr1:%(cpp_avr1)} \
-%{mmcu=at90s1200:%(cpp_avr1) -D__AVR_AT90S1200__} \
-%{mmcu=attiny10|mmcu=attiny11: %(cpp_avr1) -D__AVR_ATtiny11__} \
-%{mmcu=attiny12: %(cpp_avr1) -D__AVR_ATtiny12__} \
-%{mmcu=attiny15: %(cpp_avr1) -D__AVR_ATtiny15__} \
-%{mmcu=attiny28: %(cpp_avr1) -D__AVR_ATtiny28__} \
-%{mno-interrupts:-D__NO_INTERRUPTS__} \
-%{mint8:-D__SIZE_TYPE__=long\\ unsigned\\ int -D__PTRDIFF_TYPE__=long -D__INT_MAX__=127} \
-%{!mint*:-D__SIZE_TYPE__=unsigned\\ int -D__PTRDIFF_TYPE__=int -D__INT_MAX__=32767} \
-%{posix:-D_POSIX_SOURCE}"
+#define CPP_SPEC "%{posix:-D_POSIX_SOURCE}"
+
/* A C string constant that tells the GNU CC driver program options to
pass to CPP. It can also specify how to translate options you
give to GNU CC into options for GNU CC to pass to the CPP.
Do not define this macro if it does not need to do anything. */
-#define NO_BUILTIN_SIZE_TYPE
-/* If this macro is defined, the preprocessor will not define the
- builtin macro `__SIZE_TYPE__'. The macro `__SIZE_TYPE__' must
- then be defined by `CPP_SPEC' instead.
-
- This should be defined if `SIZE_TYPE' depends on target dependent
- flags which are not accessible to the preprocessor. Otherwise, it
- should not be defined. */
-
-#define NO_BUILTIN_PTRDIFF_TYPE
-/* If this macro is defined, the preprocessor will not define the
- builtin macro `__PTRDIFF_TYPE__'. The macro `__PTRDIFF_TYPE__'
- must then be defined by `CPP_SPEC' instead.
-
- This should be defined if `PTRDIFF_TYPE' depends on target
- dependent flags which are not accessible to the preprocessor.
- Otherwise, it should not be defined.
-
- `SIGNED_CHAR_SPEC'
- A C string constant that tells the GNU CC driver program options to
- pass to CPP. By default, this macro is defined to pass the option
- `-D__CHAR_UNSIGNED__' to CPP if `char' will be treated as
- `unsigned char' by `cc1'.
-
- Do not define this macro unless you need to override the default
- definition. */
-
#define CC1_SPEC "%{profile:-p}"
/* A C string constant that tells the GNU CC driver program options to
pass to `cc1'. It can also specify how to translate options you
Do not define this macro if it does not need to do anything. */
-#define ASM_SPEC "%{mmcu=*:-mmcu=%*}"
-/* A C string constant that tells the GNU CC driver program options to
- pass to the assembler. It can also specify how to translate
- options you give to GNU CC into options for GNU CC to pass to the
- assembler. See the file `sun3.h' for an example of this.
-
- Do not define this macro if it does not need to do anything. */
+#define CC1PLUS_SPEC "%{!frtti:-fno-rtti} \
+ %{!fenforce-eh-specs:-fno-enforce-eh-specs} \
+ %{!fexceptions:-fno-exceptions}"
+/* A C string constant that tells the GNU CC drvier program options to
+ pass to `cc1plus'. */
-#define ASM_FINAL_SPEC ""
+#define ASM_SPEC "%{mmcu=*:-mmcu=%*}"
/* A C string constant that tells the GNU CC driver program how to
run any programs which cleanup after the normal assembler.
Normally, this is not needed. See the file `mips.h' for an
Do not define this macro if it does not need to do anything. */
-#define LINK_SPEC "\
-%{!mmcu*:-m avr85xx} \
-%{mmcu=atmega603:-m avrmega603} \
-%{mmcu=atmega103:-m avrmega103} \
-%{mmcu=atmega161:-m avrmega161} \
-%{mmcu=atmega163:-m avrmega161} \
-%{mmcu=atmega32:-m avr5} \
-%{mmcu=at94k:-m avr5} \
-%{mmcu=atmega83:-m avr4} \
-%{mmcu=atmega85:-m avr4} \
-%{mmcu=at90s1200|mmcu=attiny1*:-m avr1200} \
-%{mmcu=attiny28:-m avr1} \
-%{mmcu=at90s2313:-m avr23xx} \
-%{mmcu=at90s2323:-m avr23xx} \
-%{mmcu=attiny22:-m avr23xx} \
-%{mmcu=at90s2333:-m avr23xx} \
-%{mmcu=at90s2343:-m avr23xx} \
-%{mmcu=at90s4433:-m avr4433} \
-%{mmcu=at90s4414:-m avr44x4} \
-%{mmcu=at90s4434:-m avr44x4} \
-%{mmcu=at90c8534:-m avr85xx} \
-%{mmcu=at90s8535:-m avr85xx} \
-%{mmcu=at90s8515:-m avr85xx}"
+#define LINK_SPEC " %{!mmcu*:-m avr2}\
+%{mmcu=at90s1200|mmcu=attiny1*|mmcu=attiny28:-m avr1} \
+%{mmcu=attiny22|mmcu=attiny26|mmcu=at90s2*|mmcu=at90s4*|mmcu=at90s8*|mmcu=at90c8*|mmcu=at86rf401:-m avr2}\
+%{mmcu=atmega103|mmcu=atmega603|mmcu=at43*|mmcu=at76*:-m avr3}\
+%{mmcu=atmega8*:-m avr4}\
+%{mmcu=atmega16*|mmcu=atmega32*|mmcu=atmega64|mmcu=atmega128|mmcu=at94k:-m avr5}\
+%{mmcu=atmega64|mmcu=atmega128|mmcu=atmega162|mmcu=atmega169: -Tdata 0x800100} "
/* A C string constant that tells the GNU CC driver program options to
pass to the linker. It can also specify how to translate options
If this macro is not defined, a default is provided that loads the
standard C library from the usual place. See `gcc.c'. */
+#define LIBSTDCXX "-lgcc"
+/* No libstdc++ for now. Empty string doesn't work. */
+
#define LIBGCC_SPEC \
"%{!mmcu=at90s1*:%{!mmcu=attiny1*:%{!mmcu=attiny28: -lgcc }}}"
/* Another C string constant that tells the GNU CC driver program how
#define CRT_BINUTILS_SPECS "\
%{mmcu=at90s1200|mmcu=avr1:crts1200.o%s} \
-%{mmcu=attiny10|mmcu=attiny11:crttn11.o%s} \
+%{mmcu=attiny11:crttn11.o%s} \
%{mmcu=attiny12:crttn12.o%s} \
%{mmcu=attiny15:crttn15.o%s} \
%{mmcu=attiny28:crttn28.o%s} \
%{!mmcu*|mmcu=at90s8515|mmcu=avr2:crts8515.o%s} \
%{mmcu=at90s2313:crts2313.o%s} \
%{mmcu=at90s2323:crts2323.o%s} \
-%{mmcu=attiny22:crttn22.o%s} \
%{mmcu=at90s2333:crts2333.o%s} \
%{mmcu=at90s2343:crts2343.o%s} \
+%{mmcu=attiny22:crttn22.o%s} \
+%{mmcu=attiny26:crttn26.o%s} \
%{mmcu=at90s4433:crts4433.o%s} \
%{mmcu=at90s4414:crts4414.o%s} \
%{mmcu=at90s4434:crts4434.o%s} \
%{mmcu=at90c8534:crtc8534.o%s} \
%{mmcu=at90s8535:crts8535.o%s} \
+%{mmcu=at86rf401:crt86401.o%s} \
%{mmcu=atmega103|mmcu=avr3:crtm103.o%s} \
%{mmcu=atmega603:crtm603.o%s} \
-%{mmcu=atmega83|mmcu=avr4:crtm83.o%s} \
-%{mmcu=atmega85:crtm85.o%s} \
+%{mmcu=at43usb320:crt43320.o%s} \
+%{mmcu=at43usb355:crt43355.o%s} \
+%{mmcu=at76c711:crt76711.o%s} \
+%{mmcu=atmega8|mmcu=avr4:crtm8.o%s} \
+%{mmcu=atmega8515:crtm8515.o%s} \
+%{mmcu=atmega8535:crtm8535.o%s} \
+%{mmcu=atmega16:crtm16.o%s} \
%{mmcu=atmega161|mmcu=avr5:crtm161.o%s} \
+%{mmcu=atmega162:crtm162.o%s} \
%{mmcu=atmega163:crtm163.o%s} \
+%{mmcu=atmega169:crtm169.o%s} \
%{mmcu=atmega32:crtm32.o%s} \
+%{mmcu=atmega323:crtm323.o%s} \
+%{mmcu=atmega64:crtm64.o%s} \
+%{mmcu=atmega128:crtm128.o%s} \
%{mmcu=at94k:crtat94k.o%s}"
-#define CPP_AVR1_SPEC "-D__AVR_ARCH__=1 -D__AVR_ASM_ONLY__ "
-#define CPP_AVR2_SPEC "-D__AVR_ARCH__=2 "
-#define CPP_AVR3_SPEC "-D__AVR_ARCH__=3 -D__AVR_MEGA__ "
-#define CPP_AVR4_SPEC "-D__AVR_ARCH__=4 -D__AVR_ENHANCED__ "
-#define CPP_AVR5_SPEC "-D__AVR_ARCH__=5 -D__AVR_ENHANCED__ -D__AVR_MEGA__ "
-
-#define EXTRA_SPECS \
-{"cpp_avr1", CPP_AVR1_SPEC}, \
-{"cpp_avr2", CPP_AVR2_SPEC}, \
-{"cpp_avr3", CPP_AVR3_SPEC}, \
-{"cpp_avr4", CPP_AVR4_SPEC}, \
-{"cpp_avr5", CPP_AVR5_SPEC}, \
-{"crt_binutils", CRT_BINUTILS_SPECS},
+#define EXTRA_SPECS {"crt_binutils", CRT_BINUTILS_SPECS},
+
/* Define this macro to provide additional specifications to put in
the `specs' file that can be used in various specifications like
- `CC1_SPEC'.
-
- The definition should be an initializer for an array of structures,
- containing a string constant, that defines the specification name,
- and a string constant that provides the specification.
-
- Do not define this macro if it does not need to do anything.
-
- `EXTRA_SPECS' is useful when an architecture contains several
- related targets, which have various `..._SPECS' which are similar
- to each other, and the maintainer would like one central place to
- keep these definitions.
-
- For example, the PowerPC System V.4 targets use `EXTRA_SPECS' to
- define either `_CALL_SYSV' when the System V calling sequence is
- used or `_CALL_AIX' when the older AIX-based calling sequence is
- used.
-
- The `config/rs6000/rs6000.h' target file defines:
-
- #define EXTRA_SPECS \
- { "cpp_sysv_default", CPP_SYSV_DEFAULT },
-
- #define CPP_SYS_DEFAULT ""
-
- The `config/rs6000/sysv.h' target file defines:
- #undef CPP_SPEC
- #define CPP_SPEC \
- "%{posix: -D_POSIX_SOURCE } \
- %{mcall-sysv: -D_CALL_SYSV } %{mcall-aix: -D_CALL_AIX } \
- %{!mcall-sysv: %{!mcall-aix: %(cpp_sysv_default) }} \
- %{msoft-float: -D_SOFT_FLOAT} %{mcpu=403: -D_SOFT_FLOAT}"
-
- #undef CPP_SYSV_DEFAULT
- #define CPP_SYSV_DEFAULT "-D_CALL_SYSV"
-
- while the `config/rs6000/eabiaix.h' target file defines
- `CPP_SYSV_DEFAULT' as:
-
- #undef CPP_SYSV_DEFAULT
- #define CPP_SYSV_DEFAULT "-D_CALL_AIX" */
+ `CC1_SPEC'. */
/* This is the default without any -mmcu=* option (AT90S*). */
#define MULTILIB_DEFAULTS { "mmcu=avr2" }
extern struct rtx_def *zero_reg_rtx;
extern struct rtx_def *ldi_reg_rtx;
-#define TARGET_FLOAT_FORMAT IEEE_FLOAT_FORMAT
-
-/* Define to use software floating point emulator for REAL_ARITHMETIC and
- decimal <-> binary conversion. */
-#define REAL_ARITHMETIC
-
#define PREFERRED_DEBUGGING_TYPE DBX_DEBUG
-#define DBX_REGISTER_NUMBER(r) (r)
-
/* Get the standard ELF stabs definitions. */
#include "dbxelf.h"
OSDN Git Service
