#define DEFAULT_TARGET_ARCH "ppc"
#define OBJECT_XCOFF 1
#define OBJECT_ELF 2
#define OBJECT_PEF 3
#define OBJECT_MACHO 4
#define TARGET_ELF (TARGET_OBJECT_FORMAT == OBJECT_ELF)
#define TARGET_XCOFF (TARGET_OBJECT_FORMAT == OBJECT_XCOFF)
#define TARGET_MACOS (TARGET_OBJECT_FORMAT == OBJECT_PEF)
#define TARGET_MACHO (TARGET_OBJECT_FORMAT == OBJECT_MACHO)
#ifndef TARGET_AIX
#define TARGET_AIX 0
#endif
#ifndef TARGET_CPU_DEFAULT
#define TARGET_CPU_DEFAULT ((char *)0)
#endif
#define CPP_CPU_SPEC \
"%{!mcpu*: \
%{mpower: %{!mpower2: -D_ARCH_PWR}} \
%{mpower2: -D_ARCH_PWR2} \
%{mpowerpc*: -D_ARCH_PPC} \
%{mno-power: %{!mpowerpc*: -D_ARCH_COM}} \
%{!mno-power: %{!mpower2: %(cpp_default)}}} \
%{mcpu=common: -D_ARCH_COM} \
%{mcpu=power: -D_ARCH_PWR} \
%{mcpu=power2: -D_ARCH_PWR2} \
%{mcpu=powerpc: -D_ARCH_PPC} \
%{mcpu=rios: -D_ARCH_PWR} \
%{mcpu=rios1: -D_ARCH_PWR} \
%{mcpu=rios2: -D_ARCH_PWR2} \
%{mcpu=rsc: -D_ARCH_PWR} \
%{mcpu=rsc1: -D_ARCH_PWR} \
%{mcpu=401: -D_ARCH_PPC} \
%{mcpu=403: -D_ARCH_PPC} \
%{mcpu=405: -D_ARCH_PPC} \
%{mcpu=505: -D_ARCH_PPC} \
%{mcpu=601: -D_ARCH_PPC -D_ARCH_PWR} \
%{mcpu=602: -D_ARCH_PPC} \
%{mcpu=603: -D_ARCH_PPC} \
%{mcpu=603e: -D_ARCH_PPC} \
%{mcpu=ec603e: -D_ARCH_PPC} \
%{mcpu=604: -D_ARCH_PPC} \
%{mcpu=604e: -D_ARCH_PPC} \
%{mcpu=620: -D_ARCH_PPC} \
%{mcpu=740: -D_ARCH_PPC} \
%{mcpu=7400: -D_ARCH_PPC} \
%{mcpu=7450: -D_ARCH_PPC} \
%{mcpu=750: -D_ARCH_PPC} \
%{mcpu=801: -D_ARCH_PPC} \
%{mcpu=821: -D_ARCH_PPC} \
%{mcpu=823: -D_ARCH_PPC} \
%{mcpu=860: -D_ARCH_PPC} \
%{maltivec: -D__ALTIVEC__}"
#define ASM_CPU_SPEC \
"%{!mcpu*: \
%{mpower: %{!mpower2: -mpwr}} \
%{mpower2: -mpwrx} \
%{mpowerpc*: -mppc} \
%{mno-power: %{!mpowerpc*: -mcom}} \
%{!mno-power: %{!mpower2: %(asm_default)}}} \
%{mcpu=common: -mcom} \
%{mcpu=power: -mpwr} \
%{mcpu=power2: -mpwrx} \
%{mcpu=powerpc: -mppc} \
%{mcpu=rios: -mpwr} \
%{mcpu=rios1: -mpwr} \
%{mcpu=rios2: -mpwrx} \
%{mcpu=rsc: -mpwr} \
%{mcpu=rsc1: -mpwr} \
%{mcpu=401: -mppc} \
%{mcpu=403: -mppc} \
%{mcpu=405: -mppc} \
%{mcpu=505: -mppc} \
%{mcpu=601: -m601} \
%{mcpu=602: -mppc} \
%{mcpu=603: -mppc} \
%{mcpu=603e: -mppc} \
%{mcpu=ec603e: -mppc} \
%{mcpu=604: -mppc} \
%{mcpu=604e: -mppc} \
%{mcpu=620: -mppc} \
%{mcpu=740: -mppc} \
%{mcpu=7400: -mppc} \
%{mcpu=7450: -mppc} \
%{mcpu=750: -mppc} \
%{mcpu=801: -mppc} \
%{mcpu=821: -mppc} \
%{mcpu=823: -mppc} \
%{mcpu=860: -mppc} \
%{maltivec: -maltivec}"
#define CPP_DEFAULT_SPEC ""
#define ASM_DEFAULT_SPEC ""
#define SUBTARGET_EXTRA_SPECS
#define EXTRA_SPECS \
{ "cpp_cpu", CPP_CPU_SPEC }, \
{ "cpp_default", CPP_DEFAULT_SPEC }, \
{ "asm_cpu", ASM_CPU_SPEC }, \
{ "asm_default", ASM_DEFAULT_SPEC }, \
SUBTARGET_EXTRA_SPECS
extern int target_flags;
#define MASK_POWER 0x00000001
#define MASK_POWER2 0x00000002
#define MASK_POWERPC 0x00000004
#define MASK_PPC_GPOPT 0x00000008
#define MASK_PPC_GFXOPT 0x00000010
#define MASK_POWERPC64 0x00000020
#define MASK_NEW_MNEMONICS 0x00000040
#define MASK_NO_FP_IN_TOC 0x00000080
#define MASK_NO_SUM_IN_TOC 0x00000100
#define MASK_MINIMAL_TOC 0x00000200
#define MASK_64BIT 0x00000400
#define MASK_SOFT_FLOAT 0x00000800
#define MASK_MULTIPLE 0x00001000
#define MASK_MULTIPLE_SET 0x00002000
#define MASK_STRING 0x00004000
#define MASK_STRING_SET 0x00008000
#define MASK_NO_UPDATE 0x00010000
#define MASK_NO_FUSED_MADD 0x00020000
#define MASK_SCHED_PROLOG 0x00040000
#define MASK_ALTIVEC 0x00080000
#define MASK_ALTIVEC_ABI 0x00100000
#define MASK_LONG_DOUBLE_128 0x00200000
#define MASK_AIX_STRUCT_RET 0x00100000
#define MASK_AIX_STRUCT_RET_SET 0x00200000
#define MASK_NO_VRSAVE 0x00400000
#define MASK_MACHO_DYNAMIC_NO_PIC 0x00800000
#define MASK_LONG_BRANCH 0x02000000
#define TARGET_POWER (target_flags & MASK_POWER)
#define TARGET_POWER2 (target_flags & MASK_POWER2)
#define TARGET_POWERPC (target_flags & MASK_POWERPC)
#define TARGET_PPC_GPOPT (target_flags & MASK_PPC_GPOPT)
#define TARGET_PPC_GFXOPT (target_flags & MASK_PPC_GFXOPT)
#define TARGET_NEW_MNEMONICS (target_flags & MASK_NEW_MNEMONICS)
#define TARGET_NO_FP_IN_TOC (target_flags & MASK_NO_FP_IN_TOC)
#define TARGET_NO_SUM_IN_TOC (target_flags & MASK_NO_SUM_IN_TOC)
#define TARGET_MINIMAL_TOC (target_flags & MASK_MINIMAL_TOC)
#define TARGET_64BIT (target_flags & MASK_64BIT)
#define TARGET_SOFT_FLOAT (target_flags & MASK_SOFT_FLOAT)
#define TARGET_MULTIPLE (target_flags & MASK_MULTIPLE)
#define TARGET_MULTIPLE_SET (target_flags & MASK_MULTIPLE_SET)
#define TARGET_STRING (target_flags & MASK_STRING)
#define TARGET_STRING_SET (target_flags & MASK_STRING_SET)
#define TARGET_NO_UPDATE (target_flags & MASK_NO_UPDATE)
#define TARGET_NO_FUSED_MADD (target_flags & MASK_NO_FUSED_MADD)
#define TARGET_SCHED_PROLOG (target_flags & MASK_SCHED_PROLOG)
#define TARGET_ALTIVEC (target_flags & MASK_ALTIVEC)
#define TARGET_AIX_STRUCT_RET (target_flags & MASK_AIX_STRUCT_RET)
#define TARGET_NO_VRSAVE (target_flags & MASK_NO_VRSAVE)
#define TARGET_DYNAMIC_NO_PIC (target_flags & MASK_MACHO_DYNAMIC_NO_PIC)
#define TARGET_LONG_BRANCH (target_flags & MASK_LONG_BRANCH)
#define TARGET_32BIT (! TARGET_64BIT)
#define TARGET_HARD_FLOAT (! TARGET_SOFT_FLOAT)
#define TARGET_UPDATE (! TARGET_NO_UPDATE)
#define TARGET_FUSED_MADD (! TARGET_NO_FUSED_MADD)
#define TARGET_VRSAVE (! TARGET_NO_VRSAVE)
#ifdef IN_LIBGCC2
#if defined (__64BIT__) || defined (__powerpc64__)
#define TARGET_POWERPC64 1
#else
#define TARGET_POWERPC64 0
#endif
#else
#define TARGET_POWERPC64 (target_flags & MASK_POWERPC64)
#endif
#define TARGET_XL_CALL 0
#define TARGET_SWITCHES \
{{"power", MASK_POWER | MASK_MULTIPLE | MASK_STRING, \
N_("Use POWER instruction set")}, \
{"power2", (MASK_POWER | MASK_MULTIPLE | MASK_STRING \
| MASK_POWER2), \
N_("Use POWER2 instruction set")}, \
{"no-power2", - MASK_POWER2, \
N_("Do not use POWER2 instruction set")}, \
{"no-power", - (MASK_POWER | MASK_POWER2 | MASK_MULTIPLE \
| MASK_STRING), \
N_("Do not use POWER instruction set")}, \
{"powerpc", MASK_POWERPC, \
N_("Use PowerPC instruction set")}, \
{"no-powerpc", - (MASK_POWERPC | MASK_PPC_GPOPT \
| MASK_PPC_GFXOPT | MASK_POWERPC64), \
N_("Do not use PowerPC instruction set")}, \
{"powerpc-gpopt", MASK_POWERPC | MASK_PPC_GPOPT, \
N_("Use PowerPC General Purpose group optional instructions")},\
{"no-powerpc-gpopt", - MASK_PPC_GPOPT, \
N_("Don't use PowerPC General Purpose group optional instructions")},\
{"powerpc-gfxopt", MASK_POWERPC | MASK_PPC_GFXOPT, \
N_("Use PowerPC Graphics group optional instructions")},\
{"no-powerpc-gfxopt", - MASK_PPC_GFXOPT, \
N_("Don't use PowerPC Graphics group optional instructions")},\
{"powerpc64", MASK_POWERPC64, \
N_("Use PowerPC-64 instruction set")}, \
{"no-powerpc64", - MASK_POWERPC64, \
N_("Don't use PowerPC-64 instruction set")}, \
{"altivec", MASK_ALTIVEC , \
N_("Use AltiVec instructions")}, \
{"no-altivec", - MASK_ALTIVEC , \
N_("Don't use AltiVec instructions")}, \
{"new-mnemonics", MASK_NEW_MNEMONICS, \
N_("Use new mnemonics for PowerPC architecture")},\
{"old-mnemonics", -MASK_NEW_MNEMONICS, \
N_("Use old mnemonics for PowerPC architecture")},\
{"full-toc", - (MASK_NO_FP_IN_TOC | MASK_NO_SUM_IN_TOC \
| MASK_MINIMAL_TOC), \
N_("Put everything in the regular TOC")}, \
{"fp-in-toc", - MASK_NO_FP_IN_TOC, \
N_("Place floating point constants in TOC")}, \
{"no-fp-in-toc", MASK_NO_FP_IN_TOC, \
N_("Don't place floating point constants in TOC")},\
{"sum-in-toc", - MASK_NO_SUM_IN_TOC, \
N_("Place symbol+offset constants in TOC")}, \
{"no-sum-in-toc", MASK_NO_SUM_IN_TOC, \
N_("Don't place symbol+offset constants in TOC")},\
{"minimal-toc", MASK_MINIMAL_TOC, \
"Use only one TOC entry per procedure"}, \
{"minimal-toc", - (MASK_NO_FP_IN_TOC | MASK_NO_SUM_IN_TOC), \
""}, \
{"no-minimal-toc", - MASK_MINIMAL_TOC, \
N_("Place variable addresses in the regular TOC")},\
{"hard-float", - MASK_SOFT_FLOAT, \
N_("Use hardware fp")}, \
{"soft-float", MASK_SOFT_FLOAT, \
N_("Do not use hardware fp")}, \
{"multiple", MASK_MULTIPLE | MASK_MULTIPLE_SET, \
N_("Generate load/store multiple instructions")}, \
{"no-multiple", - MASK_MULTIPLE, \
N_("Do not generate load/store multiple instructions")},\
{"no-multiple", MASK_MULTIPLE_SET, \
""}, \
{"string", MASK_STRING | MASK_STRING_SET, \
N_("Generate string instructions for block moves")},\
{"no-string", - MASK_STRING, \
N_("Do not generate string instructions for block moves")},\
{"no-string", MASK_STRING_SET, \
""}, \
{"update", - MASK_NO_UPDATE, \
N_("Generate load/store with update instructions")},\
{"no-update", MASK_NO_UPDATE, \
N_("Do not generate load/store with update instructions")},\
{"fused-madd", - MASK_NO_FUSED_MADD, \
N_("Generate fused multiply/add instructions")},\
{"no-fused-madd", MASK_NO_FUSED_MADD, \
N_("Don't generate fused multiply/add instructions")},\
{"sched-prolog", MASK_SCHED_PROLOG, \
""}, \
{"no-sched-prolog", -MASK_SCHED_PROLOG, \
N_("Don't schedule the start and end of the procedure")},\
{"sched-epilog", MASK_SCHED_PROLOG, \
""}, \
{"no-sched-epilog", -MASK_SCHED_PROLOG, \
""}, \
{"aix-struct-return", MASK_AIX_STRUCT_RET | MASK_AIX_STRUCT_RET_SET, \
N_("Return all structures in memory (AIX default)")},\
{"svr4-struct-return", - MASK_AIX_STRUCT_RET,\
N_("Return small structures in registers (SVR4 default)")},\
{"svr4-struct-return",MASK_AIX_STRUCT_RET_SET,\
""},\
{"no-aix-struct-return", - MASK_AIX_STRUCT_RET,\
""},\
{"no-aix-struct-return", MASK_AIX_STRUCT_RET_SET,\
""},\
{"no-svr4-struct-return", MASK_AIX_STRUCT_RET | MASK_AIX_STRUCT_RET_SET,\
""},\
\
{"vrsave", - MASK_NO_VRSAVE, ""}, \
{"no-vrsave", MASK_NO_VRSAVE, ""}, \
\
{"dynamic-no-pic", MASK_MACHO_DYNAMIC_NO_PIC, \
N_("Generate code suitable for executables (NOT shared libs)")},\
{"no-dynamic-no-pic", -MASK_MACHO_DYNAMIC_NO_PIC, ""}, \
\
{"long-branch", MASK_LONG_BRANCH, \
N_("Generate 32-bit call addresses (range > 64M)")}, \
{"no-long-branch", -MASK_LONG_BRANCH, ""}, \
SUBTARGET_SWITCHES \
{"", TARGET_DEFAULT | MASK_SCHED_PROLOG, \
""}}
#define TARGET_DEFAULT (MASK_POWER | MASK_MULTIPLE | MASK_STRING)
#define SUBTARGET_SWITCHES
enum processor_type
{
PROCESSOR_RIOS1,
PROCESSOR_RIOS2,
PROCESSOR_RS64A,
PROCESSOR_MPCCORE,
PROCESSOR_PPC403,
PROCESSOR_PPC405,
PROCESSOR_PPC601,
PROCESSOR_PPC603,
PROCESSOR_PPC604,
PROCESSOR_PPC604e,
PROCESSOR_PPC620,
PROCESSOR_PPC630,
PROCESSOR_PPC750,
PROCESSOR_PPC7400,
PROCESSOR_PPC7450
};
extern enum processor_type rs6000_cpu;
#define rs6000_cpu_attr ((enum attr_cpu)rs6000_cpu)
#define PROCESSOR_COMMON PROCESSOR_PPC601
#define PROCESSOR_POWER PROCESSOR_RIOS1
#define PROCESSOR_POWERPC PROCESSOR_PPC604
#define PROCESSOR_POWERPC64 PROCESSOR_RS64A
#define PROCESSOR_DEFAULT PROCESSOR_RIOS1
#define PROCESSOR_DEFAULT64 PROCESSOR_RS64A
#define ASSEMBLER_DIALECT (TARGET_NEW_MNEMONICS ? 1 : 0)
#define SUBTARGET_OPTIONS
#define TARGET_OPTIONS \
{ \
{"cpu=", &rs6000_select[1].string, \
N_("Use features of and schedule code for given CPU") }, \
{"tune=", &rs6000_select[2].string, \
N_("Schedule code for given CPU") }, \
{"debug=", &rs6000_debug_name, N_("Enable debug output") }, \
{"abi=", &rs6000_abi_string, N_("Specify ABI to use") }, \
{"long-double-", &rs6000_long_double_size_string, \
N_("Specify size of long double (64 or 128 bits)") }, \
SUBTARGET_OPTIONS \
}
struct rs6000_cpu_select
{
const char *string;
const char *name;
int set_tune_p;
int set_arch_p;
};
extern struct rs6000_cpu_select rs6000_select[];
extern const char *rs6000_debug_name;
extern const char *rs6000_abi_string;
extern int rs6000_debug_stack;
extern int rs6000_debug_arg;
#define TARGET_DEBUG_STACK rs6000_debug_stack
#define TARGET_DEBUG_ARG rs6000_debug_arg
extern const char *rs6000_long_double_size_string;
extern int rs6000_long_double_type_size;
extern int rs6000_altivec_abi;
#define TARGET_LONG_DOUBLE_128 (rs6000_long_double_type_size == 128)
#define TARGET_ALTIVEC_ABI rs6000_altivec_abi
#define OVERRIDE_OPTIONS rs6000_override_options (TARGET_CPU_DEFAULT)
#define OPTIMIZATION_OPTIONS(LEVEL,SIZE) optimization_options(LEVEL,SIZE)
#define CAN_DEBUG_WITHOUT_FP
#define REAL_ARITHMETIC
#define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE) \
if (GET_MODE_CLASS (MODE) == MODE_INT \
&& GET_MODE_SIZE (MODE) < UNITS_PER_WORD) \
(MODE) = word_mode;
#define PROMOTE_FUNCTION_ARGS
#define PROMOTE_FUNCTION_RETURN
#define BITS_BIG_ENDIAN 1
#define BYTES_BIG_ENDIAN 1
#define WORDS_BIG_ENDIAN 1
#define BITS_PER_UNIT 8
#define BITS_PER_WORD (! TARGET_POWERPC64 ? 32 : 64)
#define MAX_BITS_PER_WORD 64
#define UNITS_PER_WORD (! TARGET_POWERPC64 ? 4 : 8)
#define MIN_UNITS_PER_WORD 4
#define UNITS_PER_FP_WORD 8
#define UNITS_PER_ALTIVEC_WORD 16
#define PTRDIFF_TYPE "int"
#define SIZE_TYPE "long unsigned int"
#define WCHAR_TYPE "short unsigned int"
#define WCHAR_TYPE_SIZE 16
#define SHORT_TYPE_SIZE 16
#define INT_TYPE_SIZE 32
#define LONG_TYPE_SIZE (TARGET_32BIT ? 32 : 64)
#define MAX_LONG_TYPE_SIZE 64
#define LONG_LONG_TYPE_SIZE 64
#define CHAR_TYPE_SIZE BITS_PER_UNIT
#define FLOAT_TYPE_SIZE 32
#define DOUBLE_TYPE_SIZE 64
#define LONG_DOUBLE_TYPE_SIZE rs6000_long_double_type_size
#define MAX_LONG_DOUBLE_TYPE_SIZE 128
#ifdef __LONG_DOUBLE_128__
#define LIBGCC2_LONG_DOUBLE_TYPE_SIZE 128
#else
#define LIBGCC2_LONG_DOUBLE_TYPE_SIZE 64
#endif
#define WIDEST_HARDWARE_FP_SIZE 64
#define POINTER_SIZE (TARGET_32BIT ? 32 : 64)
#define PARM_BOUNDARY (TARGET_32BIT ? 32 : 64)
#define STACK_BOUNDARY ((TARGET_32BIT && !TARGET_ALTIVEC_ABI) ? 64 : 128)
#define FUNCTION_BOUNDARY 32
#define RS6000_DOUBLE_ALIGNMENT 64
#define RS6000_LONGLONG_ALIGNMENT 64
#define RS6000_VECTOR_ALIGNMENT 128
#define BIGGEST_ALIGNMENT 128
#define LOCAL_ALIGNMENT(TYPE, ALIGN) \
((TARGET_ALTIVEC && TREE_CODE (TYPE) == VECTOR_TYPE) ? 128 : ALIGN)
#define EMPTY_FIELD_BOUNDARY 32
#define STRUCTURE_SIZE_BOUNDARY 8
#define PCC_BITFIELD_TYPE_MATTERS 1
#define CONSTANT_ALIGNMENT(EXP, ALIGN) \
(TREE_CODE (EXP) == STRING_CST \
&& (ALIGN) < BITS_PER_WORD \
? BITS_PER_WORD \
: (ALIGN))
#define DATA_ALIGNMENT(TYPE, ALIGN) \
(TREE_CODE (TYPE) == VECTOR_TYPE ? 128 \
: TREE_CODE (TYPE) == ARRAY_TYPE \
&& TYPE_MODE (TREE_TYPE (TYPE)) == QImode \
&& (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
#define STRICT_ALIGNMENT 0
#define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) \
(STRICT_ALIGNMENT \
|| (((MODE) == SFmode || (MODE) == DFmode || (MODE) == DImode) \
&& (ALIGN) < 32))
#define FIRST_PSEUDO_REGISTER 110
#define PRE_GCC3_DWARF_FRAME_REGISTERS 77
#define FIXED_REGISTERS \
{0, 1, FIXED_R2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, FIXED_R13, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, \
\
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
1 \
}
#define CALL_USED_REGISTERS \
{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, FIXED_R13, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, \
\
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
1 \
}
#define CALL_REALLY_USED_REGISTERS \
{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, FIXED_R13, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, \
\
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
0 \
}
#define MQ_REGNO 64
#define CR0_REGNO 68
#define CR1_REGNO 69
#define CR2_REGNO 70
#define CR3_REGNO 71
#define CR4_REGNO 72
#define MAX_CR_REGNO 75
#define XER_REGNO 76
#define FIRST_ALTIVEC_REGNO 77
#define FIRST_SAVED_ALTIVEC_REGNO 97
#define LAST_ALTIVEC_REGNO 108
#define TOTAL_ALTIVEC_REGS (LAST_ALTIVEC_REGNO - FIRST_ALTIVEC_REGNO + 1)
#define VRSAVE_REGNO 109
#define REG_ALLOC_ORDER \
{32, \
45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, \
33, \
63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, \
50, 49, 48, 47, 46, \
75, 74, 69, 68, 72, 71, 70, \
0, \
9, 11, 10, 8, 7, 6, 5, 4, \
3, \
31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, \
18, 17, 16, 15, 14, 13, 12, \
64, 66, 65, \
73, 1, 2, 67, 76, \
\
77, 78, \
90, 89, 88, 87, 86, 85, 84, 83, 82, 81, 80, \
79, \
96, 95, 94, 93, 92, 91, \
108, 107, 106, 105, 104, 103, 102, 101, 100, 99, 98, \
97, 109 \
}
#define FP_REGNO_P(N) ((N) >= 32 && (N) <= 63)
#define CR_REGNO_P(N) ((N) >= 68 && (N) <= 75)
#define CR_REGNO_NOT_CR0_P(N) ((N) >= 69 && (N) <= 75)
#define INT_REGNO_P(N) ((N) <= 31 || (N) == ARG_POINTER_REGNUM)
#define XER_REGNO_P(N) ((N) == XER_REGNO)
#define ALTIVEC_REGNO_P(N) ((N) >= FIRST_ALTIVEC_REGNO && (N) <= LAST_ALTIVEC_REGNO)
#define HARD_REGNO_NREGS(REGNO, MODE) \
(FP_REGNO_P (REGNO) \
? ((GET_MODE_SIZE (MODE) + UNITS_PER_FP_WORD - 1) / UNITS_PER_FP_WORD) \
: ALTIVEC_REGNO_P (REGNO) \
? ((GET_MODE_SIZE (MODE) + UNITS_PER_ALTIVEC_WORD - 1) / UNITS_PER_ALTIVEC_WORD) \
: ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD))
#define ALTIVEC_VECTOR_MODE(MODE) \
((MODE) == V16QImode \
|| (MODE) == V8HImode \
|| (MODE) == V4SFmode \
|| (MODE) == V4SImode)
#define VECTOR_MODE_SUPPORTED_P(MODE) \
(TARGET_ALTIVEC && ALTIVEC_VECTOR_MODE (MODE))
#define HARD_REGNO_MODE_OK(REGNO, MODE) \
(FP_REGNO_P (REGNO) ? \
(GET_MODE_CLASS (MODE) == MODE_FLOAT \
|| (GET_MODE_CLASS (MODE) == MODE_INT \
&& GET_MODE_SIZE (MODE) == UNITS_PER_FP_WORD)) \
: ALTIVEC_REGNO_P (REGNO) ? ALTIVEC_VECTOR_MODE (MODE) \
: CR_REGNO_P (REGNO) ? GET_MODE_CLASS (MODE) == MODE_CC \
: XER_REGNO_P (REGNO) ? (MODE) == PSImode \
: ! INT_REGNO_P (REGNO) ? (GET_MODE_CLASS (MODE) == MODE_INT \
&& GET_MODE_SIZE (MODE) <= UNITS_PER_WORD) \
: 1)
#define HARD_REGNO_RENAME_OK(REG1, REG2) hard_regno_rename_ok ((REG1), (REG2))
#define MODES_TIEABLE_P(MODE1, MODE2) \
(GET_MODE_CLASS (MODE1) == MODE_FLOAT \
? GET_MODE_CLASS (MODE2) == MODE_FLOAT \
: GET_MODE_CLASS (MODE2) == MODE_FLOAT \
? GET_MODE_CLASS (MODE1) == MODE_FLOAT \
: GET_MODE_CLASS (MODE1) == MODE_CC \
? GET_MODE_CLASS (MODE2) == MODE_CC \
: GET_MODE_CLASS (MODE2) == MODE_CC \
? GET_MODE_CLASS (MODE1) == MODE_CC \
: ALTIVEC_VECTOR_MODE (MODE1) \
? ALTIVEC_VECTOR_MODE (MODE2) \
: ALTIVEC_VECTOR_MODE (MODE2) \
? ALTIVEC_VECTOR_MODE (MODE1) \
: 1)
#define REGISTER_MOVE_COST(MODE, CLASS1, CLASS2) \
((CLASS1) == FLOAT_REGS && (CLASS2) == FLOAT_REGS ? 2 \
: (CLASS1) == FLOAT_REGS && (CLASS2) != FLOAT_REGS ? 10 \
: (CLASS1) != FLOAT_REGS && (CLASS2) == FLOAT_REGS ? 10 \
\
\
: (CLASS1) == ALTIVEC_REGS && (CLASS2) != ALTIVEC_REGS ? 40 \
: (CLASS1) != ALTIVEC_REGS && (CLASS2) == ALTIVEC_REGS ? 40 \
: (((CLASS1) == SPECIAL_REGS || (CLASS1) == MQ_REGS \
|| (CLASS1) == LINK_REGS || (CLASS1) == CTR_REGS \
|| (CLASS1) == LINK_OR_CTR_REGS) \
&& ((CLASS2) == SPECIAL_REGS || (CLASS2) == MQ_REGS \
|| (CLASS2) == LINK_REGS || (CLASS2) == CTR_REGS \
|| (CLASS2) == LINK_OR_CTR_REGS)) ? 10 \
: 2)
#define MEMORY_MOVE_COST(MODE, CLASS, IN) \
((GET_MODE_CLASS (MODE) == MODE_FLOAT \
&& (rs6000_cpu == PROCESSOR_RIOS1 || rs6000_cpu == PROCESSOR_PPC601) \
? 3 : 2) \
+ 4)
#define BRANCH_COST 3
#define CONDITIONAL_REGISTER_USAGE \
{ \
int i; \
if (! TARGET_POWER) \
fixed_regs[64] = 1; \
if (TARGET_64BIT) \
fixed_regs[13] = call_used_regs[13] \
= call_really_used_regs[13] = 1; \
if (TARGET_SOFT_FLOAT) \
for (i = 32; i < 64; i++) \
fixed_regs[i] = call_used_regs[i] \
= call_really_used_regs[i] = 1; \
if (DEFAULT_ABI == ABI_V4 \
&& PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM \
&& flag_pic == 1) \
fixed_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] \
= call_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] \
= call_really_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] = 1; \
if (DEFAULT_ABI == ABI_DARWIN \
&& PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM) \
global_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] \
= fixed_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] \
= call_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] \
= call_really_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] = 1; \
\
if (! TARGET_ALTIVEC && DEFAULT_ABI != ABI_DARWIN) \
{ \
for (i = FIRST_ALTIVEC_REGNO; i <= LAST_ALTIVEC_REGNO; ++i) \
fixed_regs[i] = call_used_regs[i] = call_really_used_regs[i] = 1; \
call_really_used_regs[VRSAVE_REGNO] = 1; \
} \
if (TARGET_ALTIVEC_ABI || DEFAULT_ABI == ABI_DARWIN) \
for (i = FIRST_ALTIVEC_REGNO; i < FIRST_ALTIVEC_REGNO + 20; ++i) \
call_used_regs[i] = call_really_used_regs[i] = 1; \
}
#define STACK_POINTER_REGNUM 1
#define FRAME_POINTER_REGNUM 31
#define FRAME_POINTER_REQUIRED 0
#define ARG_POINTER_REGNUM 67
#define STATIC_CHAIN_REGNUM 11
#define LINK_REGISTER_REGNUM 65
#define COUNT_REGISTER_REGNUM 66
#define STRUCT_VALUE 0
enum reg_class
{
NO_REGS,
BASE_REGS,
GENERAL_REGS,
FLOAT_REGS,
NON_SPECIAL_REGS,
ALTIVEC_REGS,
VRSAVE_REGS,
MQ_REGS,
LINK_REGS,
CTR_REGS,
LINK_OR_CTR_REGS,
SPECIAL_REGS,
SPEC_OR_GEN_REGS,
CR0_REGS,
CR_REGS,
NON_FLOAT_REGS,
XER_REGS,
ALL_REGS,
LIM_REG_CLASSES
};
#define N_REG_CLASSES (int) LIM_REG_CLASSES
#define REG_CLASS_NAMES \
{ \
"NO_REGS", \
"BASE_REGS", \
"GENERAL_REGS", \
"FLOAT_REGS", \
\
"NON_SPECIAL_REGS", \
"ALTIVEC_REGS", \
"VRSAVE_REGS", \
"MQ_REGS", \
"LINK_REGS", \
"CTR_REGS", \
"LINK_OR_CTR_REGS", \
"SPECIAL_REGS", \
"SPEC_OR_GEN_REGS", \
"CR0_REGS", \
"CR_REGS", \
"NON_FLOAT_REGS", \
"XER_REGS", \
"ALL_REGS" \
}
#define REG_CLASS_CONTENTS \
{ \
{ 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, \
{ 0xfffffffe, 0x00000000, 0x00000008, 0x00000000 }, \
{ 0xffffffff, 0x00000000, 0x00000008, 0x00000000 }, \
{ 0x00000000, 0xffffffff, 0x00000000, 0x00000000 }, \
{ 0xffffffff, 0xffffffff, 0x00000008, 0x00000000 }, \
\
{ 0x00000000, 0x00000000, 0xffffe000, 0x00001fff }, \
{ 0x00000000, 0x00000000, 0x00000000, 0x00002000 }, \
{ 0x00000000, 0x00000000, 0x00000001, 0x00000000 }, \
{ 0x00000000, 0x00000000, 0x00000002, 0x00000000 }, \
{ 0x00000000, 0x00000000, 0x00000004, 0x00000000 }, \
{ 0x00000000, 0x00000000, 0x00000006, 0x00000000 }, \
{ 0x00000000, 0x00000000, 0x00000007, 0x00002000 }, \
{ 0xffffffff, 0x00000000, 0x0000000f, 0x00000000 }, \
{ 0x00000000, 0x00000000, 0x00000010, 0x00000000 }, \
{ 0x00000000, 0x00000000, 0x00000ff0, 0x00000000 }, \
{ 0xffffffff, 0x00000000, 0x0000efff, 0x00000000 }, \
{ 0x00000000, 0x00000000, 0x00001000, 0x00000000 }, \
{ 0xffffffff, 0xffffffff, 0xffffffff, 0x00003fff } \
}
#define REGNO_REG_CLASS(REGNO) \
((REGNO) == 0 ? GENERAL_REGS \
: (REGNO) < 32 ? BASE_REGS \
: FP_REGNO_P (REGNO) ? FLOAT_REGS \
: ALTIVEC_REGNO_P (REGNO) ? ALTIVEC_REGS \
: (REGNO) == CR0_REGNO ? CR0_REGS \
: CR_REGNO_P (REGNO) ? CR_REGS \
: (REGNO) == MQ_REGNO ? MQ_REGS \
: (REGNO) == LINK_REGISTER_REGNUM ? LINK_REGS \
: (REGNO) == COUNT_REGISTER_REGNUM ? CTR_REGS \
: (REGNO) == ARG_POINTER_REGNUM ? BASE_REGS \
: (REGNO) == XER_REGNO ? XER_REGS \
: (REGNO) == VRSAVE_REGNO ? VRSAVE_REGS \
: NO_REGS)
#define INDEX_REG_CLASS GENERAL_REGS
#define BASE_REG_CLASS BASE_REGS
#define REG_CLASS_FROM_LETTER(C) \
((C) == 'f' ? FLOAT_REGS \
: (C) == 'b' ? BASE_REGS \
: (C) == 'h' ? SPECIAL_REGS \
: (C) == 'q' ? MQ_REGS \
: (C) == 'c' ? CTR_REGS \
: (C) == 'l' ? LINK_REGS \
: (C) == 'v' ? ALTIVEC_REGS \
: (C) == 'x' ? CR0_REGS \
: (C) == 'y' ? CR_REGS \
: (C) == 'z' ? XER_REGS \
: NO_REGS)
#define EXTRA_CONSTANT_CONSTRAINTS
#define CONST_OK_FOR_LETTER_P(VALUE, CL) \
( (CL) == 'A' ? (unsigned HOST_WIDE_INT) ((VALUE) + 16) < 32 \
: (CL) == 'B' ? (unsigned HOST_WIDE_INT) (VALUE) < 32 \
: (CL) == 'C' ? (unsigned HOST_WIDE_INT) (VALUE) < 16 \
: (CL) == 'D' ? (unsigned HOST_WIDE_INT) (VALUE) < 4 \
: (CL) == 'I' ? (unsigned HOST_WIDE_INT) ((VALUE) + 0x8000) < 0x10000 \
: (CL) == 'J' ? ((VALUE) & (~ (unsigned HOST_WIDE_INT) 0xffff0000)) == 0 \
: (CL) == 'K' ? ((VALUE) & (~ (HOST_WIDE_INT) 0xffff)) == 0 \
: (CL) == 'L' ? (((VALUE) & 0xffff) == 0 \
&& ((VALUE) >> 31 == -1 || (VALUE) >> 31 == 0)) \
: (CL) == 'M' ? (VALUE) > 31 \
: (CL) == 'N' ? (VALUE) > 0 && exact_log2 (VALUE) >= 0 \
: (CL) == 'O' ? (VALUE) == 0 \
: (CL) == 'P' ? (unsigned HOST_WIDE_INT) ((- (VALUE)) + 0x8000) < 0x10000 \
: 0)
#define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) \
( (C) == 'G' ? (num_insns_constant (VALUE, GET_MODE (VALUE)) \
== ((GET_MODE (VALUE) == SFmode) ? 1 : 2)) \
: (C) == 'H' ? (num_insns_constant (VALUE, GET_MODE (VALUE)) == 3) \
: 0)
#define EXTRA_CONSTRAINT(OP, C) \
((C) == 'Q' ? GET_CODE (OP) == MEM && GET_CODE (XEXP (OP, 0)) == REG \
: (C) == 'R' ? LEGITIMATE_CONSTANT_POOL_ADDRESS_P (OP) \
: (C) == 'S' ? mask64_operand (OP, DImode) \
: (C) == 'T' ? mask_operand (OP, SImode) \
: (C) == 'U' ? (DEFAULT_ABI == ABI_V4 \
&& small_data_operand (OP, GET_MODE (OP))) \
: 0)
#define PREFERRED_RELOAD_CLASS(X,CLASS) \
(((GET_CODE (X) == CONST_DOUBLE \
&& GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT) \
? NO_REGS \
: (GET_MODE_CLASS (GET_MODE (X)) == MODE_INT \
&& (CLASS) == NON_SPECIAL_REGS) \
? GENERAL_REGS \
: (CLASS)))
#define SECONDARY_RELOAD_CLASS(CLASS,MODE,IN) \
secondary_reload_class (CLASS, MODE, IN)
#define SECONDARY_MEMORY_NEEDED(CLASS1,CLASS2,MODE) \
((CLASS1) != (CLASS2) && ((CLASS1) == FLOAT_REGS \
|| (CLASS2) == FLOAT_REGS \
|| (CLASS1) == ALTIVEC_REGS \
|| (CLASS2) == ALTIVEC_REGS))
#define CLASS_MAX_NREGS(CLASS, MODE) \
(((CLASS) == FLOAT_REGS) \
? ((GET_MODE_SIZE (MODE) + UNITS_PER_FP_WORD - 1) / UNITS_PER_FP_WORD) \
: ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD))
#define CLASS_CANNOT_CHANGE_MODE FLOAT_REGS
#define CLASS_CANNOT_CHANGE_MODE_P(FROM,TO) \
(GET_MODE_SIZE (FROM) != GET_MODE_SIZE (TO))
enum rs6000_abi {
ABI_NONE,
ABI_AIX,
ABI_AIX_NODESC,
ABI_V4,
ABI_DARWIN
};
extern enum rs6000_abi rs6000_current_abi;
typedef struct rs6000_stack {
int first_gp_reg_save;
int first_fp_reg_save;
int first_altivec_reg_save;
int lr_save_p;
int cr_save_p;
int vrsave_save_p;
unsigned int vrsave_mask;
int toc_save_p;
int push_p;
int calls_p;
int vector_outside_red_zone_p;
int world_save_p;
enum rs6000_abi abi;
int gp_save_offset;
int fp_save_offset;
int altivec_save_offset;
int lr_save_offset;
int cr_save_offset;
int vrsave_save_offset;
int toc_save_offset;
int varargs_save_offset;
int ehrd_offset;
int reg_size;
int varargs_size;
int vars_size;
int parm_size;
int save_size;
int fixed_size;
int gp_size;
int fp_size;
int altivec_size;
int cr_size;
int lr_size;
int vrsave_size;
int altivec_padding_size;
int toc_size;
int total_size;
} rs6000_stack_t;
#define STACK_GROWS_DOWNWARD
#define RS6000_REG_SAVE ((DEFAULT_ABI == ABI_AIX \
|| DEFAULT_ABI == ABI_AIX_NODESC \
|| DEFAULT_ABI == ABI_DARWIN) \
? (TARGET_64BIT ? 64 : 32) \
: 0)
#define RS6000_SAVE_AREA \
(((DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_AIX_NODESC || DEFAULT_ABI == ABI_DARWIN) ? 24 : 8) \
<< (TARGET_64BIT ? 1 : 0))
#define RS6000_SAVE_TOC gen_rtx_MEM (Pmode, \
plus_constant (stack_pointer_rtx, \
(TARGET_32BIT ? 20 : 40)))
#define RS6000_VARARGS_AREA 0
#define RS6000_ALIGN(n,a) (((n) + (a) - 1) & ~((a) - 1))
#define RS6000_VARARGS_SIZE \
((GP_ARG_NUM_REG * (TARGET_32BIT ? 4 : 8)) + (FP_ARG_NUM_REG * 8) + 8 + 8)
#define STARTING_FRAME_OFFSET \
(RS6000_ALIGN (current_function_outgoing_args_size, \
TARGET_ALTIVEC ? 16 : 8) \
+ RS6000_VARARGS_AREA \
+ RS6000_SAVE_AREA)
#define STACK_DYNAMIC_OFFSET(FUNDECL) \
(RS6000_ALIGN (current_function_outgoing_args_size, \
TARGET_ALTIVEC ? 16 : 8) \
+ (STACK_POINTER_OFFSET))
#define FRAME_ALIGN_MOD(a,o,s) ((a) == 16 && !((o) == 0 && (s) == 0) ? 8 : 0)
#define FIRST_PARM_OFFSET(FNDECL) RS6000_SAVE_AREA
#define ARG_POINTER_CFA_OFFSET(FNDECL) 0
#define REG_PARM_STACK_SPACE(FNDECL) RS6000_REG_SAVE
#define NO_REG_PARM_STACK_SPACE(CUM,ENTRY) \
no_reg_parm_stack_space(&CUM, ENTRY)
#define OUTGOING_REG_PARM_STACK_SPACE
#define STACK_POINTER_OFFSET RS6000_SAVE_AREA
#define ACCUMULATE_OUTGOING_ARGS 1
#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) 0
#define FUNCTION_VALUE(VALTYPE, FUNC) \
gen_rtx_REG ((INTEGRAL_TYPE_P (VALTYPE) \
&& TYPE_PRECISION (VALTYPE) < BITS_PER_WORD) \
|| POINTER_TYPE_P (VALTYPE) \
? word_mode : TYPE_MODE (VALTYPE), \
TREE_CODE (VALTYPE) == VECTOR_TYPE ? ALTIVEC_ARG_RETURN \
: TREE_CODE (VALTYPE) == REAL_TYPE && TARGET_HARD_FLOAT \
? FP_ARG_RETURN : GP_ARG_RETURN)
#define LIBCALL_VALUE(MODE) \
gen_rtx_REG (MODE, ALTIVEC_VECTOR_MODE (MODE) ? ALTIVEC_ARG_RETURN \
: GET_MODE_CLASS (MODE) == MODE_FLOAT \
&& TARGET_HARD_FLOAT \
? FP_ARG_RETURN : GP_ARG_RETURN)
#define RETURN_IN_MEMORY(TYPE) \
(AGGREGATE_TYPE_P (TYPE) && \
(TARGET_AIX_STRUCT_RET || \
(unsigned HOST_WIDEST_INT) int_size_in_bytes (TYPE) > 8))
#define DRAFT_V4_STRUCT_RET 0
#define DEFAULT_PCC_STRUCT_RETURN 0
#define STACK_SAVEAREA_MODE(LEVEL) \
(LEVEL == SAVE_FUNCTION ? VOIDmode \
: LEVEL == SAVE_NONLOCAL ? (TARGET_32BIT ? DImode : TImode) : Pmode)
#define GP_ARG_MIN_REG 3
#define GP_ARG_MAX_REG 10
#define GP_ARG_NUM_REG (GP_ARG_MAX_REG - GP_ARG_MIN_REG + 1)
#define FP_ARG_MIN_REG 33
#define FP_ARG_AIX_MAX_REG 45
#define FP_ARG_V4_MAX_REG 40
#define FP_ARG_MAX_REG ((DEFAULT_ABI == ABI_AIX \
|| DEFAULT_ABI == ABI_AIX_NODESC \
|| DEFAULT_ABI == ABI_DARWIN) \
? FP_ARG_AIX_MAX_REG : FP_ARG_V4_MAX_REG)
#define FP_ARG_NUM_REG (FP_ARG_MAX_REG - FP_ARG_MIN_REG + 1)
#define ALTIVEC_ARG_MIN_REG (FIRST_ALTIVEC_REGNO + 2)
#define ALTIVEC_ARG_MAX_REG (ALTIVEC_ARG_MIN_REG + 11)
#define ALTIVEC_ARG_NUM_REG (ALTIVEC_ARG_MAX_REG - ALTIVEC_ARG_MIN_REG + 1)
#define GP_ARG_RETURN GP_ARG_MIN_REG
#define FP_ARG_RETURN FP_ARG_MIN_REG
#define ALTIVEC_ARG_RETURN (FIRST_ALTIVEC_REGNO + 2)
#define CALL_NORMAL 0x00000000
#define CALL_V4_CLEAR_FP_ARGS 0x00000002
#define CALL_V4_SET_FP_ARGS 0x00000004
#define CALL_LONG 0x00000008
#define FUNCTION_VALUE_REGNO_P(N) ((N) == GP_ARG_RETURN \
|| ((N) == FP_ARG_RETURN) \
|| (TARGET_ALTIVEC && \
(N) == ALTIVEC_ARG_RETURN))
#define FUNCTION_ARG_REGNO_P(N) \
(((unsigned)((N) - GP_ARG_MIN_REG) < (unsigned)(GP_ARG_NUM_REG)) \
|| (TARGET_ALTIVEC && \
(unsigned)((N) - ALTIVEC_ARG_MIN_REG) < (unsigned)(ALTIVEC_ARG_NUM_REG)) \
|| ((unsigned)((N) - FP_ARG_MIN_REG) < (unsigned)(FP_ARG_NUM_REG)))
typedef struct machine_function
{
int sysv_varargs_p;
int ra_needs_full_frame;
int substitute_pic_base_reg;
} machine_function;
typedef struct rs6000_args
{
int words;
int fregno;
int vregno;
int nargs_prototype;
int orig_nargs;
int prototype;
int call_cookie;
int sysv_gregno;
int num_vector;
int is_incoming;
int is_varargs;
} CUMULATIVE_ARGS;
#define RS6000_ARG_SIZE(MODE, TYPE) \
((MODE) != BLKmode \
? (GET_MODE_SIZE (MODE) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD \
: (int_size_in_bytes (TYPE) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
#define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,INDIRECT) \
init_cumulative_args (&CUM, FNTYPE, LIBNAME, FALSE)
#define INIT_CUMULATIVE_INCOMING_ARGS(CUM,FNTYPE,LIBNAME) \
init_cumulative_args (&CUM, FNTYPE, LIBNAME, TRUE)
#define REARRANGE_ARG_LIST(CUM,ARGS) \
rearrange_arg_list(&CUM, ARGS)
#define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \
function_arg_advance (&CUM, MODE, TYPE, NAMED)
#define USE_FP_FOR_ARG_P(CUM,MODE,TYPE) \
(GET_MODE_CLASS (MODE) == MODE_FLOAT \
&& (CUM).fregno <= FP_ARG_MAX_REG \
&& TARGET_HARD_FLOAT)
#define USE_ALTIVEC_FOR_ARG_P(CUM,MODE,TYPE) \
(ALTIVEC_VECTOR_MODE (MODE) \
&& (CUM).vregno <= ALTIVEC_ARG_MAX_REG \
&& TARGET_ALTIVEC_ABI)
#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
function_arg (&CUM, MODE, TYPE, NAMED)
#define FUNCTION_ARG_PARTIAL_NREGS(CUM, MODE, TYPE, NAMED) \
function_arg_partial_nregs (&CUM, MODE, TYPE, NAMED)
#define FUNCTION_ARG_PASS_BY_REFERENCE(CUM, MODE, TYPE, NAMED) \
function_arg_pass_by_reference(&CUM, MODE, TYPE, NAMED)
#define FUNCTION_ARG_PADDING(MODE, TYPE) function_arg_padding (MODE, TYPE)
#define FUNCTION_ARG_BOUNDARY(MODE, TYPE) \
function_arg_boundary (MODE, TYPE)
#define FUNCTION_ARG_MOD_BOUNDARY(MODE, TYPE) \
function_arg_mod_boundary (MODE, TYPE)
#define SETUP_INCOMING_VARARGS(CUM,MODE,TYPE,PRETEND_SIZE,NO_RTL) \
setup_incoming_varargs (&CUM, MODE, TYPE, &PRETEND_SIZE, NO_RTL)
#define BUILD_VA_LIST_TYPE(VALIST) \
(VALIST) = rs6000_build_va_list ()
#define EXPAND_BUILTIN_VA_START(stdarg, valist, nextarg) \
rs6000_va_start (stdarg, valist, nextarg)
#define EXPAND_BUILTIN_VA_ARG(valist, type) \
rs6000_va_arg (valist, type)
#define PAD_VARARGS_DOWN (TYPE_MODE (type) != BLKmode)
#define STRICT_ARGUMENT_NAMING 1
#define FUNCTION_OK_FOR_SIBCALL(DECL) function_ok_for_sibcall ((DECL))
#define FUNCTION_PROFILER(FILE, LABELNO) \
output_function_profiler ((FILE), (LABELNO));
#define EXIT_IGNORE_STACK 1
#define EPILOGUE_USES(REGNO) \
((reload_completed && (REGNO) == LINK_REGISTER_REGNUM) \
|| (TARGET_ALTIVEC && (REGNO) == VRSAVE_REGNO) \
|| (current_function_calls_eh_return \
&& TARGET_AIX \
&& (REGNO) == TOC_REGISTER))
#define TRAMPOLINE_SIZE rs6000_trampoline_size ()
#define INITIALIZE_TRAMPOLINE(ADDR, FNADDR, CXT) \
rs6000_initialize_trampoline (ADDR, FNADDR, CXT)
#define RETURN_ADDRESS_OFFSET \
((DEFAULT_ABI == ABI_AIX \
|| DEFAULT_ABI == ABI_DARWIN \
|| DEFAULT_ABI == ABI_AIX_NODESC) ? (TARGET_32BIT ? 8 : 16) : \
(DEFAULT_ABI == ABI_V4) ? 4 : \
(internal_error ("RETURN_ADDRESS_OFFSET not supported"), 0))
#define RETURN_ADDR_RTX(COUNT, FRAME) \
(rs6000_return_addr (COUNT, FRAME))
#define ELIMINABLE_REGS \
{{ FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}, \
{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \
{ ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM}, \
{ 30, 30} }
#define CAN_ELIMINATE(FROM, TO) \
((FROM) == ARG_POINTER_REGNUM && (TO) == STACK_POINTER_REGNUM \
? ! frame_pointer_needed \
: (FROM) == 30 ? ! TARGET_MINIMAL_TOC || TARGET_NO_TOC || get_pool_size () == 0 \
: 1)
#define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
{ \
rs6000_stack_t *info = rs6000_stack_info (); \
\
if ((FROM) == FRAME_POINTER_REGNUM && (TO) == STACK_POINTER_REGNUM) \
(OFFSET) = (info->push_p) ? 0 : - info->total_size; \
else if ((FROM) == ARG_POINTER_REGNUM && (TO) == FRAME_POINTER_REGNUM) \
(OFFSET) = info->total_size; \
else if ((FROM) == ARG_POINTER_REGNUM && (TO) == STACK_POINTER_REGNUM) \
(OFFSET) = (info->push_p) ? info->total_size : 0; \
else if ((FROM) == 30) \
(OFFSET) = 0; \
else \
abort (); \
}
#define HAVE_PRE_DECREMENT 1
#define HAVE_PRE_INCREMENT 1
#define REGNO_OK_FOR_INDEX_P(REGNO) \
((REGNO) < FIRST_PSEUDO_REGISTER \
? (REGNO) <= 31 || (REGNO) == 67 \
: (reg_renumber[REGNO] >= 0 \
&& (reg_renumber[REGNO] <= 31 || reg_renumber[REGNO] == 67)))
#define REGNO_OK_FOR_BASE_P(REGNO) \
((REGNO) < FIRST_PSEUDO_REGISTER \
? ((REGNO) > 0 && (REGNO) <= 31) || (REGNO) == 67 \
: (reg_renumber[REGNO] > 0 \
&& (reg_renumber[REGNO] <= 31 || reg_renumber[REGNO] == 67)))
#define MAX_REGS_PER_ADDRESS 2
#define CONSTANT_ADDRESS_P(X) \
(GET_CODE (X) == LABEL_REF || GET_CODE (X) == SYMBOL_REF \
|| GET_CODE (X) == CONST_INT || GET_CODE (X) == CONST \
|| GET_CODE (X) == HIGH)
#define LEGITIMATE_CONSTANT_P(X) \
((GET_CODE (X) != CONST_VECTOR && GET_CODE (X) != CONST_DOUBLE) \
|| (GET_CODE (X) == CONST_DOUBLE \
&& (GET_MODE (X) == VOIDmode \
|| (TARGET_POWERPC64 && GET_MODE (X) == DImode) \
|| easy_fp_constant (X, GET_MODE (X)))) \
|| (GET_CODE (X) == CONST_VECTOR && easy_vector_constant (X)))
#ifdef REG_OK_STRICT
# define REG_OK_STRICT_FLAG 1
#else
# define REG_OK_STRICT_FLAG 0
#endif
#define INT_REG_OK_FOR_INDEX_P(X, STRICT) \
((! (STRICT) \
&& (REGNO (X) <= 31 \
|| REGNO (X) == ARG_POINTER_REGNUM \
|| REGNO (X) >= FIRST_PSEUDO_REGISTER)) \
|| ((STRICT) && REGNO_OK_FOR_INDEX_P (REGNO (X))))
#define INT_REG_OK_FOR_BASE_P(X, STRICT) \
(REGNO (X) > 0 && INT_REG_OK_FOR_INDEX_P (X, (STRICT)))
#define REG_OK_FOR_INDEX_P(X) INT_REG_OK_FOR_INDEX_P (X, REG_OK_STRICT_FLAG)
#define REG_OK_FOR_BASE_P(X) INT_REG_OK_FOR_BASE_P (X, REG_OK_STRICT_FLAG)
#define CONSTANT_POOL_EXPR_P(X) (constant_pool_expr_p (X))
#define TOC_RELATIVE_EXPR_P(X) (toc_relative_expr_p (X))
#define LEGITIMATE_CONSTANT_POOL_ADDRESS_P(X) \
(TARGET_TOC \
&& GET_CODE (X) == PLUS \
&& GET_CODE (XEXP (X, 0)) == REG \
&& (TARGET_MINIMAL_TOC || REGNO (XEXP (X, 0)) == TOC_REGISTER) \
&& CONSTANT_POOL_EXPR_P (XEXP (X, 1)))
#define LEGITIMATE_SMALL_DATA_P(MODE, X) \
(DEFAULT_ABI == ABI_V4 \
&& !flag_pic && !TARGET_TOC \
&& (GET_CODE (X) == SYMBOL_REF || GET_CODE (X) == CONST) \
&& small_data_operand (X, MODE))
#define LEGITIMATE_ADDRESS_INTEGER_P(X, OFFSET) \
(GET_CODE (X) == CONST_INT \
&& (unsigned HOST_WIDE_INT) (INTVAL (X) + (OFFSET) + 0x8000) < 0x10000)
#define LEGITIMATE_OFFSET_ADDRESS_P(MODE, X, STRICT) \
(GET_CODE (X) == PLUS \
&& GET_CODE (XEXP (X, 0)) == REG \
&& INT_REG_OK_FOR_BASE_P (XEXP (X, 0), (STRICT)) \
&& LEGITIMATE_ADDRESS_INTEGER_P (XEXP (X, 1), 0) \
&& (! ALTIVEC_VECTOR_MODE (MODE) \
|| (GET_CODE (XEXP (X,1)) == CONST_INT && INTVAL (XEXP (X,1)) == 0)) \
&& (((MODE) != DFmode && (MODE) != DImode) \
|| (TARGET_32BIT \
? LEGITIMATE_ADDRESS_INTEGER_P (XEXP (X, 1), 4) \
: ! (INTVAL (XEXP (X, 1)) & 3))) \
&& ((MODE) != TImode \
|| (TARGET_32BIT \
? LEGITIMATE_ADDRESS_INTEGER_P (XEXP (X, 1), 12) \
: (LEGITIMATE_ADDRESS_INTEGER_P (XEXP (X, 1), 8) \
&& ! (INTVAL (XEXP (X, 1)) & 3)))))
#define LEGITIMATE_INDEXED_ADDRESS_P(X, STRICT) \
(GET_CODE (X) == PLUS \
&& GET_CODE (XEXP (X, 0)) == REG \
&& GET_CODE (XEXP (X, 1)) == REG \
&& ((INT_REG_OK_FOR_BASE_P (XEXP (X, 0), (STRICT)) \
&& INT_REG_OK_FOR_INDEX_P (XEXP (X, 1), (STRICT))) \
|| (INT_REG_OK_FOR_BASE_P (XEXP (X, 1), (STRICT)) \
&& INT_REG_OK_FOR_INDEX_P (XEXP (X, 0), (STRICT)))))
#define LEGITIMATE_INDIRECT_ADDRESS_P(X, STRICT) \
(GET_CODE (X) == REG && INT_REG_OK_FOR_BASE_P (X, (STRICT)))
#define LEGITIMATE_LO_SUM_ADDRESS_P(MODE, X, STRICT) \
\
((TARGET_ELF || TARGET_MACHO) \
&& ! flag_pic && ! TARGET_TOC \
\
&& ! VECTOR_MODE_P (MODE) \
&& GET_MODE_NUNITS (MODE) == 1 \
&& (GET_MODE_BITSIZE (MODE) <= 32 \
|| (TARGET_HARD_FLOAT && (MODE) == DFmode)) \
&& GET_CODE (X) == LO_SUM \
&& GET_CODE (XEXP (X, 0)) == REG \
&& INT_REG_OK_FOR_BASE_P (XEXP (X, 0), (STRICT)) \
&& CONSTANT_P (XEXP (X, 1)))
#define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \
{ if (rs6000_legitimate_address (MODE, X, REG_OK_STRICT_FLAG)) \
goto ADDR; \
}
#define LEGITIMIZE_ADDRESS(X,OLDX,MODE,WIN) \
{ rtx result = rs6000_legitimize_address (X, OLDX, MODE); \
if (result != NULL_RTX) \
{ \
(X) = result; \
goto WIN; \
} \
}
#define LEGITIMIZE_RELOAD_ADDRESS(X,MODE,OPNUM,TYPE,IND_LEVELS,WIN) \
do { \
int win; \
\
(X) = rs6000_legitimize_reload_address (&(X), (MODE), (OPNUM), \
(int)(TYPE), (IND_LEVELS), &win); \
if ( win ) \
goto WIN; \
} while (0)
#define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL) \
{ if (GET_CODE (ADDR) == PLUS \
&& LEGITIMATE_ADDRESS_INTEGER_P (XEXP (ADDR, 1), 0) \
&& ! LEGITIMATE_ADDRESS_INTEGER_P (XEXP (ADDR, 1), \
(TARGET_32BIT ? 4 : 8))) \
goto LABEL; \
if (TARGET_UPDATE && GET_CODE (ADDR) == PRE_INC) \
goto LABEL; \
if (TARGET_UPDATE && GET_CODE (ADDR) == PRE_DEC) \
goto LABEL; \
if (GET_CODE (ADDR) == LO_SUM) \
goto LABEL; \
}
#define RS6000_PIC_OFFSET_TABLE_REGNUM 30
#define PIC_OFFSET_TABLE_REGNUM (flag_pic ? RS6000_PIC_OFFSET_TABLE_REGNUM : INVALID_REGNUM)
#define TOC_REGISTER (TARGET_MINIMAL_TOC ? 30 : 2)
#define CASE_VECTOR_MODE SImode
#define CASE_VECTOR_PC_RELATIVE 1
#define DEFAULT_SIGNED_CHAR 0
#define MOVE_MAX (! TARGET_POWERPC64 ? 4 : 8)
#define MAX_MOVE_MAX 8
#define SLOW_BYTE_ACCESS 1
#define WORD_REGISTER_OPERATIONS
#define LOAD_EXTEND_OP(MODE) ZERO_EXTEND
#define SHORT_IMMEDIATES_SIGN_EXTEND
#define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
#define Pmode (TARGET_32BIT ? SImode : DImode)
#define FUNCTION_MODE (TARGET_32BIT ? SImode : DImode)
#define NO_FUNCTION_CSE
#define SHIFT_COUNT_TRUNCATED (TARGET_POWER ? 1 : 0)
#define CONST_COSTS(RTX,CODE,OUTER_CODE) \
case CONST_INT: \
case CONST: \
case LABEL_REF: \
case SYMBOL_REF: \
case CONST_DOUBLE: \
case HIGH: \
return 0;
#define RTX_COSTS(X,CODE,OUTER_CODE) \
case PLUS: \
\
case MINUS: \
\
if ( TARGET_FUSED_MADD \
&& GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT \
&& GET_CODE (XEXP (X, 0)) == MULT ) \
return COSTS_N_INSNS (0) - rs6000_rtx_mult_cost (XEXP (X,0)); \
if ( TARGET_FUSED_MADD \
&& GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT \
&& GET_CODE (XEXP (X, 1)) == MULT ) \
return COSTS_N_INSNS (0) - rs6000_rtx_mult_cost (XEXP (X,1)); \
if (CODE==MINUS) \
return COSTS_N_INSNS (1); \
\
return ((GET_CODE (XEXP (X, 1)) == CONST_INT \
&& ((unsigned HOST_WIDE_INT) (INTVAL (XEXP (X, 1)) \
+ 0x8000) >= 0x10000) \
&& ((INTVAL (XEXP (X, 1)) & 0xffff) != 0)) \
? COSTS_N_INSNS (2) \
: COSTS_N_INSNS (1)); \
case AND: \
case IOR: \
case XOR: \
return ((GET_CODE (XEXP (X, 1)) == CONST_INT \
&& (INTVAL (XEXP (X, 1)) & (~ (HOST_WIDE_INT) 0xffff)) != 0 \
&& ((INTVAL (XEXP (X, 1)) & 0xffff) != 0)) \
? COSTS_N_INSNS (2) \
: COSTS_N_INSNS (1)); \
case MULT: \
\
return rs6000_rtx_mult_cost (X); \
case DIV: \
case MOD: \
if (GET_CODE (XEXP (X, 1)) == CONST_INT \
&& exact_log2 (INTVAL (XEXP (X, 1))) >= 0) \
return COSTS_N_INSNS (2); \
\
case UDIV: \
case UMOD: \
switch (rs6000_cpu) \
{ \
case PROCESSOR_RIOS1: \
return COSTS_N_INSNS (19); \
case PROCESSOR_RIOS2: \
return COSTS_N_INSNS (13); \
case PROCESSOR_RS64A: \
return (GET_MODE (XEXP (X, 1)) != DImode \
? COSTS_N_INSNS (65) \
: COSTS_N_INSNS (67)); \
case PROCESSOR_MPCCORE: \
return COSTS_N_INSNS (6); \
case PROCESSOR_PPC403: \
return COSTS_N_INSNS (33); \
case PROCESSOR_PPC405: \
return COSTS_N_INSNS (35); \
case PROCESSOR_PPC601: \
return COSTS_N_INSNS (36); \
case PROCESSOR_PPC603: \
return COSTS_N_INSNS (37); \
case PROCESSOR_PPC604: \
case PROCESSOR_PPC604e: \
return COSTS_N_INSNS (20); \
case PROCESSOR_PPC620: \
case PROCESSOR_PPC630: \
return (GET_MODE (XEXP (X, 1)) != DImode \
? COSTS_N_INSNS (21) \
: COSTS_N_INSNS (37)); \
case PROCESSOR_PPC750: \
case PROCESSOR_PPC7400: \
return COSTS_N_INSNS (19); \
case PROCESSOR_PPC7450: \
return COSTS_N_INSNS (23); \
} \
case FFS: \
return COSTS_N_INSNS (4); \
case MEM: \
\
return 5;
#define ADDRESS_COST(RTX) 0
#define EXTRA_CC_MODES \
CC(CCUNSmode, "CCUNS") \
CC(CCFPmode, "CCFP") \
CC(CCEQmode, "CCEQ")
#define SELECT_CC_MODE(OP,X,Y) \
(GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT ? CCFPmode \
: (OP) == GTU || (OP) == LTU || (OP) == GEU || (OP) == LEU ? CCUNSmode \
: (((OP) == EQ || (OP) == NE) && GET_RTX_CLASS (GET_CODE (X)) == '<' \
? CCEQmode : CCmode))
extern struct rtx_def *rs6000_compare_op0, *rs6000_compare_op1;
extern int rs6000_compare_fp_p;
#define ASM_COMMENT_START " #"
#define TARGET_MEM_FUNCTIONS
extern int toc_initialized;
#define ASM_OUTPUT_SPECIAL_POOL_ENTRY(FILE, X, MODE, ALIGN, LABELNO, WIN) \
{ if (ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (X, MODE)) \
{ \
output_toc (FILE, X, LABELNO, MODE); \
goto WIN; \
} \
}
#ifdef HAVE_GAS_WEAK
#define RS6000_WEAK 1
#else
#define RS6000_WEAK 0
#endif
#if RS6000_WEAK
#define ASM_WEAKEN_DECL(FILE, DECL, NAME, VAL) \
do \
{ \
fputs ("\t.weak\t", (FILE)); \
assemble_name ((FILE), (NAME)); \
if ((DECL) && TREE_CODE (DECL) == FUNCTION_DECL \
&& DEFAULT_ABI == ABI_AIX) \
{ \
fputs ("\n\t.weak\t.", (FILE)); \
assemble_name ((FILE), (NAME)); \
} \
fputc ('\n', (FILE)); \
if (VAL) \
{ \
ASM_OUTPUT_DEF ((FILE), (NAME), (VAL)); \
if ((DECL) && TREE_CODE (DECL) == FUNCTION_DECL \
&& DEFAULT_ABI == ABI_AIX) \
{ \
fputs ("\t.set\t.", (FILE)); \
assemble_name ((FILE), (NAME)); \
fputs (",.", (FILE)); \
assemble_name ((FILE), (VAL)); \
fputc ('\n', (FILE)); \
} \
} \
} \
while (0)
#endif
#undef ASM_OUTPUT_DEF_FROM_DECLS
#define ASM_OUTPUT_DEF_FROM_DECLS(FILE, DECL, TARGET) \
do \
{ \
const char *alias = XSTR (XEXP (DECL_RTL (DECL), 0), 0); \
const char *name = IDENTIFIER_POINTER (TARGET); \
if (TREE_CODE (DECL) == FUNCTION_DECL \
&& DEFAULT_ABI == ABI_AIX) \
{ \
if (TREE_PUBLIC (DECL)) \
{ \
if (!RS6000_WEAK || !DECL_WEAK (DECL)) \
{ \
fputs ("\t.globl\t.", FILE); \
assemble_name (FILE, alias); \
putc ('\n', FILE); \
} \
} \
else if (TARGET_XCOFF) \
{ \
fputs ("\t.lglobl\t.", FILE); \
assemble_name (FILE, alias); \
putc ('\n', FILE); \
} \
fputs ("\t.set\t.", FILE); \
assemble_name (FILE, alias); \
fputs (",.", FILE); \
assemble_name (FILE, name); \
fputc ('\n', FILE); \
} \
ASM_OUTPUT_DEF (FILE, alias, name); \
} \
while (0)
#define ASM_APP_ON ""
#define ASM_APP_OFF ""
extern char rs6000_reg_names[][8];
#define REGISTER_NAMES \
{ \
&rs6000_reg_names[ 0][0], \
&rs6000_reg_names[ 1][0], \
&rs6000_reg_names[ 2][0], \
&rs6000_reg_names[ 3][0], \
&rs6000_reg_names[ 4][0], \
&rs6000_reg_names[ 5][0], \
&rs6000_reg_names[ 6][0], \
&rs6000_reg_names[ 7][0], \
&rs6000_reg_names[ 8][0], \
&rs6000_reg_names[ 9][0], \
&rs6000_reg_names[10][0], \
&rs6000_reg_names[11][0], \
&rs6000_reg_names[12][0], \
&rs6000_reg_names[13][0], \
&rs6000_reg_names[14][0], \
&rs6000_reg_names[15][0], \
&rs6000_reg_names[16][0], \
&rs6000_reg_names[17][0], \
&rs6000_reg_names[18][0], \
&rs6000_reg_names[19][0], \
&rs6000_reg_names[20][0], \
&rs6000_reg_names[21][0], \
&rs6000_reg_names[22][0], \
&rs6000_reg_names[23][0], \
&rs6000_reg_names[24][0], \
&rs6000_reg_names[25][0], \
&rs6000_reg_names[26][0], \
&rs6000_reg_names[27][0], \
&rs6000_reg_names[28][0], \
&rs6000_reg_names[29][0], \
&rs6000_reg_names[30][0], \
&rs6000_reg_names[31][0], \
\
&rs6000_reg_names[32][0], \
&rs6000_reg_names[33][0], \
&rs6000_reg_names[34][0], \
&rs6000_reg_names[35][0], \
&rs6000_reg_names[36][0], \
&rs6000_reg_names[37][0], \
&rs6000_reg_names[38][0], \
&rs6000_reg_names[39][0], \
&rs6000_reg_names[40][0], \
&rs6000_reg_names[41][0], \
&rs6000_reg_names[42][0], \
&rs6000_reg_names[43][0], \
&rs6000_reg_names[44][0], \
&rs6000_reg_names[45][0], \
&rs6000_reg_names[46][0], \
&rs6000_reg_names[47][0], \
&rs6000_reg_names[48][0], \
&rs6000_reg_names[49][0], \
&rs6000_reg_names[50][0], \
&rs6000_reg_names[51][0], \
&rs6000_reg_names[52][0], \
&rs6000_reg_names[53][0], \
&rs6000_reg_names[54][0], \
&rs6000_reg_names[55][0], \
&rs6000_reg_names[56][0], \
&rs6000_reg_names[57][0], \
&rs6000_reg_names[58][0], \
&rs6000_reg_names[59][0], \
&rs6000_reg_names[60][0], \
&rs6000_reg_names[61][0], \
&rs6000_reg_names[62][0], \
&rs6000_reg_names[63][0], \
\
&rs6000_reg_names[64][0], \
&rs6000_reg_names[65][0], \
&rs6000_reg_names[66][0], \
&rs6000_reg_names[67][0], \
\
&rs6000_reg_names[68][0], \
&rs6000_reg_names[69][0], \
&rs6000_reg_names[70][0], \
&rs6000_reg_names[71][0], \
&rs6000_reg_names[72][0], \
&rs6000_reg_names[73][0], \
&rs6000_reg_names[74][0], \
&rs6000_reg_names[75][0], \
\
&rs6000_reg_names[76][0], \
\
&rs6000_reg_names[77][0], \
&rs6000_reg_names[78][0], \
&rs6000_reg_names[79][0], \
&rs6000_reg_names[80][0], \
&rs6000_reg_names[81][0], \
&rs6000_reg_names[82][0], \
&rs6000_reg_names[83][0], \
&rs6000_reg_names[84][0], \
&rs6000_reg_names[85][0], \
&rs6000_reg_names[86][0], \
&rs6000_reg_names[87][0], \
&rs6000_reg_names[88][0], \
&rs6000_reg_names[89][0], \
&rs6000_reg_names[90][0], \
&rs6000_reg_names[91][0], \
&rs6000_reg_names[92][0], \
&rs6000_reg_names[93][0], \
&rs6000_reg_names[94][0], \
&rs6000_reg_names[95][0], \
&rs6000_reg_names[96][0], \
&rs6000_reg_names[97][0], \
&rs6000_reg_names[98][0], \
&rs6000_reg_names[99][0], \
&rs6000_reg_names[100][0], \
&rs6000_reg_names[101][0], \
&rs6000_reg_names[102][0], \
&rs6000_reg_names[103][0], \
&rs6000_reg_names[104][0], \
&rs6000_reg_names[105][0], \
&rs6000_reg_names[106][0], \
&rs6000_reg_names[107][0], \
&rs6000_reg_names[108][0], \
&rs6000_reg_names[109][0], \
}
#define DEBUG_REGISTER_NAMES \
{ \
"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \
"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", \
"r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", \
"r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31", \
"f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \
"f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", \
"f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23", \
"f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31", \
"mq", "lr", "ctr", "ap", \
"cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7", \
"xer", \
"v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", \
"v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15", \
"v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23", \
"v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31", \
"vrsave" \
}
#define ADDITIONAL_REGISTER_NAMES \
{{"r0", 0}, {"r1", 1}, {"r2", 2}, {"r3", 3}, \
{"r4", 4}, {"r5", 5}, {"r6", 6}, {"r7", 7}, \
{"r8", 8}, {"r9", 9}, {"r10", 10}, {"r11", 11}, \
{"r12", 12}, {"r13", 13}, {"r14", 14}, {"r15", 15}, \
{"r16", 16}, {"r17", 17}, {"r18", 18}, {"r19", 19}, \
{"r20", 20}, {"r21", 21}, {"r22", 22}, {"r23", 23}, \
{"r24", 24}, {"r25", 25}, {"r26", 26}, {"r27", 27}, \
{"r28", 28}, {"r29", 29}, {"r30", 30}, {"r31", 31}, \
{"fr0", 32}, {"fr1", 33}, {"fr2", 34}, {"fr3", 35}, \
{"fr4", 36}, {"fr5", 37}, {"fr6", 38}, {"fr7", 39}, \
{"fr8", 40}, {"fr9", 41}, {"fr10", 42}, {"fr11", 43}, \
{"fr12", 44}, {"fr13", 45}, {"fr14", 46}, {"fr15", 47}, \
{"fr16", 48}, {"fr17", 49}, {"fr18", 50}, {"fr19", 51}, \
{"fr20", 52}, {"fr21", 53}, {"fr22", 54}, {"fr23", 55}, \
{"fr24", 56}, {"fr25", 57}, {"fr26", 58}, {"fr27", 59}, \
{"fr28", 60}, {"fr29", 61}, {"fr30", 62}, {"fr31", 63}, \
{"v0", 77}, {"v1", 78}, {"v2", 79}, {"v3", 80}, \
{"v4", 81}, {"v5", 82}, {"v6", 83}, {"v7", 84}, \
{"v8", 85}, {"v9", 86}, {"v10", 87}, {"v11", 88}, \
{"v12", 89}, {"v13", 90}, {"v14", 91}, {"v15", 92}, \
{"v16", 93}, {"v17", 94}, {"v18", 95}, {"v19", 96}, \
{"v20", 97}, {"v21", 98}, {"v22", 99}, {"v23", 100}, \
{"v24", 101},{"v25", 102},{"v26", 103},{"v27", 104}, \
{"v28", 105},{"v29", 106},{"v30", 107},{"v31", 108}, \
{"vrsave", 109}, \
\
{"cr0", 68}, {"cr1", 69}, {"cr2", 70}, {"cr3", 71}, \
{"cr4", 72}, {"cr5", 73}, {"cr6", 74}, {"cr7", 75}, \
{"cc", 68}, {"sp", 1}, {"toc", 2} }
#define RS6000_CALL_GLUE "cror 31,31,31"
#define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) \
do { char buf[100]; \
fputs ("\t.long ", FILE); \
ASM_GENERATE_INTERNAL_LABEL (buf, "L", VALUE); \
assemble_name (FILE, buf); \
putc ('-', FILE); \
ASM_GENERATE_INTERNAL_LABEL (buf, "L", REL); \
assemble_name (FILE, buf); \
putc ('\n', FILE); \
} while (0)
#define ASM_OUTPUT_ALIGN(FILE,LOG) \
if ((LOG) != 0) \
fprintf (FILE, "\t.align %d\n", (LOG))
#if 0
#define ASM_OUTPUT_ALIGNED_LOCAL(FILE, NAME, SIZE, ALIGNMENT) \
do { fputs (".lcomm ", (FILE)); \
RS6000_OUTPUT_BASENAME ((FILE), (NAME)); \
fprintf ((FILE), ",%d,%s", (TARGET_32BIT ? (SIZE) : (ALIGNMENT)), \
xcoff_bss_section_name); \
if ( (ALIGNMENT) == 128) \
fputs (",4", (FILE)); \
putc ('\n', FILE); \
} while (0)
#endif
#define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO) \
( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 10), \
sprintf ((OUTPUT), "%s.%d", (NAME), (LABELNO)))
#define INCOMING_RETURN_ADDR_RTX gen_rtx_REG (Pmode, LINK_REGISTER_REGNUM)
#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (LINK_REGISTER_REGNUM)
#define EH_RETURN_DATA_REGNO(N) ((N) < 4 ? (N) + 3 : INVALID_REGNUM)
#define EH_RETURN_STACKADJ_RTX gen_rtx_REG (Pmode, 10)
#define PRINT_OPERAND(FILE, X, CODE) print_operand (FILE, X, CODE)
#define PRINT_OPERAND_PUNCT_VALID_P(CODE) \
((CODE) == '.')
#define PRINT_OPERAND_ADDRESS(FILE, ADDR) print_operand_address (FILE, ADDR)
#define PREDICATE_CODES \
\
{"zero_m1_operand", {CONST_INT}}, \
{"any_operand", {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF, \
LABEL_REF, SUBREG, REG, MEM, PARALLEL}}, \
{"zero_constant", {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF, \
LABEL_REF, SUBREG, REG, MEM}}, \
{"short_cint_operand", {CONST_INT}}, \
{"u_short_cint_operand", {CONST_INT}}, \
{"non_short_cint_operand", {CONST_INT}}, \
{"exact_log2_cint_operand", {CONST_INT}}, \
{"gpc_reg_operand", {SUBREG, REG}}, \
{"cc_reg_operand", {SUBREG, REG}}, \
{"cc_reg_not_cr0_operand", {SUBREG, REG}}, \
\
{"reg_or_zero_operand", {SUBREG, REG, CONST_INT}}, \
{"reg_or_short_operand", {SUBREG, REG, CONST_INT}}, \
{"reg_or_neg_short_operand", {SUBREG, REG, CONST_INT}}, \
{"reg_or_aligned_short_operand", {SUBREG, REG, CONST_INT}}, \
{"reg_or_u_short_operand", {SUBREG, REG, CONST_INT}}, \
{"reg_or_cint_operand", {SUBREG, REG, CONST_INT}}, \
{"reg_or_arith_cint_operand", {SUBREG, REG, CONST_INT}}, \
{"reg_or_add_cint64_operand", {SUBREG, REG, CONST_INT}}, \
{"reg_or_sub_cint64_operand", {SUBREG, REG, CONST_INT}}, \
{"reg_or_logical_cint_operand", {SUBREG, REG, CONST_INT, CONST_DOUBLE}}, \
{"got_operand", {SYMBOL_REF, CONST, LABEL_REF}}, \
{"got_no_const_operand", {SYMBOL_REF, LABEL_REF}}, \
{"easy_fp_constant", {CONST_DOUBLE}}, \
{"zero_fp_constant", {CONST_DOUBLE}}, \
{"reg_or_mem_operand", {SUBREG, MEM, REG}}, \
{"lwa_operand", {SUBREG, MEM, REG}}, \
{"volatile_mem_operand", {MEM}}, \
{"offsettable_mem_operand", {MEM}}, \
{"mem_or_easy_const_operand", {SUBREG, MEM, CONST_DOUBLE}}, \
{"add_operand", {SUBREG, REG, CONST_INT}}, \
{"non_add_cint_operand", {CONST_INT}}, \
{"and_operand", {SUBREG, REG, CONST_INT}}, \
{"and64_operand", {SUBREG, REG, CONST_INT, CONST_DOUBLE}}, \
{"logical_operand", {SUBREG, REG, CONST_INT, CONST_DOUBLE}}, \
{"non_logical_cint_operand", {CONST_INT, CONST_DOUBLE}}, \
{"mask_operand", {CONST_INT}}, \
{"mask64_operand", {CONST_INT, CONST_DOUBLE}}, \
{"count_register_operand", {REG}}, \
{"xer_operand", {REG}}, \
{"call_operand", {SYMBOL_REF, REG}}, \
{"current_file_function_operand", {SYMBOL_REF}}, \
{"input_operand", {SUBREG, MEM, REG, CONST_INT, \
CONST_DOUBLE, SYMBOL_REF}}, \
{"load_multiple_operation", {PARALLEL}}, \
{"store_multiple_operation", {PARALLEL}}, \
\
{"equality_operator", {EQ, NE}}, \
{"vector_comparison_operator", {EQ, LT}}, \
{"vrsave_operation", {PARALLEL}}, \
{"branch_comparison_operator", {EQ, NE, LE, LT, GE, \
GT, LEU, LTU, GEU, GTU, \
UNORDERED, ORDERED, \
UNGE, UNLE }}, \
{"branch_positive_comparison_operator", {EQ, LT, GT, LTU, GTU, \
UNORDERED }}, \
{"scc_comparison_operator", {EQ, NE, LE, LT, GE, \
GT, LEU, LTU, GEU, GTU, \
UNORDERED, ORDERED, \
UNGE, UNLE }}, \
{"trap_comparison_operator", {EQ, NE, LE, LT, GE, \
GT, LEU, LTU, GEU, GTU}}, \
{"boolean_operator", {AND, IOR, XOR}}, \
{"boolean_or_operator", {IOR, XOR}}, \
{"altivec_register_operand", {REG}}, \
{"min_max_operator", {SMIN, SMAX, UMIN, UMAX}},
extern int flag_pic;
extern int optimize;
extern int flag_expensive_optimizations;
extern int frame_pointer_needed;
enum {VRSAVE_OFF, VRSAVE_NORMAL, VRSAVE_ALLON};
extern int current_vrsave_save_type,
standard_vrsave_save_type;
#define DECL_TARGET_INTRINSIC_P(NODE) \
decl_target_intrinsic_p (NODE)
#define DECL_TARGET_OVERLOADED_INTRINSIC_P(NODE) \
decl_target_overloaded_intrinsic_p (NODE)
#define SELECT_TARGET_OVERLOADED_INTRINSIC(FUNCTION, PARAMS) \
select_target_overloaded_intrinsic(FUNCTION, PARAMS)
#ifdef PFE
#define PFE_FREEZE_THAW_MACHINE_STATUS(f) rs6000_pfe_freeze_thaw_machine_status (f)
#endif
enum rs6000_builtins
{
ALTIVEC_BUILTIN_ST_INTERNAL_4si,
ALTIVEC_BUILTIN_LD_INTERNAL_4si,
ALTIVEC_BUILTIN_ST_INTERNAL_8hi,
ALTIVEC_BUILTIN_LD_INTERNAL_8hi,
ALTIVEC_BUILTIN_ST_INTERNAL_16qi,
ALTIVEC_BUILTIN_LD_INTERNAL_16qi,
ALTIVEC_BUILTIN_ST_INTERNAL_4sf,
ALTIVEC_BUILTIN_LD_INTERNAL_4sf,
ALTIVEC_BUILTIN_VADDUBM,
ALTIVEC_BUILTIN_VADDUHM,
ALTIVEC_BUILTIN_VADDUWM,
ALTIVEC_BUILTIN_VADDFP,
ALTIVEC_BUILTIN_VADDCUW,
ALTIVEC_BUILTIN_VADDUBS,
ALTIVEC_BUILTIN_VADDSBS,
ALTIVEC_BUILTIN_VADDUHS,
ALTIVEC_BUILTIN_VADDSHS,
ALTIVEC_BUILTIN_VADDUWS,
ALTIVEC_BUILTIN_VADDSWS,
ALTIVEC_BUILTIN_VAND,
ALTIVEC_BUILTIN_VANDC,
ALTIVEC_BUILTIN_VAVGUB,
ALTIVEC_BUILTIN_VAVGSB,
ALTIVEC_BUILTIN_VAVGUH,
ALTIVEC_BUILTIN_VAVGSH,
ALTIVEC_BUILTIN_VAVGUW,
ALTIVEC_BUILTIN_VAVGSW,
ALTIVEC_BUILTIN_VCFUX,
ALTIVEC_BUILTIN_VCFSX,
ALTIVEC_BUILTIN_VCTSXS,
ALTIVEC_BUILTIN_VCTUXS,
ALTIVEC_BUILTIN_VCMPBFP,
ALTIVEC_BUILTIN_VCMPEQUB,
ALTIVEC_BUILTIN_VCMPEQUH,
ALTIVEC_BUILTIN_VCMPEQUW,
ALTIVEC_BUILTIN_VCMPEQFP,
ALTIVEC_BUILTIN_VCMPGEFP,
ALTIVEC_BUILTIN_VCMPGTUB,
ALTIVEC_BUILTIN_VCMPGTSB,
ALTIVEC_BUILTIN_VCMPGTUH,
ALTIVEC_BUILTIN_VCMPGTSH,
ALTIVEC_BUILTIN_VCMPGTUW,
ALTIVEC_BUILTIN_VCMPGTSW,
ALTIVEC_BUILTIN_VCMPGTFP,
ALTIVEC_BUILTIN_VEXPTEFP,
ALTIVEC_BUILTIN_VLOGEFP,
ALTIVEC_BUILTIN_VMADDFP,
ALTIVEC_BUILTIN_VMAXUB,
ALTIVEC_BUILTIN_VMAXSB,
ALTIVEC_BUILTIN_VMAXUH,
ALTIVEC_BUILTIN_VMAXSH,
ALTIVEC_BUILTIN_VMAXUW,
ALTIVEC_BUILTIN_VMAXSW,
ALTIVEC_BUILTIN_VMAXFP,
ALTIVEC_BUILTIN_VMHADDSHS,
ALTIVEC_BUILTIN_VMHRADDSHS,
ALTIVEC_BUILTIN_VMLADDUHM,
ALTIVEC_BUILTIN_VMRGHB,
ALTIVEC_BUILTIN_VMRGHH,
ALTIVEC_BUILTIN_VMRGHW,
ALTIVEC_BUILTIN_VMRGLB,
ALTIVEC_BUILTIN_VMRGLH,
ALTIVEC_BUILTIN_VMRGLW,
ALTIVEC_BUILTIN_VMSUMUBM,
ALTIVEC_BUILTIN_VMSUMMBM,
ALTIVEC_BUILTIN_VMSUMUHM,
ALTIVEC_BUILTIN_VMSUMSHM,
ALTIVEC_BUILTIN_VMSUMUHS,
ALTIVEC_BUILTIN_VMSUMSHS,
ALTIVEC_BUILTIN_VMINUB,
ALTIVEC_BUILTIN_VMINSB,
ALTIVEC_BUILTIN_VMINUH,
ALTIVEC_BUILTIN_VMINSH,
ALTIVEC_BUILTIN_VMINUW,
ALTIVEC_BUILTIN_VMINSW,
ALTIVEC_BUILTIN_VMINFP,
ALTIVEC_BUILTIN_VMULEUB,
ALTIVEC_BUILTIN_VMULESB,
ALTIVEC_BUILTIN_VMULEUH,
ALTIVEC_BUILTIN_VMULESH,
ALTIVEC_BUILTIN_VMULOUB,
ALTIVEC_BUILTIN_VMULOSB,
ALTIVEC_BUILTIN_VMULOUH,
ALTIVEC_BUILTIN_VMULOSH,
ALTIVEC_BUILTIN_VNMSUBFP,
ALTIVEC_BUILTIN_VNOR,
ALTIVEC_BUILTIN_VOR,
ALTIVEC_BUILTIN_VSEL_4SI,
ALTIVEC_BUILTIN_VSEL_4SF,
ALTIVEC_BUILTIN_VSEL_8HI,
ALTIVEC_BUILTIN_VSEL_16QI,
ALTIVEC_BUILTIN_VPERM_4SI,
ALTIVEC_BUILTIN_VPERM_4SF,
ALTIVEC_BUILTIN_VPERM_8HI,
ALTIVEC_BUILTIN_VPERM_16QI,
ALTIVEC_BUILTIN_VPKUHUM,
ALTIVEC_BUILTIN_VPKUWUM,
ALTIVEC_BUILTIN_VPKPX,
ALTIVEC_BUILTIN_VPKUHSS,
ALTIVEC_BUILTIN_VPKSHSS,
ALTIVEC_BUILTIN_VPKUWSS,
ALTIVEC_BUILTIN_VPKSWSS,
ALTIVEC_BUILTIN_VPKUHUS,
ALTIVEC_BUILTIN_VPKSHUS,
ALTIVEC_BUILTIN_VPKUWUS,
ALTIVEC_BUILTIN_VPKSWUS,
ALTIVEC_BUILTIN_VREFP,
ALTIVEC_BUILTIN_VRFIM,
ALTIVEC_BUILTIN_VRFIN,
ALTIVEC_BUILTIN_VRFIP,
ALTIVEC_BUILTIN_VRFIZ,
ALTIVEC_BUILTIN_VRLB,
ALTIVEC_BUILTIN_VRLH,
ALTIVEC_BUILTIN_VRLW,
ALTIVEC_BUILTIN_VRSQRTEFP,
ALTIVEC_BUILTIN_VSLB,
ALTIVEC_BUILTIN_VSLH,
ALTIVEC_BUILTIN_VSLW,
ALTIVEC_BUILTIN_VSL,
ALTIVEC_BUILTIN_VSLO,
ALTIVEC_BUILTIN_VSPLTB,
ALTIVEC_BUILTIN_VSPLTH,
ALTIVEC_BUILTIN_VSPLTW,
ALTIVEC_BUILTIN_VSPLTISB,
ALTIVEC_BUILTIN_VSPLTISH,
ALTIVEC_BUILTIN_VSPLTISW,
ALTIVEC_BUILTIN_VSRB,
ALTIVEC_BUILTIN_VSRH,
ALTIVEC_BUILTIN_VSRW,
ALTIVEC_BUILTIN_VSRAB,
ALTIVEC_BUILTIN_VSRAH,
ALTIVEC_BUILTIN_VSRAW,
ALTIVEC_BUILTIN_VSR,
ALTIVEC_BUILTIN_VSRO,
ALTIVEC_BUILTIN_VSUBUBM,
ALTIVEC_BUILTIN_VSUBUHM,
ALTIVEC_BUILTIN_VSUBUWM,
ALTIVEC_BUILTIN_VSUBFP,
ALTIVEC_BUILTIN_VSUBCUW,
ALTIVEC_BUILTIN_VSUBUBS,
ALTIVEC_BUILTIN_VSUBSBS,
ALTIVEC_BUILTIN_VSUBUHS,
ALTIVEC_BUILTIN_VSUBSHS,
ALTIVEC_BUILTIN_VSUBUWS,
ALTIVEC_BUILTIN_VSUBSWS,
ALTIVEC_BUILTIN_VSUM4UBS,
ALTIVEC_BUILTIN_VSUM4SBS,
ALTIVEC_BUILTIN_VSUM4SHS,
ALTIVEC_BUILTIN_VSUM2SWS,
ALTIVEC_BUILTIN_VSUMSWS,
ALTIVEC_BUILTIN_VXOR,
ALTIVEC_BUILTIN_VSLDOI_16QI,
ALTIVEC_BUILTIN_VSLDOI_8HI,
ALTIVEC_BUILTIN_VSLDOI_4SI,
ALTIVEC_BUILTIN_VSLDOI_4SF,
ALTIVEC_BUILTIN_VUPKHSB,
ALTIVEC_BUILTIN_VUPKHPX,
ALTIVEC_BUILTIN_VUPKHSH,
ALTIVEC_BUILTIN_VUPKLSB,
ALTIVEC_BUILTIN_VUPKLPX,
ALTIVEC_BUILTIN_VUPKLSH,
ALTIVEC_BUILTIN_MTVSCR,
ALTIVEC_BUILTIN_MFVSCR,
ALTIVEC_BUILTIN_DSSALL,
ALTIVEC_BUILTIN_DSS,
ALTIVEC_BUILTIN_LVSL,
ALTIVEC_BUILTIN_LVSR,
ALTIVEC_BUILTIN_DSTT,
ALTIVEC_BUILTIN_DSTST,
ALTIVEC_BUILTIN_DSTSTT,
ALTIVEC_BUILTIN_DST,
ALTIVEC_BUILTIN_LVEBX,
ALTIVEC_BUILTIN_LVEHX,
ALTIVEC_BUILTIN_LVEWX,
ALTIVEC_BUILTIN_LVXL,
ALTIVEC_BUILTIN_LVX,
ALTIVEC_BUILTIN_STVX,
ALTIVEC_BUILTIN_STVEBX,
ALTIVEC_BUILTIN_STVEHX,
ALTIVEC_BUILTIN_STVEWX,
ALTIVEC_BUILTIN_STVXL,
ALTIVEC_BUILTIN_VCMPBFP_P,
ALTIVEC_BUILTIN_VCMPEQFP_P,
ALTIVEC_BUILTIN_VCMPEQUB_P,
ALTIVEC_BUILTIN_VCMPEQUH_P,
ALTIVEC_BUILTIN_VCMPEQUW_P,
ALTIVEC_BUILTIN_VCMPGEFP_P,
ALTIVEC_BUILTIN_VCMPGTFP_P,
ALTIVEC_BUILTIN_VCMPGTSB_P,
ALTIVEC_BUILTIN_VCMPGTSH_P,
ALTIVEC_BUILTIN_VCMPGTSW_P,
ALTIVEC_BUILTIN_VCMPGTUB_P,
ALTIVEC_BUILTIN_VCMPGTUH_P,
ALTIVEC_BUILTIN_VCMPGTUW_P,
ALTIVEC_BUILTIN_ABSS_V4SI,
ALTIVEC_BUILTIN_ABSS_V8HI,
ALTIVEC_BUILTIN_ABSS_V16QI,
ALTIVEC_BUILTIN_ABS_V4SI,
ALTIVEC_BUILTIN_ABS_V4SF,
ALTIVEC_BUILTIN_ABS_V8HI,
ALTIVEC_BUILTIN_ABS_V16QI
};