Next: , Previous: ARM Options, Up: Submodel Options


3.17.3 AVR Options

-mmcu=mcu
Specify Atmel AVR instruction set architectures (ISA) or MCU type.

For a complete list of mcu values that are supported by avr-gcc, see the compiler output when called with the --help=target command line option. The default for this option is avr2.

GCC supports the following AVR devices and ISAs:

avr2
“Classic” devices with up to 8 KiB of program memory.
mcu = at90c8534, at90s2313, at90s2323, at90s2333, at90s2343, at90s4414, at90s4433, at90s4434, at90s8515, at90s8535, attiny22, attiny26.
avr25
“Classic” devices with up to 8 KiB of program memory and with the MOVW instruction.
mcu = at86rf401, ata6289, attiny13, attiny13a, attiny2313, attiny2313a, attiny24, attiny24a, attiny25, attiny261, attiny261a, attiny4313, attiny43u, attiny44, attiny44a, attiny45, attiny461, attiny461a, attiny48, attiny84, attiny84a, attiny85, attiny861, attiny861a, attiny87, attiny88.
avr3
“Classic” devices with 16 KiB up to 64 KiB of program memory.
mcu = at43usb355, at76c711.
avr31
“Classic” devices with 128 KiB of program memory.
mcu = at43usb320, atmega103.
avr35
“Classic” devices with 16 KiB up to 64 KiB of program memory and with the MOVW instruction.
mcu = at90usb162, at90usb82, atmega16u2, atmega32u2, atmega8u2, attiny167.
avr4
“Enhanced” devices with up to 8 KiB of program memory.
mcu = at90pwm1, at90pwm2, at90pwm2b, at90pwm3, at90pwm3b, at90pwm81, atmega48, atmega48a, atmega48p, atmega8, atmega8515, atmega8535, atmega88, atmega88a, atmega88p, atmega88pa, atmega8hva.
avr5
“Enhanced” devices with 16 KiB up to 64 KiB of program memory.
mcu = at90can32, at90can64, at90pwm216, at90pwm316, at90scr100, at90usb646, at90usb647, at94k, atmega16, atmega161, atmega162, atmega163, atmega164a, atmega164p, atmega165, atmega165a, atmega165p, atmega168, atmega168a, atmega168p, atmega169, atmega169a, atmega169p, atmega169pa, atmega16a, atmega16hva, atmega16hva2, atmega16hvb, atmega16m1, atmega16u4, atmega32, atmega323, atmega324a, atmega324p, atmega324pa, atmega325, atmega3250, atmega3250a, atmega3250p, atmega325a, atmega325p, atmega328, atmega328p, atmega329, atmega3290, atmega3290a, atmega3290p, atmega329a, atmega329p, atmega329pa, atmega32c1, atmega32hvb, atmega32m1, atmega32u4, atmega32u6, atmega406, atmega64, atmega640, atmega644, atmega644a, atmega644p, atmega644pa, atmega645, atmega6450, atmega6450a, atmega6450p, atmega645a, atmega645p, atmega649, atmega6490, atmega649a, atmega649p, atmega64c1, atmega64hve, atmega64m1, m3000.
avr51
“Enhanced” devices with 128 KiB of program memory.
mcu = at90can128, at90usb1286, at90usb1287, atmega128, atmega1280, atmega1281, atmega1284p, atmega128rfa1.
avr6
“Enhanced” devices with 3-byte PC, i.e. with more than 128 KiB of program memory.
mcu = atmega2560, atmega2561.
avrxmega2
“XMEGA” devices with more than 8 KiB and up to 64 KiB of program memory.
mcu = atxmega16a4, atxmega16d4, atxmega16x1, atxmega32a4, atxmega32d4, atxmega32x1.
avrxmega4
“XMEGA” devices with more than 64 KiB and up to 128 KiB of program memory.
mcu = atxmega64a3, atxmega64d3.
avrxmega5
“XMEGA” devices with more than 64 KiB and up to 128 KiB of program memory and more than 64 KiB of RAM.
mcu = atxmega64a1, atxmega64a1u.
avrxmega6
“XMEGA” devices with more than 128 KiB of program memory.
mcu = atxmega128a3, atxmega128d3, atxmega192a3, atxmega192d3, atxmega256a3, atxmega256a3b, atxmega256a3bu, atxmega256d3.
avrxmega7
“XMEGA” devices with more than 128 KiB of program memory and more than 64 KiB of RAM.
mcu = atxmega128a1, atxmega128a1u.
avr1
This ISA is implemented by the minimal AVR core and supported for assembler only.
mcu = at90s1200, attiny11, attiny12, attiny15, attiny28.

