void
spu_cpu_cpp_builtins (struct cpp_reader *pfile)
{
builtin_define_std ("__SPU__");
cpp_assert (pfile, "cpu=spu");
cpp_assert (pfile, "machine=spu");
if (spu_arch == PROCESSOR_CELLEDP)
builtin_define_std ("__SPU_EDP__");
builtin_define_std ("__vector=__attribute__((__spu_vector__))");
if (!flag_iso)
{
/* Define this when supporting context-sensitive keywords. */
cpp_define (pfile, "__VECTOR_KEYWORD_SUPPORTED__");
cpp_define (pfile, "vector=vector");
/* Initialize vector keywords. */
__vector_keyword = get_identifier ("__vector");
C_CPP_HASHNODE (__vector_keyword)->flags |= NODE_CONDITIONAL;
vector_keyword = get_identifier ("vector");
C_CPP_HASHNODE (vector_keyword)->flags |= NODE_CONDITIONAL;
/* Enable context-sensitive macros. */
cpp_get_callbacks (pfile)->macro_to_expand = spu_macro_to_expand;
}
}
void
spu_cpu_cpp_builtins (struct cpp_reader *pfile)
{
builtin_define_std ("__SPU__");
cpp_assert (pfile, "cpu=spu");
cpp_assert (pfile, "machine=spu");
if (spu_arch == PROCESSOR_CELLEDP)
builtin_define_std ("__SPU_EDP__");
builtin_define_std ("__vector=__attribute__((__spu_vector__))");
}
void
ix86_target_macros (void)
{
/* 32/64-bit won't change with target specific options, so do the assert and
builtin_define_std calls here. */
if (TARGET_64BIT)
{
cpp_assert (parse_in, "cpu=x86_64");
cpp_assert (parse_in, "machine=x86_64");
cpp_define (parse_in, "__amd64");
cpp_define (parse_in, "__amd64__");
cpp_define (parse_in, "__x86_64");
cpp_define (parse_in, "__x86_64__");
}
else
{
cpp_assert (parse_in, "cpu=i386");
cpp_assert (parse_in, "machine=i386");
builtin_define_std ("i386");
}
ix86_target_macros_internal (ix86_isa_flags,
ix86_arch,
ix86_tune,
ix86_fpmath,
cpp_define);
}
void
sparc_target_macros (void)
{
builtin_define_std ("sparc");
if (TARGET_64BIT)
{
cpp_assert (parse_in, "cpu=sparc64");
cpp_assert (parse_in, "machine=sparc64");
}
else
{
cpp_assert (parse_in, "cpu=sparc");
cpp_assert (parse_in, "machine=sparc");
}
if (TARGET_VIS3)
{
cpp_define (parse_in, "__VIS__=0x300");
cpp_define (parse_in, "__VIS=0x300");
}
else if (TARGET_VIS2)
{
cpp_define (parse_in, "__VIS__=0x200");
cpp_define (parse_in, "__VIS=0x200");
}
else if (TARGET_VIS)
{
cpp_define (parse_in, "__VIS__=0x100");
cpp_define (parse_in, "__VIS=0x100");
}
}
void
ix86_target_macros (void)
{
/* 32/64-bit won't change with target specific options, so do the assert and
builtin_define_std calls here. */
if (TARGET_64BIT)
{
cpp_assert (parse_in, "cpu=x86_64");
cpp_assert (parse_in, "machine=x86_64");
cpp_define (parse_in, "__amd64");
cpp_define (parse_in, "__amd64__");
cpp_define (parse_in, "__x86_64");
cpp_define (parse_in, "__x86_64__");
if (TARGET_X32)
{
cpp_define (parse_in, "_ILP32");
cpp_define (parse_in, "__ILP32__");
}
}
else
{
cpp_assert (parse_in, "cpu=i386");
cpp_assert (parse_in, "machine=i386");
builtin_define_std ("i386");
}
cpp_define_formatted (parse_in, "__ATOMIC_HLE_ACQUIRE=%d", IX86_HLE_ACQUIRE);
cpp_define_formatted (parse_in, "__ATOMIC_HLE_RELEASE=%d", IX86_HLE_RELEASE);
ix86_target_macros_internal (ix86_isa_flags,
ix86_arch,
ix86_tune,
ix86_fpmath,
cpp_define);
}
void
ix86_target_macros (void)
{
/* 32/64-bit won't change with target specific options, so do the assert and
builtin_define_std calls here. */
if (TARGET_64BIT)
{
cpp_assert (parse_in, "cpu=x86_64");
cpp_assert (parse_in, "machine=x86_64");
cpp_define (parse_in, "__amd64");
cpp_define (parse_in, "__amd64__");
cpp_define (parse_in, "__x86_64");
cpp_define (parse_in, "__x86_64__");
if (TARGET_X32)
{
cpp_define (parse_in, "_ILP32");
cpp_define (parse_in, "__ILP32__");
}
}
else
{
cpp_assert (parse_in, "cpu=i386");
cpp_assert (parse_in, "machine=i386");
builtin_define_std ("i386");
}
if (!TARGET_80387)
cpp_define (parse_in, "_SOFT_FLOAT");
if (TARGET_LONG_DOUBLE_64)
cpp_define (parse_in, "__LONG_DOUBLE_64__");
if (TARGET_LONG_DOUBLE_128)
cpp_define (parse_in, "__LONG_DOUBLE_128__");
if (TARGET_128BIT_LONG_DOUBLE)
cpp_define (parse_in, "__SIZEOF_FLOAT80__=16");
else
cpp_define (parse_in, "__SIZEOF_FLOAT80__=12");
cpp_define (parse_in, "__SIZEOF_FLOAT128__=16");
cpp_define_formatted (parse_in, "__ATOMIC_HLE_ACQUIRE=%d", IX86_HLE_ACQUIRE);
cpp_define_formatted (parse_in, "__ATOMIC_HLE_RELEASE=%d", IX86_HLE_RELEASE);
cpp_define (parse_in, "__GCC_ASM_FLAG_OUTPUTS__");
ix86_target_macros_internal (ix86_isa_flags,
ix86_isa_flags2,
ix86_arch,
ix86_tune,
ix86_fpmath,
cpp_define);
cpp_define (parse_in, "__SEG_FS");
cpp_define (parse_in, "__SEG_GS");
}
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__");
}
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)
{
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)
{
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"))
{
cpp_define (pfile, "__PGM=__pgm");
cpp_define (pfile, "__PGM1=__pgm1");
cpp_define (pfile, "__PGM2=__pgm2");
cpp_define (pfile, "__PGM3=__pgm3");
cpp_define (pfile, "__PGM4=__pgm4");
cpp_define (pfile, "__PGM5=__pgm5");
cpp_define (pfile, "__PGMX=__pgmx");
}
/* 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");
}
