void avr_cpu_cpp_builtins (struct cpp_reader *pfile) { int i; builtin_define_std ("AVR"); /* __AVR_DEVICE_NAME__ and avr_mcu_types[].macro like __AVR_ATmega8__ are defined by -D command option, see device-specs file. */ if (avr_arch->macro) cpp_define_formatted (pfile, "__AVR_ARCH__=%s", avr_arch->macro); if (AVR_HAVE_RAMPD) cpp_define (pfile, "__AVR_HAVE_RAMPD__"); if (AVR_HAVE_RAMPX) cpp_define (pfile, "__AVR_HAVE_RAMPX__"); if (AVR_HAVE_RAMPY) cpp_define (pfile, "__AVR_HAVE_RAMPY__"); if (AVR_HAVE_RAMPZ) cpp_define (pfile, "__AVR_HAVE_RAMPZ__"); if (AVR_HAVE_ELPM) cpp_define (pfile, "__AVR_HAVE_ELPM__"); if (AVR_HAVE_ELPMX) cpp_define (pfile, "__AVR_HAVE_ELPMX__"); if (AVR_HAVE_MOVW) cpp_define (pfile, "__AVR_HAVE_MOVW__"); if (AVR_HAVE_LPMX) cpp_define (pfile, "__AVR_HAVE_LPMX__"); if (avr_arch->asm_only) cpp_define (pfile, "__AVR_ASM_ONLY__"); if (AVR_HAVE_MUL) { cpp_define (pfile, "__AVR_ENHANCED__"); cpp_define (pfile, "__AVR_HAVE_MUL__"); } if (avr_arch->have_jmp_call) { cpp_define (pfile, "__AVR_MEGA__"); cpp_define (pfile, "__AVR_HAVE_JMP_CALL__"); } if (AVR_XMEGA) cpp_define (pfile, "__AVR_XMEGA__"); if (AVR_TINY) { cpp_define (pfile, "__AVR_TINY__"); /* Define macro "__AVR_TINY_PM_BASE_ADDRESS__" with mapped program memory start address. This macro shall be used where mapped program memory is accessed, eg. copying data section (__do_copy_data) contents to data memory region. NOTE: Program memory of AVR_TINY devices cannot be accessed directly, it has been mapped to the data memory. For AVR_TINY devices (ATtiny4/5/9/10/20 and 40) mapped program memory starts at 0x4000. */ cpp_define_formatted (pfile, "__AVR_TINY_PM_BASE_ADDRESS__=0x%x", AVR_TINY_PM_OFFSET); } if (AVR_HAVE_EIJMP_EICALL) { cpp_define (pfile, "__AVR_HAVE_EIJMP_EICALL__"); cpp_define (pfile, "__AVR_3_BYTE_PC__"); } else { cpp_define (pfile, "__AVR_2_BYTE_PC__"); } if (AVR_HAVE_8BIT_SP) cpp_define (pfile, "__AVR_HAVE_8BIT_SP__"); else cpp_define (pfile, "__AVR_HAVE_16BIT_SP__"); if (AVR_HAVE_SPH) cpp_define (pfile, "__AVR_HAVE_SPH__"); else cpp_define (pfile, "__AVR_SP8__"); if (TARGET_NO_INTERRUPTS) cpp_define (pfile, "__NO_INTERRUPTS__"); if (TARGET_SKIP_BUG) { cpp_define (pfile, "__AVR_ERRATA_SKIP__"); if (AVR_HAVE_JMP_CALL) cpp_define (pfile, "__AVR_ERRATA_SKIP_JMP_CALL__"); } if (TARGET_RMW) cpp_define (pfile, "__AVR_ISA_RMW__"); cpp_define_formatted (pfile, "__AVR_SFR_OFFSET__=0x%x", avr_arch->sfr_offset); #ifdef WITH_AVRLIBC cpp_define (pfile, "__WITH_AVRLIBC__"); #endif /* WITH_AVRLIBC */ /* Define builtin macros so that the user can easily query whether non-generic address spaces (and which) are supported or not. This is only supported for C. For C++, a language extension is needed (as mentioned in ISO/IEC DTR 18037; Annex F.2) which is not implemented in GCC up to now. */ if (lang_GNU_C ()) { for (i = 0; i < ADDR_SPACE_COUNT; i++) if (!ADDR_SPACE_GENERIC_P (i) /* Only supply __FLASH<n> macro if the address space is reasonable for this target. The address space qualifier itself is still supported, but using it will throw an error. */ && avr_addr_space_supported_p ((addr_space_t) i)) { const char *name = avr_addrspace[i].name; char *Name = (char*) alloca (1 + strlen (name)); cpp_define (pfile, avr_toupper (Name, name)); } } /* Define builtin macros so that the user can easily query whether or not a specific builtin is available. */ #define DEF_BUILTIN(NAME, N_ARGS, TYPE, CODE, LIBNAME) \ cpp_define (pfile, "__BUILTIN_AVR_" #NAME); #include "builtins.def" #undef DEF_BUILTIN /* Builtin macros for the __int24 and __uint24 type. */ cpp_define_formatted (pfile, "__INT24_MAX__=8388607%s", INT_TYPE_SIZE == 8 ? "LL" : "L"); cpp_define (pfile, "__INT24_MIN__=(-__INT24_MAX__-1)"); cpp_define_formatted (pfile, "__UINT24_MAX__=16777215%s", INT_TYPE_SIZE == 8 ? "ULL" : "UL"); }
void avr_cpu_cpp_builtins (struct cpp_reader *pfile) { int i; builtin_define_std ("AVR"); if (avr_current_arch->macro) cpp_define_formatted (pfile, "__AVR_ARCH__=%s", avr_current_arch->macro); if (avr_current_device->macro) { cpp_define (pfile, avr_current_device->macro); cpp_define_formatted (pfile, "__AVR_DEVICE_NAME__=%s", avr_current_device->name); } if (AVR_HAVE_RAMPD) cpp_define (pfile, "__AVR_HAVE_RAMPD__"); if (AVR_HAVE_RAMPX) cpp_define (pfile, "__AVR_HAVE_RAMPX__"); if (AVR_HAVE_RAMPY) cpp_define (pfile, "__AVR_HAVE_RAMPY__"); if (AVR_HAVE_RAMPZ) cpp_define (pfile, "__AVR_HAVE_RAMPZ__"); if (AVR_HAVE_ELPM) cpp_define (pfile, "__AVR_HAVE_ELPM__"); if (AVR_HAVE_ELPMX) cpp_define (pfile, "__AVR_HAVE_ELPMX__"); if (AVR_HAVE_MOVW) cpp_define (pfile, "__AVR_HAVE_MOVW__"); if (AVR_HAVE_LPMX) cpp_define (pfile, "__AVR_HAVE_LPMX__"); if (avr_current_arch->asm_only) cpp_define (pfile, "__AVR_ASM_ONLY__"); if (AVR_HAVE_MUL) { cpp_define (pfile, "__AVR_ENHANCED__"); cpp_define (pfile, "__AVR_HAVE_MUL__"); } if (avr_current_arch->have_jmp_call) { cpp_define (pfile, "__AVR_MEGA__"); cpp_define (pfile, "__AVR_HAVE_JMP_CALL__"); } if (AVR_XMEGA) cpp_define (pfile, "__AVR_XMEGA__"); if (avr_current_arch->have_eijmp_eicall) { cpp_define (pfile, "__AVR_HAVE_EIJMP_EICALL__"); cpp_define (pfile, "__AVR_3_BYTE_PC__"); } else { cpp_define (pfile, "__AVR_2_BYTE_PC__"); } if (AVR_HAVE_8BIT_SP) cpp_define (pfile, "__AVR_HAVE_8BIT_SP__"); else cpp_define (pfile, "__AVR_HAVE_16BIT_SP__"); if (avr_sp8) cpp_define (pfile, "__AVR_SP8__"); if (AVR_HAVE_SPH) cpp_define (pfile, "__AVR_HAVE_SPH__"); if (TARGET_NO_INTERRUPTS) cpp_define (pfile, "__NO_INTERRUPTS__"); if (avr_current_device->dev_attribute & AVR_ERRATA_SKIP) { cpp_define (pfile, "__AVR_ERRATA_SKIP__"); if (avr_current_arch->have_jmp_call) cpp_define (pfile, "__AVR_ERRATA_SKIP_JMP_CALL__"); } if (avr_current_device->dev_attribute & AVR_ISA_RMW) cpp_define (pfile, "__AVR_ISA_RMW__"); cpp_define_formatted (pfile, "__AVR_SFR_OFFSET__=0x%x", avr_current_arch->sfr_offset); #ifdef WITH_AVRLIBC cpp_define (pfile, "__WITH_AVRLIBC__"); #endif /* WITH_AVRLIBC */ /* Define builtin macros so that the user can easily query whether non-generic address spaces (and which) are supported or not. This is only supported for C. For C++, a language extension is needed (as mentioned in ISO/IEC DTR 18037; Annex F.2) which is not implemented in GCC up to now. */ if (!strcmp (lang_hooks.name, "GNU C")) { for (i = 0; i < ADDR_SPACE_COUNT; i++) if (!ADDR_SPACE_GENERIC_P (i) /* Only supply __FLASH<n> macro if the address space is reasonable for this target. The address space qualifier itself is still supported, but using it will throw an error. */ && avr_addrspace[i].segment < avr_current_device->n_flash) { const char *name = avr_addrspace[i].name; char *Name = (char*) alloca (1 + strlen (name)); cpp_define (pfile, avr_toupper (Name, name)); } } /* Define builtin macros so that the user can easily query whether or not a specific builtin is available. */ #define DEF_BUILTIN(NAME, N_ARGS, TYPE, CODE, LIBNAME) \ cpp_define (pfile, "__BUILTIN_AVR_" #NAME); #include "builtins.def" #undef DEF_BUILTIN /* Builtin macros for the __int24 and __uint24 type. */ cpp_define_formatted (pfile, "__INT24_MAX__=8388607%s", INT_TYPE_SIZE == 8 ? "LL" : "L"); cpp_define (pfile, "__INT24_MIN__=(-__INT24_MAX__-1)"); cpp_define_formatted (pfile, "__UINT24_MAX__=16777215%s", INT_TYPE_SIZE == 8 ? "ULL" : "UL"); }
void avr_cpu_cpp_builtins (struct cpp_reader *pfile) { builtin_define_std ("AVR"); if (avr_current_arch->macro) cpp_define (pfile, avr_current_arch->macro); if (avr_extra_arch_macro) cpp_define (pfile, avr_extra_arch_macro); if (avr_current_arch->have_elpm) cpp_define (pfile, "__AVR_HAVE_RAMPZ__"); if (avr_current_arch->have_elpm) cpp_define (pfile, "__AVR_HAVE_ELPM__"); if (avr_current_arch->have_elpmx) cpp_define (pfile, "__AVR_HAVE_ELPMX__"); if (avr_current_arch->have_movw_lpmx) { cpp_define (pfile, "__AVR_HAVE_MOVW__"); cpp_define (pfile, "__AVR_HAVE_LPMX__"); } if (avr_current_arch->asm_only) cpp_define (pfile, "__AVR_ASM_ONLY__"); if (avr_current_arch->have_mul) { cpp_define (pfile, "__AVR_ENHANCED__"); cpp_define (pfile, "__AVR_HAVE_MUL__"); } if (avr_current_arch->have_jmp_call) { cpp_define (pfile, "__AVR_MEGA__"); cpp_define (pfile, "__AVR_HAVE_JMP_CALL__"); } if (avr_current_arch->have_eijmp_eicall) { cpp_define (pfile, "__AVR_HAVE_EIJMP_EICALL__"); cpp_define (pfile, "__AVR_3_BYTE_PC__"); } else { cpp_define (pfile, "__AVR_2_BYTE_PC__"); } if (avr_current_device->short_sp) cpp_define (pfile, "__AVR_HAVE_8BIT_SP__"); else cpp_define (pfile, "__AVR_HAVE_16BIT_SP__"); if (TARGET_NO_INTERRUPTS) cpp_define (pfile, "__NO_INTERRUPTS__"); if (avr_current_device->errata_skip) { cpp_define (pfile, "__AVR_ERRATA_SKIP__"); if (avr_current_arch->have_jmp_call) cpp_define (pfile, "__AVR_ERRATA_SKIP_JMP_CALL__"); } cpp_define_formatted (pfile, "__AVR_SFR_OFFSET__=0x%x", avr_current_arch->sfr_offset); /* Define builtin macros so that the user can easily query if or if not non-generic address spaces (and which) are supported. This is only supported for C. For C++, a language extension is needed (as mentioned in ISO/IEC DTR 18037; Annex F.2) which is not implemented in GCC up to now. */ if (!strcmp (lang_hooks.name, "GNU C")) { int i; for (i = 0; avr_addrspace[i].name; i++) if (!ADDR_SPACE_GENERIC_P (i)) { const char *name = avr_addrspace[i].name; char *Name = (char*) alloca (1 + strlen (name)); cpp_define_formatted (pfile, "%s=%s", avr_toupper (Name, name), name); } } /* Define builtin macros so that the user can easily query if or if not a specific builtin is available. */ cpp_define (pfile, "__BUILTIN_AVR_NOP"); cpp_define (pfile, "__BUILTIN_AVR_SEI"); cpp_define (pfile, "__BUILTIN_AVR_CLI"); cpp_define (pfile, "__BUILTIN_AVR_WDR"); cpp_define (pfile, "__BUILTIN_AVR_SLEEP"); cpp_define (pfile, "__BUILTIN_AVR_SWAP"); cpp_define (pfile, "__BUILTIN_AVR_MAP8"); cpp_define (pfile, "__BUILTIN_AVR_MAP16"); cpp_define (pfile, "__BUILTIN_AVR_DELAY_CYCLES"); cpp_define (pfile, "__BUILTIN_AVR_FMUL"); cpp_define (pfile, "__BUILTIN_AVR_FMULS"); cpp_define (pfile, "__BUILTIN_AVR_FMULSU"); cpp_define (pfile, "__INT24_MAX__=8388607L"); cpp_define (pfile, "__INT24_MIN__=(-__INT24_MAX__-1)"); cpp_define (pfile, "__UINT24_MAX__=16777215UL"); }