-maccumulate-args
Accumulate outgoing function arguments and acquire/release the needed stack space for outgoing function arguments once in function prologue/epilogue. Without this option, outgoing arguments are pushed before calling a function and popped afterwards.

Popping the arguments after the function call can be expensive on AVR so that accumulating the stack space might lead to smaller executables because arguments need not to be removed from the stack after such a function call.

This option can lead to reduced code size for functions that perform several calls to functions that get their arguments on the stack like calls to printf-like functions.

-mbranch-cost=cost
Set the branch costs for conditional branch instructions to cost. Reasonable values for cost are small, non-negative integers. The default branch cost is 0.
-mcall-prologues
Functions prologues/epilogues are expanded as calls to appropriate subroutines. Code size is smaller.
-mint8
Assume int to be 8-bit integer. This affects the sizes of all types: a char is 1 byte, an int is 1 byte, a long is 2 bytes, and long long is 4 bytes. Please note that this option does not conform to the C standards, but it results in smaller code size.
-mno-interrupts
Generated code is not compatible with hardware interrupts. Code size is smaller.
-mrelax
Try to replace CALL resp. JMP instruction by the shorter RCALL resp. RJMP instruction if applicable. Setting -mrelax just adds the --relax option to the linker command line when the linker is called.

Jump relaxing is performed by the linker because jump offsets are not known before code is located. Therefore, the assembler code generated by the compiler is the same, but the instructions in the executable may differ from instructions in the assembler code.

Relaxing must be turned on if linker stubs are needed, see the section on EIND and linker stubs below.

-mshort-calls
Use RCALL/RJMP instructions even on devices with 16 KiB or more of program memory, i.e. on devices that have the CALL and JMP instructions. See also the -mrelax command line option.
-msp8
Treat the stack pointer register as an 8-bit register, i.e. assume the high byte of the stack pointer is zero. In general, you don't need to set this option by hand.

This option is used internally by the compiler to select and build multilibs for architectures avr2 and avr25. These architectures mix devices with and without SPH. For any setting other than -mmcu=avr2 or -mmcu=avr25 the compiler driver will add or remove this option from the compiler proper's command line, because the compiler then knows if the device or architecture has an 8-bit stack pointer and thus no SPH register or not.

-mstrict-X
Use address register X in a way proposed by the hardware. This means that X is only used in indirect, post-increment or pre-decrement addressing.

Without this option, the X register may be used in the same way as Y or Z which then is emulated by additional instructions. For example, loading a value with X+const addressing with a small non-negative const < 64 to a register Rn is performed as

          adiw r26, const   ; X += const
          ld   Rn, X        ; Rn = *X
          sbiw r26, const   ; X -= const
     

-mtiny-stack
Only change the lower 8 bits of the stack pointer.
3.17.3.1 EIND and Devices with more than 128 Ki Bytes of Flash

Pointers in the implementation are 16 bits wide. The address of a function or label is represented as word address so that indirect jumps and calls can target any code address in the range of 64 Ki words.

In order to facilitate indirect jump on devices with more than 128 Ki bytes of program memory space, there is a special function register called EIND that serves as most significant part of the target address when EICALL or EIJMP instructions are used.

Indirect jumps and calls on these devices are handled as follows by the compiler and are subject to some limitations:

