/* 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 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. */
/* This declaration should be present. */
#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. */
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;
#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
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. */
{(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 */ \
+ {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
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)'
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
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.
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
#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
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)'
+/* `SELECT_RTX_SECTION (MODE, RTX, ALIGN)'
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
This macro is irrelevant if there is no separate readonly data
section. */
-#define ENCODE_SECTION_INFO(DECL) encode_section_info(DECL)
+#define ENCODE_SECTION_INFO(DECL, FIRST) encode_section_info(DECL, FIRST)
/* 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).
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
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
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.
-
- 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)'
output_ascii (FILE, P, SIZE)
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) \
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. */
%{mmcu=at90s2333:%(cpp_avr2) -D__AVR_AT90S2333__} \
%{mmcu=at90s2343:%(cpp_avr2) -D__AVR_AT90S2343__} \
%{mmcu=attiny22: %(cpp_avr2) -D__AVR_ATtiny22__} \
+%{mmcu=attiny26: %(cpp_avr2) -D__AVR_ATtiny26__} \
%{mmcu=at90s4433:%(cpp_avr2) -D__AVR_AT90S4433__} \
%{mmcu=at90s4414:%(cpp_avr2) -D__AVR_AT90S4414__} \
%{mmcu=at90s4434:%(cpp_avr2) -D__AVR_AT90S4434__} \
%{mmcu=avr3:%(cpp_avr3)} \
%{mmcu=atmega603:%(cpp_avr3) -D__AVR_ATmega603__} \
%{mmcu=atmega103:%(cpp_avr3) -D__AVR_ATmega103__} \
+%{mmcu=at43usb320:%(cpp_avr3) -D__AVR_AT43USB320__} \
+%{mmcu=at43usb355:%(cpp_avr3) -D__AVR_AT43USB355__} \
+%{mmcu=at76c711: %(cpp_avr3) -D__AVR_AT76C711__} \
%{mmcu=avr4:%(cpp_avr4)} \
+%{mmcu=atmega8: %(cpp_avr4) -D__AVR_ATmega8__} \
%{mmcu=atmega83: %(cpp_avr4) -D__AVR_ATmega83__} \
%{mmcu=atmega85: %(cpp_avr4) -D__AVR_ATmega85__} \
+%{mmcu=atmega8515: %(cpp_avr4) -D__AVR_ATmega8515__} \
%{mmcu=avr5:%(cpp_avr5)} \
+%{mmcu=atmega16: %(cpp_avr5) -D__AVR_ATmega16__} \
%{mmcu=atmega161:%(cpp_avr5) -D__AVR_ATmega161__} \
+%{mmcu=atmega162:%(cpp_avr5) -D__AVR_ATmega162__} \
%{mmcu=atmega163:%(cpp_avr5) -D__AVR_ATmega163__} \
%{mmcu=atmega32: %(cpp_avr5) -D__AVR_ATmega32__} \
+%{mmcu=atmega323:%(cpp_avr5) -D__AVR_ATmega323__} \
+%{mmcu=atmega64: %(cpp_avr5) -D__AVR_ATmega64__} \
+%{mmcu=atmega128:%(cpp_avr5) -D__AVR_ATmega128__} \
%{mmcu=at94k: %(cpp_avr5) -D__AVR_AT94K__} \
%{mmcu=avr1:%(cpp_avr1)} \
%{mmcu=at90s1200:%(cpp_avr1) -D__AVR_AT90S1200__} \
%{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} \
+%{mint8:-D__INT_MAX__=127} \
+%{!mint*:-D__INT_MAX__=32767} \
%{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
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
%{!mmcu*:-m avr85xx} \
%{mmcu=atmega603:-m avrmega603} \
%{mmcu=atmega103:-m avrmega103} \
+%{mmcu=at43usb320:-m avr3} \
+%{mmcu=at43usb355:-m avr3} \
+%{mmcu=at76c711:-m avr3} \
+%{mmcu=atmega16:-m avrmega161} \
%{mmcu=atmega161:-m avrmega161} \
+%{mmcu=atmega162:-m avr5 -Tdata 0x800100} \
%{mmcu=atmega163:-m avrmega161} \
%{mmcu=atmega32:-m avr5} \
+%{mmcu=atmega323:-m avr5} \
+%{mmcu=atmega64:-m avr5 -Tdata 0x800100} \
+%{mmcu=atmega128:-m avr5 -Tdata 0x800100} \
%{mmcu=at94k:-m avr5} \
+%{mmcu=atmega8:-m avr4} \
%{mmcu=atmega83:-m avr4} \
%{mmcu=atmega85:-m avr4} \
+%{mmcu=atmega8515:-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=attiny22:-m avr23xx} \
+%{mmcu=attiny26:-m avr23xx} \
%{mmcu=at90s4433:-m avr4433} \
%{mmcu=at90s4414:-m avr44x4} \
%{mmcu=at90s4434:-m avr44x4} \
%{!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=at90s8535:crts8535.o%s} \
%{mmcu=atmega103|mmcu=avr3:crtm103.o%s} \
%{mmcu=atmega603:crtm603.o%s} \
+%{mmcu=at43usb320:crt43320.o%s} \
+%{mmcu=at43usb355:crt43355.o%s} \
+%{mmcu=at76c711:crt76711.o%s } \
+%{mmcu=atmega8:crtm8.o%s} \
%{mmcu=atmega83|mmcu=avr4:crtm83.o%s} \
%{mmcu=atmega85:crtm85.o%s} \
+%{mmcu=atmega8515:crtm8515.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=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 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