3.17.3.2 Handling of the RAMPD, RAMPX, RAMPY and RAMPZ Special Function Registers

Some AVR devices support memories larger than the 64 KiB range that can be accessed with 16-bit pointers. To access memory locations outside this 64 KiB range, the contentent of a RAMP register is used as high part of the address: The X, Y, Z address register is concatenated with the RAMPX, RAMPY, RAMPZ special function register, respectively, to get a wide address. Similarly, RAMPD is used together with direct addressing.

3.17.3.3 AVR Built-in Macros

GCC defines several built-in macros so that the user code can test for the presence or absence of features. Almost any of the following built-in macros are deduced from device capabilities and thus triggered by the -mmcu= command-line option.

For even more AVR-specific built-in macros see AVR Named Address Spaces and AVR Built-in Functions.

__AVR_Device__
Setting -mmcu=device defines this built-in macro which reflects the device's name. For example, -mmcu=atmega8 defines the built-in macro __AVR_ATmega8__, -mmcu=attiny261a defines __AVR_ATtiny261A__, etc.

The built-in macros' names follow the scheme __AVR_Device__ where Device is the device name as from the AVR user manual. The difference between Device in the built-in macro and device in -mmcu=device is that the latter is always lowercase.

__AVR_HAVE_ELPM__
The device has the the ELPM instruction.
__AVR_HAVE_ELPMX__
The device has the ELPM Rn,Z and ELPM Rn,Z+ instructions.
__AVR_HAVE_MOVW__
The device has the MOVW instruction to perform 16-bit register-register moves.
__AVR_HAVE_LPMX__
The device has the LPM Rn,Z and LPM Rn,Z+ instructions.
__AVR_HAVE_MUL__
The device has a hardware multiplier.
__AVR_HAVE_JMP_CALL__
The device has the JMP and CALL instructions. This is the case for devices with at least 16 KiB of program memory and if -mshort-calls is not set.
__AVR_HAVE_EIJMP_EICALL__
__AVR_3_BYTE_PC__
The device has the EIJMP and EICALL instructions. This is the case for devices with more than 128 KiB of program memory. This also means that the program counter (PC) is 3 bytes wide.
__AVR_2_BYTE_PC__
The program counter (PC) is 2 bytes wide. This is the case for devices with up to 128 KiB of program memory.
__AVR_HAVE_8BIT_SP__
__AVR_HAVE_16BIT_SP__
The stack pointer (SP) register is treated as 8-bit respectively 16-bit register by the compiler. The definition of these macros is affected by -mtiny-stack.
__AVR_HAVE_SPH__
__AVR_SP8__
The device has the SPH (high part of stack pointer) special function register or has an 8-bit stack pointer, respectively. The definition of these macros is affected by -mmcu= and in the cases of -mmcu=avr2 and -mmcu=avr25 also by -msp8.
__AVR_HAVE_RAMPD__
__AVR_HAVE_RAMPX__
__AVR_HAVE_RAMPY__
__AVR_HAVE_RAMPZ__
The device has the RAMPD, RAMPX, RAMPY, RAMPZ special function register, respectively.
__NO_INTERRUPTS__
This macro reflects the -mno-interrupts command line option.
__AVR_ERRATA_SKIP__
__AVR_ERRATA_SKIP_JMP_CALL__
Some AVR devices (AT90S8515, ATmega103) must not skip 32-bit instructions because of a hardware erratum. Skip instructions are SBRS, SBRC, SBIS, SBIC and CPSE. The second macro is only defined if __AVR_HAVE_JMP_CALL__ is also set.
__AVR_SFR_OFFSET__=offset
Instructions that can address I/O special function registers directly like IN, OUT, SBI, etc. may use a different address as if addressed by an instruction to access RAM like LD or STS. This offset depends on the device architecture and has to be subtracted from the RAM address in order to get the respective I/O address.
__WITH_AVRLIBC__
The compiler is configured to be used together with AVR-Libc. See the --with-avrlibc configure option.