OSDN Git Service

c9856d12aca95427a83d0ad402bdc86e4b86c22e
[pf3gnuchains/gcc-fork.git] / gcc / config / rs6000 / rs6000.h
1 /* Definitions of target machine for GNU compiler, for IBM RS/6000.
2    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3    2000, 2001, 2002, 2003, 2004, 2005, 2006
4    Free Software Foundation, Inc.
5    Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
6
7    This file is part of GCC.
8
9    GCC is free software; you can redistribute it and/or modify it
10    under the terms of the GNU General Public License as published
11    by the Free Software Foundation; either version 2, or (at your
12    option) any later version.
13
14    GCC is distributed in the hope that it will be useful, but WITHOUT
15    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
16    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
17    License for more details.
18
19    You should have received a copy of the GNU General Public License
20    along with GCC; see the file COPYING.  If not, write to the
21    Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
22    MA 02110-1301, USA.  */
23
24 /* Note that some other tm.h files include this one and then override
25    many of the definitions.  */
26
27 /* Definitions for the object file format.  These are set at
28    compile-time.  */
29
30 #define OBJECT_XCOFF 1
31 #define OBJECT_ELF 2
32 #define OBJECT_PEF 3
33 #define OBJECT_MACHO 4
34
35 #define TARGET_ELF (TARGET_OBJECT_FORMAT == OBJECT_ELF)
36 #define TARGET_XCOFF (TARGET_OBJECT_FORMAT == OBJECT_XCOFF)
37 #define TARGET_MACOS (TARGET_OBJECT_FORMAT == OBJECT_PEF)
38 #define TARGET_MACHO (TARGET_OBJECT_FORMAT == OBJECT_MACHO)
39
40 #ifndef TARGET_AIX
41 #define TARGET_AIX 0
42 #endif
43
44 /* Control whether function entry points use a "dot" symbol when
45    ABI_AIX.  */
46 #define DOT_SYMBOLS 1
47
48 /* Default string to use for cpu if not specified.  */
49 #ifndef TARGET_CPU_DEFAULT
50 #define TARGET_CPU_DEFAULT ((char *)0)
51 #endif
52
53 /* If configured for PPC405, support PPC405CR Erratum77.  */
54 #ifdef CONFIG_PPC405CR
55 #define PPC405_ERRATUM77 (rs6000_cpu == PROCESSOR_PPC405)
56 #else
57 #define PPC405_ERRATUM77 0
58 #endif
59
60 /* Common ASM definitions used by ASM_SPEC among the various targets
61    for handling -mcpu=xxx switches.  */
62 #define ASM_CPU_SPEC \
63 "%{!mcpu*: \
64   %{mpower: %{!mpower2: -mpwr}} \
65   %{mpower2: -mpwrx} \
66   %{mpowerpc64*: -mppc64} \
67   %{!mpowerpc64*: %{mpowerpc*: -mppc}} \
68   %{mno-power: %{!mpowerpc*: -mcom}} \
69   %{!mno-power: %{!mpower*: %(asm_default)}}} \
70 %{mcpu=common: -mcom} \
71 %{mcpu=power: -mpwr} \
72 %{mcpu=power2: -mpwrx} \
73 %{mcpu=power3: -mppc64} \
74 %{mcpu=power4: -mpower4} \
75 %{mcpu=power5: -mpower4} \
76 %{mcpu=power5+: -mpower4} \
77 %{mcpu=power6: -mpower4 -maltivec} \
78 %{mcpu=power6x: -mpower4 -maltivec} \
79 %{mcpu=powerpc: -mppc} \
80 %{mcpu=rios: -mpwr} \
81 %{mcpu=rios1: -mpwr} \
82 %{mcpu=rios2: -mpwrx} \
83 %{mcpu=rsc: -mpwr} \
84 %{mcpu=rsc1: -mpwr} \
85 %{mcpu=rs64a: -mppc64} \
86 %{mcpu=401: -mppc} \
87 %{mcpu=403: -m403} \
88 %{mcpu=405: -m405} \
89 %{mcpu=405fp: -m405} \
90 %{mcpu=440: -m440} \
91 %{mcpu=440fp: -m440} \
92 %{mcpu=505: -mppc} \
93 %{mcpu=601: -m601} \
94 %{mcpu=602: -mppc} \
95 %{mcpu=603: -mppc} \
96 %{mcpu=603e: -mppc} \
97 %{mcpu=ec603e: -mppc} \
98 %{mcpu=604: -mppc} \
99 %{mcpu=604e: -mppc} \
100 %{mcpu=620: -mppc64} \
101 %{mcpu=630: -mppc64} \
102 %{mcpu=740: -mppc} \
103 %{mcpu=750: -mppc} \
104 %{mcpu=G3: -mppc} \
105 %{mcpu=7400: -mppc -maltivec} \
106 %{mcpu=7450: -mppc -maltivec} \
107 %{mcpu=G4: -mppc -maltivec} \
108 %{mcpu=801: -mppc} \
109 %{mcpu=821: -mppc} \
110 %{mcpu=823: -mppc} \
111 %{mcpu=860: -mppc} \
112 %{mcpu=970: -mpower4 -maltivec} \
113 %{mcpu=G5: -mpower4 -maltivec} \
114 %{mcpu=8540: -me500} \
115 %{maltivec: -maltivec} \
116 -many"
117
118 #define CPP_DEFAULT_SPEC ""
119
120 #define ASM_DEFAULT_SPEC ""
121
122 /* This macro defines names of additional specifications to put in the specs
123    that can be used in various specifications like CC1_SPEC.  Its definition
124    is an initializer with a subgrouping for each command option.
125
126    Each subgrouping contains a string constant, that defines the
127    specification name, and a string constant that used by the GCC driver
128    program.
129
130    Do not define this macro if it does not need to do anything.  */
131
132 #define SUBTARGET_EXTRA_SPECS
133
134 #define EXTRA_SPECS                                                     \
135   { "cpp_default",              CPP_DEFAULT_SPEC },                     \
136   { "asm_cpu",                  ASM_CPU_SPEC },                         \
137   { "asm_default",              ASM_DEFAULT_SPEC },                     \
138   SUBTARGET_EXTRA_SPECS
139
140 /* Architecture type.  */
141
142 /* Define TARGET_MFCRF if the target assembler does not support the
143    optional field operand for mfcr.  */
144
145 #ifndef HAVE_AS_MFCRF
146 #undef  TARGET_MFCRF
147 #define TARGET_MFCRF 0
148 #endif
149
150 /* Define TARGET_POPCNTB if the target assembler does not support the
151    popcount byte instruction.  */
152
153 #ifndef HAVE_AS_POPCNTB
154 #undef  TARGET_POPCNTB
155 #define TARGET_POPCNTB 0
156 #endif
157
158 /* Define TARGET_FPRND if the target assembler does not support the
159    fp rounding instructions.  */
160
161 #ifndef HAVE_AS_FPRND
162 #undef  TARGET_FPRND
163 #define TARGET_FPRND 0
164 #endif
165
166 /* Define TARGET_MFPGPR if the target assembler does not support the
167    mffpr and mftgpr instructions. */
168
169 #ifndef HAVE_AS_MFPGPR
170 #undef  TARGET_MFPGPR
171 #define TARGET_MFPGPR 0
172 #endif
173
174 #ifndef TARGET_SECURE_PLT
175 #define TARGET_SECURE_PLT 0
176 #endif
177
178 #define TARGET_32BIT            (! TARGET_64BIT)
179
180 #ifndef HAVE_AS_TLS
181 #define HAVE_AS_TLS 0
182 #endif
183
184 /* Return 1 for a symbol ref for a thread-local storage symbol.  */
185 #define RS6000_SYMBOL_REF_TLS_P(RTX) \
186   (GET_CODE (RTX) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (RTX) != 0)
187
188 #ifdef IN_LIBGCC2
189 /* For libgcc2 we make sure this is a compile time constant */
190 #if defined (__64BIT__) || defined (__powerpc64__) || defined (__ppc64__)
191 #undef TARGET_POWERPC64
192 #define TARGET_POWERPC64        1
193 #else
194 #undef TARGET_POWERPC64
195 #define TARGET_POWERPC64        0
196 #endif
197 #else
198     /* The option machinery will define this.  */
199 #endif
200
201 #define TARGET_DEFAULT (MASK_POWER | MASK_MULTIPLE | MASK_STRING)
202
203 /* Processor type.  Order must match cpu attribute in MD file.  */
204 enum processor_type
205  {
206    PROCESSOR_RIOS1,
207    PROCESSOR_RIOS2,
208    PROCESSOR_RS64A,
209    PROCESSOR_MPCCORE,
210    PROCESSOR_PPC403,
211    PROCESSOR_PPC405,
212    PROCESSOR_PPC440,
213    PROCESSOR_PPC601,
214    PROCESSOR_PPC603,
215    PROCESSOR_PPC604,
216    PROCESSOR_PPC604e,
217    PROCESSOR_PPC620,
218    PROCESSOR_PPC630,
219    PROCESSOR_PPC750,
220    PROCESSOR_PPC7400,
221    PROCESSOR_PPC7450,
222    PROCESSOR_PPC8540,
223    PROCESSOR_POWER4,
224    PROCESSOR_POWER5,
225    PROCESSOR_POWER6
226 };
227
228 extern enum processor_type rs6000_cpu;
229
230 /* Recast the processor type to the cpu attribute.  */
231 #define rs6000_cpu_attr ((enum attr_cpu)rs6000_cpu)
232
233 /* Define generic processor types based upon current deployment.  */
234 #define PROCESSOR_COMMON    PROCESSOR_PPC601
235 #define PROCESSOR_POWER     PROCESSOR_RIOS1
236 #define PROCESSOR_POWERPC   PROCESSOR_PPC604
237 #define PROCESSOR_POWERPC64 PROCESSOR_RS64A
238
239 /* Define the default processor.  This is overridden by other tm.h files.  */
240 #define PROCESSOR_DEFAULT   PROCESSOR_RIOS1
241 #define PROCESSOR_DEFAULT64 PROCESSOR_RS64A
242
243 /* Specify the dialect of assembler to use.  New mnemonics is dialect one
244    and the old mnemonics are dialect zero.  */
245 #define ASSEMBLER_DIALECT (TARGET_NEW_MNEMONICS ? 1 : 0)
246
247 /* Types of costly dependences.  */
248 enum rs6000_dependence_cost
249  {
250    max_dep_latency = 1000,
251    no_dep_costly,
252    all_deps_costly,
253    true_store_to_load_dep_costly,
254    store_to_load_dep_costly
255  };
256
257 /* Types of nop insertion schemes in sched target hook sched_finish.  */
258 enum rs6000_nop_insertion
259   {
260     sched_finish_regroup_exact = 1000,
261     sched_finish_pad_groups,
262     sched_finish_none
263   };
264
265 /* Dispatch group termination caused by an insn.  */
266 enum group_termination
267   {
268     current_group,
269     previous_group
270   };
271
272 /* Support for a compile-time default CPU, et cetera.  The rules are:
273    --with-cpu is ignored if -mcpu is specified.
274    --with-tune is ignored if -mtune is specified.
275    --with-float is ignored if -mhard-float or -msoft-float are
276     specified.  */
277 #define OPTION_DEFAULT_SPECS \
278   {"cpu", "%{!mcpu=*:-mcpu=%(VALUE)}" }, \
279   {"tune", "%{!mtune=*:-mtune=%(VALUE)}" }, \
280   {"float", "%{!msoft-float:%{!mhard-float:-m%(VALUE)-float}}" }
281
282 /* rs6000_select[0] is reserved for the default cpu defined via --with-cpu */
283 struct rs6000_cpu_select
284 {
285   const char *string;
286   const char *name;
287   int set_tune_p;
288   int set_arch_p;
289 };
290
291 extern struct rs6000_cpu_select rs6000_select[];
292
293 /* Debug support */
294 extern const char *rs6000_debug_name;   /* Name for -mdebug-xxxx option */
295 extern int rs6000_debug_stack;          /* debug stack applications */
296 extern int rs6000_debug_arg;            /* debug argument handling */
297
298 #define TARGET_DEBUG_STACK      rs6000_debug_stack
299 #define TARGET_DEBUG_ARG        rs6000_debug_arg
300
301 extern const char *rs6000_traceback_name; /* Type of traceback table.  */
302
303 /* These are separate from target_flags because we've run out of bits
304    there.  */
305 extern int rs6000_long_double_type_size;
306 extern int rs6000_ieeequad;
307 extern int rs6000_altivec_abi;
308 extern int rs6000_spe_abi;
309 extern int rs6000_float_gprs;
310 extern int rs6000_alignment_flags;
311 extern const char *rs6000_sched_insert_nops_str;
312 extern enum rs6000_nop_insertion rs6000_sched_insert_nops;
313
314 /* Alignment options for fields in structures for sub-targets following
315    AIX-like ABI.
316    ALIGN_POWER word-aligns FP doubles (default AIX ABI).
317    ALIGN_NATURAL doubleword-aligns FP doubles (align to object size).
318
319    Override the macro definitions when compiling libobjc to avoid undefined
320    reference to rs6000_alignment_flags due to library's use of GCC alignment
321    macros which use the macros below.  */
322
323 #ifndef IN_TARGET_LIBS
324 #define MASK_ALIGN_POWER   0x00000000
325 #define MASK_ALIGN_NATURAL 0x00000001
326 #define TARGET_ALIGN_NATURAL (rs6000_alignment_flags & MASK_ALIGN_NATURAL)
327 #else
328 #define TARGET_ALIGN_NATURAL 0
329 #endif
330
331 #define TARGET_LONG_DOUBLE_128 (rs6000_long_double_type_size == 128)
332 #define TARGET_IEEEQUAD rs6000_ieeequad
333 #define TARGET_ALTIVEC_ABI rs6000_altivec_abi
334
335 #define TARGET_SPE_ABI 0
336 #define TARGET_SPE 0
337 #define TARGET_E500 0
338 #define TARGET_ISEL 0
339 #define TARGET_FPRS 1
340 #define TARGET_E500_SINGLE 0
341 #define TARGET_E500_DOUBLE 0
342
343 /* Sometimes certain combinations of command options do not make sense
344    on a particular target machine.  You can define a macro
345    `OVERRIDE_OPTIONS' to take account of this.  This macro, if
346    defined, is executed once just after all the command options have
347    been parsed.
348
349    Do not use this macro to turn on various extra optimizations for
350    `-O'.  That is what `OPTIMIZATION_OPTIONS' is for.
351
352    On the RS/6000 this is used to define the target cpu type.  */
353
354 #define OVERRIDE_OPTIONS rs6000_override_options (TARGET_CPU_DEFAULT)
355
356 /* Define this to change the optimizations performed by default.  */
357 #define OPTIMIZATION_OPTIONS(LEVEL,SIZE) optimization_options(LEVEL,SIZE)
358
359 /* Show we can debug even without a frame pointer.  */
360 #define CAN_DEBUG_WITHOUT_FP
361
362 /* Target pragma.  */
363 #define REGISTER_TARGET_PRAGMAS() do {                          \
364   c_register_pragma (0, "longcall", rs6000_pragma_longcall);    \
365   targetm.resolve_overloaded_builtin = altivec_resolve_overloaded_builtin; \
366 } while (0)
367
368 /* Target #defines.  */
369 #define TARGET_CPU_CPP_BUILTINS() \
370   rs6000_cpu_cpp_builtins (pfile)
371
372 /* This is used by rs6000_cpu_cpp_builtins to indicate the byte order
373    we're compiling for.  Some configurations may need to override it.  */
374 #define RS6000_CPU_CPP_ENDIAN_BUILTINS()        \
375   do                                            \
376     {                                           \
377       if (BYTES_BIG_ENDIAN)                     \
378         {                                       \
379           builtin_define ("__BIG_ENDIAN__");    \
380           builtin_define ("_BIG_ENDIAN");       \
381           builtin_assert ("machine=bigendian"); \
382         }                                       \
383       else                                      \
384         {                                       \
385           builtin_define ("__LITTLE_ENDIAN__"); \
386           builtin_define ("_LITTLE_ENDIAN");    \
387           builtin_assert ("machine=littleendian"); \
388         }                                       \
389     }                                           \
390   while (0)
391 \f
392 /* Target machine storage layout.  */
393
394 /* Define this macro if it is advisable to hold scalars in registers
395    in a wider mode than that declared by the program.  In such cases,
396    the value is constrained to be within the bounds of the declared
397    type, but kept valid in the wider mode.  The signedness of the
398    extension may differ from that of the type.  */
399
400 #define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE)       \
401   if (GET_MODE_CLASS (MODE) == MODE_INT         \
402       && GET_MODE_SIZE (MODE) < UNITS_PER_WORD) \
403     (MODE) = TARGET_32BIT ? SImode : DImode;
404
405 /* Define this if most significant bit is lowest numbered
406    in instructions that operate on numbered bit-fields.  */
407 /* That is true on RS/6000.  */
408 #define BITS_BIG_ENDIAN 1
409
410 /* Define this if most significant byte of a word is the lowest numbered.  */
411 /* That is true on RS/6000.  */
412 #define BYTES_BIG_ENDIAN 1
413
414 /* Define this if most significant word of a multiword number is lowest
415    numbered.
416
417    For RS/6000 we can decide arbitrarily since there are no machine
418    instructions for them.  Might as well be consistent with bits and bytes.  */
419 #define WORDS_BIG_ENDIAN 1
420
421 #define MAX_BITS_PER_WORD 64
422
423 /* Width of a word, in units (bytes).  */
424 #define UNITS_PER_WORD (! TARGET_POWERPC64 ? 4 : 8)
425 #ifdef IN_LIBGCC2
426 #define MIN_UNITS_PER_WORD UNITS_PER_WORD
427 #else
428 #define MIN_UNITS_PER_WORD 4
429 #endif
430 #define UNITS_PER_FP_WORD 8
431 #define UNITS_PER_ALTIVEC_WORD 16
432 #define UNITS_PER_SPE_WORD 8
433
434 /* Type used for ptrdiff_t, as a string used in a declaration.  */
435 #define PTRDIFF_TYPE "int"
436
437 /* Type used for size_t, as a string used in a declaration.  */
438 #define SIZE_TYPE "long unsigned int"
439
440 /* Type used for wchar_t, as a string used in a declaration.  */
441 #define WCHAR_TYPE "short unsigned int"
442
443 /* Width of wchar_t in bits.  */
444 #define WCHAR_TYPE_SIZE 16
445
446 /* A C expression for the size in bits of the type `short' on the
447    target machine.  If you don't define this, the default is half a
448    word.  (If this would be less than one storage unit, it is
449    rounded up to one unit.)  */
450 #define SHORT_TYPE_SIZE 16
451
452 /* A C expression for the size in bits of the type `int' on the
453    target machine.  If you don't define this, the default is one
454    word.  */
455 #define INT_TYPE_SIZE 32
456
457 /* A C expression for the size in bits of the type `long' on the
458    target machine.  If you don't define this, the default is one
459    word.  */
460 #define LONG_TYPE_SIZE (TARGET_32BIT ? 32 : 64)
461
462 /* A C expression for the size in bits of the type `long long' on the
463    target machine.  If you don't define this, the default is two
464    words.  */
465 #define LONG_LONG_TYPE_SIZE 64
466
467 /* A C expression for the size in bits of the type `float' on the
468    target machine.  If you don't define this, the default is one
469    word.  */
470 #define FLOAT_TYPE_SIZE 32
471
472 /* A C expression for the size in bits of the type `double' on the
473    target machine.  If you don't define this, the default is two
474    words.  */
475 #define DOUBLE_TYPE_SIZE 64
476
477 /* A C expression for the size in bits of the type `long double' on
478    the target machine.  If you don't define this, the default is two
479    words.  */
480 #define LONG_DOUBLE_TYPE_SIZE rs6000_long_double_type_size
481
482 /* Define this to set long double type size to use in libgcc2.c, which can
483    not depend on target_flags.  */
484 #ifdef __LONG_DOUBLE_128__
485 #define LIBGCC2_LONG_DOUBLE_TYPE_SIZE 128
486 #else
487 #define LIBGCC2_LONG_DOUBLE_TYPE_SIZE 64
488 #endif
489
490 /* Work around rs6000_long_double_type_size dependency in ada/targtyps.c.  */
491 #define WIDEST_HARDWARE_FP_SIZE 64
492
493 /* Width in bits of a pointer.
494    See also the macro `Pmode' defined below.  */
495 #define POINTER_SIZE (TARGET_32BIT ? 32 : 64)
496
497 /* Allocation boundary (in *bits*) for storing arguments in argument list.  */
498 #define PARM_BOUNDARY (TARGET_32BIT ? 32 : 64)
499
500 /* Boundary (in *bits*) on which stack pointer should be aligned.  */
501 #define STACK_BOUNDARY \
502   ((TARGET_32BIT && !TARGET_ALTIVEC && !TARGET_ALTIVEC_ABI) ? 64 : 128)
503
504 /* Allocation boundary (in *bits*) for the code of a function.  */
505 #define FUNCTION_BOUNDARY 32
506
507 /* No data type wants to be aligned rounder than this.  */
508 #define BIGGEST_ALIGNMENT 128
509
510 /* A C expression to compute the alignment for a variables in the
511    local store.  TYPE is the data type, and ALIGN is the alignment
512    that the object would ordinarily have.  */
513 #define LOCAL_ALIGNMENT(TYPE, ALIGN)                            \
514   ((TARGET_ALTIVEC && TREE_CODE (TYPE) == VECTOR_TYPE) ? 128 :  \
515     (TARGET_E500_DOUBLE && TYPE_MODE (TYPE) == DFmode) ? 64 : \
516     (TARGET_SPE && TREE_CODE (TYPE) == VECTOR_TYPE \
517      && SPE_VECTOR_MODE (TYPE_MODE (TYPE))) ? 64 : ALIGN)
518
519 /* Alignment of field after `int : 0' in a structure.  */
520 #define EMPTY_FIELD_BOUNDARY 32
521
522 /* Every structure's size must be a multiple of this.  */
523 #define STRUCTURE_SIZE_BOUNDARY 8
524
525 /* Return 1 if a structure or array containing FIELD should be
526    accessed using `BLKMODE'.
527
528    For the SPE, simd types are V2SI, and gcc can be tempted to put the
529    entire thing in a DI and use subregs to access the internals.
530    store_bit_field() will force (subreg:DI (reg:V2SI x))'s to the
531    back-end.  Because a single GPR can hold a V2SI, but not a DI, the
532    best thing to do is set structs to BLKmode and avoid Severe Tire
533    Damage.
534
535    On e500 v2, DF and DI modes suffer from the same anomaly.  DF can
536    fit into 1, whereas DI still needs two.  */
537 #define MEMBER_TYPE_FORCES_BLK(FIELD, MODE) \
538   ((TARGET_SPE && TREE_CODE (TREE_TYPE (FIELD)) == VECTOR_TYPE) \
539    || (TARGET_E500_DOUBLE && (MODE) == DFmode))
540
541 /* A bit-field declared as `int' forces `int' alignment for the struct.  */
542 #define PCC_BITFIELD_TYPE_MATTERS 1
543
544 /* Make strings word-aligned so strcpy from constants will be faster.
545    Make vector constants quadword aligned.  */
546 #define CONSTANT_ALIGNMENT(EXP, ALIGN)                           \
547   (TREE_CODE (EXP) == STRING_CST                                 \
548    && (ALIGN) < BITS_PER_WORD                                    \
549    ? BITS_PER_WORD                                               \
550    : (ALIGN))
551
552 /* Make arrays of chars word-aligned for the same reasons.
553    Align vectors to 128 bits.  Align SPE vectors and E500 v2 doubles to
554    64 bits.  */
555 #define DATA_ALIGNMENT(TYPE, ALIGN)             \
556   (TREE_CODE (TYPE) == VECTOR_TYPE ? (TARGET_SPE_ABI ? 64 : 128)        \
557    : (TARGET_E500_DOUBLE && TYPE_MODE (TYPE) == DFmode) ? 64 \
558    : TREE_CODE (TYPE) == ARRAY_TYPE             \
559    && TYPE_MODE (TREE_TYPE (TYPE)) == QImode    \
560    && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
561
562 /* Nonzero if move instructions will actually fail to work
563    when given unaligned data.  */
564 #define STRICT_ALIGNMENT 0
565
566 /* Define this macro to be the value 1 if unaligned accesses have a cost
567    many times greater than aligned accesses, for example if they are
568    emulated in a trap handler.  */
569 #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN)                              \
570   (STRICT_ALIGNMENT                                                     \
571    || (((MODE) == SFmode || (MODE) == DFmode || (MODE) == TFmode        \
572         || (MODE) == DImode)                                            \
573        && (ALIGN) < 32))
574 \f
575 /* Standard register usage.  */
576
577 /* Number of actual hardware registers.
578    The hardware registers are assigned numbers for the compiler
579    from 0 to just below FIRST_PSEUDO_REGISTER.
580    All registers that the compiler knows about must be given numbers,
581    even those that are not normally considered general registers.
582
583    RS/6000 has 32 fixed-point registers, 32 floating-point registers,
584    an MQ register, a count register, a link register, and 8 condition
585    register fields, which we view here as separate registers.  AltiVec
586    adds 32 vector registers and a VRsave register.
587
588    In addition, the difference between the frame and argument pointers is
589    a function of the number of registers saved, so we need to have a
590    register for AP that will later be eliminated in favor of SP or FP.
591    This is a normal register, but it is fixed.
592
593    We also create a pseudo register for float/int conversions, that will
594    really represent the memory location used.  It is represented here as
595    a register, in order to work around problems in allocating stack storage
596    in inline functions.
597
598    Another pseudo (not included in DWARF_FRAME_REGISTERS) is soft frame
599    pointer, which is eventually eliminated in favor of SP or FP.  */
600
601 #define FIRST_PSEUDO_REGISTER 114
602
603 /* This must be included for pre gcc 3.0 glibc compatibility.  */
604 #define PRE_GCC3_DWARF_FRAME_REGISTERS 77
605
606 /* Add 32 dwarf columns for synthetic SPE registers.  */
607 #define DWARF_FRAME_REGISTERS ((FIRST_PSEUDO_REGISTER - 1) + 32)
608
609 /* The SPE has an additional 32 synthetic registers, with DWARF debug
610    info numbering for these registers starting at 1200.  While eh_frame
611    register numbering need not be the same as the debug info numbering,
612    we choose to number these regs for eh_frame at 1200 too.  This allows
613    future versions of the rs6000 backend to add hard registers and
614    continue to use the gcc hard register numbering for eh_frame.  If the
615    extra SPE registers in eh_frame were numbered starting from the
616    current value of FIRST_PSEUDO_REGISTER, then if FIRST_PSEUDO_REGISTER
617    changed we'd need to introduce a mapping in DWARF_FRAME_REGNUM to
618    avoid invalidating older SPE eh_frame info.
619
620    We must map them here to avoid huge unwinder tables mostly consisting
621    of unused space.  */
622 #define DWARF_REG_TO_UNWIND_COLUMN(r) \
623   ((r) > 1200 ? ((r) - 1200 + FIRST_PSEUDO_REGISTER - 1) : (r))
624
625 /* Use standard DWARF numbering for DWARF debugging information.  */
626 #define DBX_REGISTER_NUMBER(REGNO) rs6000_dbx_register_number (REGNO)
627
628 /* Use gcc hard register numbering for eh_frame.  */
629 #define DWARF_FRAME_REGNUM(REGNO) (REGNO)
630
631 /* Map register numbers held in the call frame info that gcc has
632    collected using DWARF_FRAME_REGNUM to those that should be output in
633    .debug_frame and .eh_frame.  We continue to use gcc hard reg numbers
634    for .eh_frame, but use the numbers mandated by the various ABIs for
635    .debug_frame.  rs6000_emit_prologue has translated any combination of
636    CR2, CR3, CR4 saves to a save of CR2.  The actual code emitted saves
637    the whole of CR, so we map CR2_REGNO to the DWARF reg for CR.  */
638 #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH)     \
639   ((FOR_EH) ? (REGNO)                           \
640    : (REGNO) == CR2_REGNO ? 64                  \
641    : DBX_REGISTER_NUMBER (REGNO))
642
643 /* 1 for registers that have pervasive standard uses
644    and are not available for the register allocator.
645
646    On RS/6000, r1 is used for the stack.  On Darwin, r2 is available
647    as a local register; for all other OS's r2 is the TOC pointer.
648
649    cr5 is not supposed to be used.
650
651    On System V implementations, r13 is fixed and not available for use.  */
652
653 #define FIXED_REGISTERS  \
654   {0, 1, FIXED_R2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, FIXED_R13, 0, 0, \
655    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
656    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
657    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
658    0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1,          \
659    /* AltiVec registers.  */                       \
660    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
661    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
662    1, 1                                            \
663    , 1, 1, 1                                       \
664 }
665
666 /* 1 for registers not available across function calls.
667    These must include the FIXED_REGISTERS and also any
668    registers that can be used without being saved.
669    The latter must include the registers where values are returned
670    and the register where structure-value addresses are passed.
671    Aside from that, you can include as many other registers as you like.  */
672
673 #define CALL_USED_REGISTERS  \
674   {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, FIXED_R13, 0, 0, \
675    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
676    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, \
677    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
678    1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1,          \
679    /* AltiVec registers.  */                       \
680    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
681    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
682    1, 1                                            \
683    , 1, 1, 1                                       \
684 }
685
686 /* Like `CALL_USED_REGISTERS' except this macro doesn't require that
687    the entire set of `FIXED_REGISTERS' be included.
688    (`CALL_USED_REGISTERS' must be a superset of `FIXED_REGISTERS').
689    This macro is optional.  If not specified, it defaults to the value
690    of `CALL_USED_REGISTERS'.  */
691
692 #define CALL_REALLY_USED_REGISTERS  \
693   {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, FIXED_R13, 0, 0, \
694    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
695    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, \
696    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
697    1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1,          \
698    /* AltiVec registers.  */                       \
699    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
700    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
701    0, 0                                            \
702    , 0, 0, 0                                       \
703 }
704
705 #define MQ_REGNO     64
706 #define CR0_REGNO    68
707 #define CR1_REGNO    69
708 #define CR2_REGNO    70
709 #define CR3_REGNO    71
710 #define CR4_REGNO    72
711 #define MAX_CR_REGNO 75
712 #define XER_REGNO    76
713 #define FIRST_ALTIVEC_REGNO     77
714 #define LAST_ALTIVEC_REGNO      108
715 #define TOTAL_ALTIVEC_REGS      (LAST_ALTIVEC_REGNO - FIRST_ALTIVEC_REGNO + 1)
716 #define VRSAVE_REGNO            109
717 #define VSCR_REGNO              110
718 #define SPE_ACC_REGNO           111
719 #define SPEFSCR_REGNO           112
720
721 #define FIRST_SAVED_ALTIVEC_REGNO (FIRST_ALTIVEC_REGNO+20)
722 #define FIRST_SAVED_FP_REGNO    (14+32)
723 #define FIRST_SAVED_GP_REGNO 13
724
725 /* List the order in which to allocate registers.  Each register must be
726    listed once, even those in FIXED_REGISTERS.
727
728    We allocate in the following order:
729         fp0             (not saved or used for anything)
730         fp13 - fp2      (not saved; incoming fp arg registers)
731         fp1             (not saved; return value)
732         fp31 - fp14     (saved; order given to save least number)
733         cr7, cr6        (not saved or special)
734         cr1             (not saved, but used for FP operations)
735         cr0             (not saved, but used for arithmetic operations)
736         cr4, cr3, cr2   (saved)
737         r0              (not saved; cannot be base reg)
738         r9              (not saved; best for TImode)
739         r11, r10, r8-r4 (not saved; highest used first to make less conflict)
740         r3              (not saved; return value register)
741         r31 - r13       (saved; order given to save least number)
742         r12             (not saved; if used for DImode or DFmode would use r13)
743         mq              (not saved; best to use it if we can)
744         ctr             (not saved; when we have the choice ctr is better)
745         lr              (saved)
746         cr5, r1, r2, ap, xer (fixed)
747         v0 - v1         (not saved or used for anything)
748         v13 - v3        (not saved; incoming vector arg registers)
749         v2              (not saved; incoming vector arg reg; return value)
750         v19 - v14       (not saved or used for anything)
751         v31 - v20       (saved; order given to save least number)
752         vrsave, vscr    (fixed)
753         spe_acc, spefscr (fixed)
754         sfp             (fixed)
755 */
756
757 #if FIXED_R2 == 1
758 #define MAYBE_R2_AVAILABLE
759 #define MAYBE_R2_FIXED 2,
760 #else
761 #define MAYBE_R2_AVAILABLE 2,
762 #define MAYBE_R2_FIXED
763 #endif
764
765 #define REG_ALLOC_ORDER                                         \
766   {32,                                                          \
767    45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34,              \
768    33,                                                          \
769    63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51,          \
770    50, 49, 48, 47, 46,                                          \
771    75, 74, 69, 68, 72, 71, 70,                                  \
772    0, MAYBE_R2_AVAILABLE                                        \
773    9, 11, 10, 8, 7, 6, 5, 4,                                    \
774    3,                                                           \
775    31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19,          \
776    18, 17, 16, 15, 14, 13, 12,                                  \
777    64, 66, 65,                                                  \
778    73, 1, MAYBE_R2_FIXED 67, 76,                                \
779    /* AltiVec registers.  */                                    \
780    77, 78,                                                      \
781    90, 89, 88, 87, 86, 85, 84, 83, 82, 81, 80,                  \
782    79,                                                          \
783    96, 95, 94, 93, 92, 91,                                      \
784    108, 107, 106, 105, 104, 103, 102, 101, 100, 99, 98, 97,     \
785    109, 110,                                                    \
786    111, 112, 113                                                \
787 }
788
789 /* True if register is floating-point.  */
790 #define FP_REGNO_P(N) ((N) >= 32 && (N) <= 63)
791
792 /* True if register is a condition register.  */
793 #define CR_REGNO_P(N) ((N) >= 68 && (N) <= 75)
794
795 /* True if register is a condition register, but not cr0.  */
796 #define CR_REGNO_NOT_CR0_P(N) ((N) >= 69 && (N) <= 75)
797
798 /* True if register is an integer register.  */
799 #define INT_REGNO_P(N) \
800   ((N) <= 31 || (N) == ARG_POINTER_REGNUM || (N) == FRAME_POINTER_REGNUM)
801
802 /* SPE SIMD registers are just the GPRs.  */
803 #define SPE_SIMD_REGNO_P(N) ((N) <= 31)
804
805 /* True if register is the XER register.  */
806 #define XER_REGNO_P(N) ((N) == XER_REGNO)
807
808 /* True if register is an AltiVec register.  */
809 #define ALTIVEC_REGNO_P(N) ((N) >= FIRST_ALTIVEC_REGNO && (N) <= LAST_ALTIVEC_REGNO)
810
811 /* Return number of consecutive hard regs needed starting at reg REGNO
812    to hold something of mode MODE.  */
813
814 #define HARD_REGNO_NREGS(REGNO, MODE) rs6000_hard_regno_nregs ((REGNO), (MODE))
815
816 #define HARD_REGNO_CALL_PART_CLOBBERED(REGNO, MODE)     \
817   ((TARGET_32BIT && TARGET_POWERPC64                    \
818     && (GET_MODE_SIZE (MODE) > 4)  \
819     && INT_REGNO_P (REGNO)) ? 1 : 0)
820
821 #define ALTIVEC_VECTOR_MODE(MODE)       \
822          ((MODE) == V16QImode           \
823           || (MODE) == V8HImode         \
824           || (MODE) == V4SFmode         \
825           || (MODE) == V4SImode)
826
827 #define SPE_VECTOR_MODE(MODE)           \
828         ((MODE) == V4HImode             \
829          || (MODE) == V2SFmode          \
830          || (MODE) == V1DImode          \
831          || (MODE) == V2SImode)
832
833 #define UNITS_PER_SIMD_WORD                                     \
834         (TARGET_ALTIVEC ? UNITS_PER_ALTIVEC_WORD                \
835          : (TARGET_SPE ? UNITS_PER_SPE_WORD : UNITS_PER_WORD))
836
837 /* Value is TRUE if hard register REGNO can hold a value of
838    machine-mode MODE.  */
839 #define HARD_REGNO_MODE_OK(REGNO, MODE) \
840   rs6000_hard_regno_mode_ok_p[(int)(MODE)][REGNO]
841
842 /* Value is 1 if it is a good idea to tie two pseudo registers
843    when one has mode MODE1 and one has mode MODE2.
844    If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2,
845    for any hard reg, then this must be 0 for correct output.  */
846 #define MODES_TIEABLE_P(MODE1, MODE2) \
847   (SCALAR_FLOAT_MODE_P (MODE1)                  \
848    ? SCALAR_FLOAT_MODE_P (MODE2)                \
849    : SCALAR_FLOAT_MODE_P (MODE2)                \
850    ? SCALAR_FLOAT_MODE_P (MODE1)                \
851    : GET_MODE_CLASS (MODE1) == MODE_CC          \
852    ? GET_MODE_CLASS (MODE2) == MODE_CC          \
853    : GET_MODE_CLASS (MODE2) == MODE_CC          \
854    ? GET_MODE_CLASS (MODE1) == MODE_CC          \
855    : SPE_VECTOR_MODE (MODE1)                    \
856    ? SPE_VECTOR_MODE (MODE2)                    \
857    : SPE_VECTOR_MODE (MODE2)                    \
858    ? SPE_VECTOR_MODE (MODE1)                    \
859    : ALTIVEC_VECTOR_MODE (MODE1)                \
860    ? ALTIVEC_VECTOR_MODE (MODE2)                \
861    : ALTIVEC_VECTOR_MODE (MODE2)                \
862    ? ALTIVEC_VECTOR_MODE (MODE1)                \
863    : 1)
864
865 /* Post-reload, we can't use any new AltiVec registers, as we already
866    emitted the vrsave mask.  */
867
868 #define HARD_REGNO_RENAME_OK(SRC, DST) \
869   (! ALTIVEC_REGNO_P (DST) || regs_ever_live[DST])
870
871 /* A C expression returning the cost of moving data from a register of class
872    CLASS1 to one of CLASS2.  */
873
874 #define REGISTER_MOVE_COST rs6000_register_move_cost
875
876 /* A C expressions returning the cost of moving data of MODE from a register to
877    or from memory.  */
878
879 #define MEMORY_MOVE_COST rs6000_memory_move_cost
880
881 /* Specify the cost of a branch insn; roughly the number of extra insns that
882    should be added to avoid a branch.
883
884    Set this to 3 on the RS/6000 since that is roughly the average cost of an
885    unscheduled conditional branch.  */
886
887 #define BRANCH_COST 3
888
889 /* Override BRANCH_COST heuristic which empirically produces worse
890    performance for removing short circuiting from the logical ops.  */
891
892 #define LOGICAL_OP_NON_SHORT_CIRCUIT 0
893
894 /* A fixed register used at prologue and epilogue generation to fix
895    addressing modes.  The SPE needs heavy addressing fixes at the last
896    minute, and it's best to save a register for it.
897
898    AltiVec also needs fixes, but we've gotten around using r11, which
899    is actually wrong because when use_backchain_to_restore_sp is true,
900    we end up clobbering r11.
901
902    The AltiVec case needs to be fixed.  Dunno if we should break ABI
903    compatibility and reserve a register for it as well..  */
904
905 #define FIXED_SCRATCH (TARGET_SPE ? 14 : 11)
906
907 /* Define this macro to change register usage conditional on target
908    flags.  */
909
910 #define CONDITIONAL_REGISTER_USAGE rs6000_conditional_register_usage ()
911
912 /* Specify the registers used for certain standard purposes.
913    The values of these macros are register numbers.  */
914
915 /* RS/6000 pc isn't overloaded on a register that the compiler knows about.  */
916 /* #define PC_REGNUM  */
917
918 /* Register to use for pushing function arguments.  */
919 #define STACK_POINTER_REGNUM 1
920
921 /* Base register for access to local variables of the function.  */
922 #define HARD_FRAME_POINTER_REGNUM 31
923
924 /* Base register for access to local variables of the function.  */
925 #define FRAME_POINTER_REGNUM 113
926
927 /* Value should be nonzero if functions must have frame pointers.
928    Zero means the frame pointer need not be set up (and parms
929    may be accessed via the stack pointer) in functions that seem suitable.
930    This is computed in `reload', in reload1.c.  */
931 #define FRAME_POINTER_REQUIRED 0
932
933 /* Base register for access to arguments of the function.  */
934 #define ARG_POINTER_REGNUM 67
935
936 /* Place to put static chain when calling a function that requires it.  */
937 #define STATIC_CHAIN_REGNUM 11
938
939 /* Link register number.  */
940 #define LINK_REGISTER_REGNUM 65
941
942 /* Count register number.  */
943 #define COUNT_REGISTER_REGNUM 66
944 \f
945 /* Define the classes of registers for register constraints in the
946    machine description.  Also define ranges of constants.
947
948    One of the classes must always be named ALL_REGS and include all hard regs.
949    If there is more than one class, another class must be named NO_REGS
950    and contain no registers.
951
952    The name GENERAL_REGS must be the name of a class (or an alias for
953    another name such as ALL_REGS).  This is the class of registers
954    that is allowed by "g" or "r" in a register constraint.
955    Also, registers outside this class are allocated only when
956    instructions express preferences for them.
957
958    The classes must be numbered in nondecreasing order; that is,
959    a larger-numbered class must never be contained completely
960    in a smaller-numbered class.
961
962    For any two classes, it is very desirable that there be another
963    class that represents their union.  */
964
965 /* The RS/6000 has three types of registers, fixed-point, floating-point,
966    and condition registers, plus three special registers, MQ, CTR, and the
967    link register.  AltiVec adds a vector register class.
968
969    However, r0 is special in that it cannot be used as a base register.
970    So make a class for registers valid as base registers.
971
972    Also, cr0 is the only condition code register that can be used in
973    arithmetic insns, so make a separate class for it.  */
974
975 enum reg_class
976 {
977   NO_REGS,
978   BASE_REGS,
979   GENERAL_REGS,
980   FLOAT_REGS,
981   ALTIVEC_REGS,
982   VRSAVE_REGS,
983   VSCR_REGS,
984   SPE_ACC_REGS,
985   SPEFSCR_REGS,
986   NON_SPECIAL_REGS,
987   MQ_REGS,
988   LINK_REGS,
989   CTR_REGS,
990   LINK_OR_CTR_REGS,
991   SPECIAL_REGS,
992   SPEC_OR_GEN_REGS,
993   CR0_REGS,
994   CR_REGS,
995   NON_FLOAT_REGS,
996   XER_REGS,
997   ALL_REGS,
998   LIM_REG_CLASSES
999 };
1000
1001 #define N_REG_CLASSES (int) LIM_REG_CLASSES
1002
1003 /* Give names of register classes as strings for dump file.  */
1004
1005 #define REG_CLASS_NAMES                                                 \
1006 {                                                                       \
1007   "NO_REGS",                                                            \
1008   "BASE_REGS",                                                          \
1009   "GENERAL_REGS",                                                       \
1010   "FLOAT_REGS",                                                         \
1011   "ALTIVEC_REGS",                                                       \
1012   "VRSAVE_REGS",                                                        \
1013   "VSCR_REGS",                                                          \
1014   "SPE_ACC_REGS",                                                       \
1015   "SPEFSCR_REGS",                                                       \
1016   "NON_SPECIAL_REGS",                                                   \
1017   "MQ_REGS",                                                            \
1018   "LINK_REGS",                                                          \
1019   "CTR_REGS",                                                           \
1020   "LINK_OR_CTR_REGS",                                                   \
1021   "SPECIAL_REGS",                                                       \
1022   "SPEC_OR_GEN_REGS",                                                   \
1023   "CR0_REGS",                                                           \
1024   "CR_REGS",                                                            \
1025   "NON_FLOAT_REGS",                                                     \
1026   "XER_REGS",                                                           \
1027   "ALL_REGS"                                                            \
1028 }
1029
1030 /* Define which registers fit in which classes.
1031    This is an initializer for a vector of HARD_REG_SET
1032    of length N_REG_CLASSES.  */
1033
1034 #define REG_CLASS_CONTENTS                                                   \
1035 {                                                                            \
1036   { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }, /* NO_REGS */          \
1037   { 0xfffffffe, 0x00000000, 0x00000008, 0x00020000 }, /* BASE_REGS */        \
1038   { 0xffffffff, 0x00000000, 0x00000008, 0x00020000 }, /* GENERAL_REGS */     \
1039   { 0x00000000, 0xffffffff, 0x00000000, 0x00000000 }, /* FLOAT_REGS */       \
1040   { 0x00000000, 0x00000000, 0xffffe000, 0x00001fff }, /* ALTIVEC_REGS */     \
1041   { 0x00000000, 0x00000000, 0x00000000, 0x00002000 }, /* VRSAVE_REGS */      \
1042   { 0x00000000, 0x00000000, 0x00000000, 0x00004000 }, /* VSCR_REGS */        \
1043   { 0x00000000, 0x00000000, 0x00000000, 0x00008000 }, /* SPE_ACC_REGS */     \
1044   { 0x00000000, 0x00000000, 0x00000000, 0x00010000 }, /* SPEFSCR_REGS */     \
1045   { 0xffffffff, 0xffffffff, 0x00000008, 0x00020000 }, /* NON_SPECIAL_REGS */ \
1046   { 0x00000000, 0x00000000, 0x00000001, 0x00000000 }, /* MQ_REGS */          \
1047   { 0x00000000, 0x00000000, 0x00000002, 0x00000000 }, /* LINK_REGS */        \
1048   { 0x00000000, 0x00000000, 0x00000004, 0x00000000 }, /* CTR_REGS */         \
1049   { 0x00000000, 0x00000000, 0x00000006, 0x00000000 }, /* LINK_OR_CTR_REGS */ \
1050   { 0x00000000, 0x00000000, 0x00000007, 0x00002000 }, /* SPECIAL_REGS */     \
1051   { 0xffffffff, 0x00000000, 0x0000000f, 0x00022000 }, /* SPEC_OR_GEN_REGS */ \
1052   { 0x00000000, 0x00000000, 0x00000010, 0x00000000 }, /* CR0_REGS */         \
1053   { 0x00000000, 0x00000000, 0x00000ff0, 0x00000000 }, /* CR_REGS */          \
1054   { 0xffffffff, 0x00000000, 0x0000efff, 0x00020000 }, /* NON_FLOAT_REGS */   \
1055   { 0x00000000, 0x00000000, 0x00001000, 0x00000000 }, /* XER_REGS */         \
1056   { 0xffffffff, 0xffffffff, 0xffffffff, 0x0003ffff }  /* ALL_REGS */         \
1057 }
1058
1059 /* The same information, inverted:
1060    Return the class number of the smallest class containing
1061    reg number REGNO.  This could be a conditional expression
1062    or could index an array.  */
1063
1064 #define REGNO_REG_CLASS(REGNO)                  \
1065  ((REGNO) == 0 ? GENERAL_REGS                   \
1066   : (REGNO) < 32 ? BASE_REGS                    \
1067   : FP_REGNO_P (REGNO) ? FLOAT_REGS             \
1068   : ALTIVEC_REGNO_P (REGNO) ? ALTIVEC_REGS      \
1069   : (REGNO) == CR0_REGNO ? CR0_REGS             \
1070   : CR_REGNO_P (REGNO) ? CR_REGS                \
1071   : (REGNO) == MQ_REGNO ? MQ_REGS               \
1072   : (REGNO) == LINK_REGISTER_REGNUM ? LINK_REGS \
1073   : (REGNO) == COUNT_REGISTER_REGNUM ? CTR_REGS \
1074   : (REGNO) == ARG_POINTER_REGNUM ? BASE_REGS   \
1075   : (REGNO) == XER_REGNO ? XER_REGS             \
1076   : (REGNO) == VRSAVE_REGNO ? VRSAVE_REGS       \
1077   : (REGNO) == VSCR_REGNO ? VRSAVE_REGS         \
1078   : (REGNO) == SPE_ACC_REGNO ? SPE_ACC_REGS     \
1079   : (REGNO) == SPEFSCR_REGNO ? SPEFSCR_REGS     \
1080   : (REGNO) == FRAME_POINTER_REGNUM ? BASE_REGS \
1081   : NO_REGS)
1082
1083 /* The class value for index registers, and the one for base regs.  */
1084 #define INDEX_REG_CLASS GENERAL_REGS
1085 #define BASE_REG_CLASS BASE_REGS
1086
1087 /* Given an rtx X being reloaded into a reg required to be
1088    in class CLASS, return the class of reg to actually use.
1089    In general this is just CLASS; but on some machines
1090    in some cases it is preferable to use a more restrictive class.
1091
1092    On the RS/6000, we have to return NO_REGS when we want to reload a
1093    floating-point CONST_DOUBLE to force it to be copied to memory.
1094
1095    We also don't want to reload integer values into floating-point
1096    registers if we can at all help it.  In fact, this can
1097    cause reload to die, if it tries to generate a reload of CTR
1098    into a FP register and discovers it doesn't have the memory location
1099    required.
1100
1101    ??? Would it be a good idea to have reload do the converse, that is
1102    try to reload floating modes into FP registers if possible?
1103  */
1104
1105 #define PREFERRED_RELOAD_CLASS(X,CLASS)                 \
1106   ((CONSTANT_P (X)                                      \
1107     && reg_classes_intersect_p ((CLASS), FLOAT_REGS))   \
1108    ? NO_REGS                                            \
1109    : (GET_MODE_CLASS (GET_MODE (X)) == MODE_INT         \
1110       && (CLASS) == NON_SPECIAL_REGS)                   \
1111    ? GENERAL_REGS                                       \
1112    : (CLASS))
1113
1114 /* Return the register class of a scratch register needed to copy IN into
1115    or out of a register in CLASS in MODE.  If it can be done directly,
1116    NO_REGS is returned.  */
1117
1118 #define SECONDARY_RELOAD_CLASS(CLASS,MODE,IN) \
1119   rs6000_secondary_reload_class (CLASS, MODE, IN)
1120
1121 /* If we are copying between FP or AltiVec registers and anything
1122    else, we need a memory location.  The exception is when we are
1123    targeting ppc64 and the move to/from fpr to gpr instructions
1124    are available.*/
1125
1126 #define SECONDARY_MEMORY_NEEDED(CLASS1,CLASS2,MODE)                     \
1127  ((CLASS1) != (CLASS2) && (((CLASS1) == FLOAT_REGS                      \
1128                             && (!TARGET_MFPGPR || !TARGET_POWERPC64     \
1129                                 || ((MODE != DFmode) && (MODE != DImode)))) \
1130                            || ((CLASS2) == FLOAT_REGS                   \
1131                                && (!TARGET_MFPGPR || !TARGET_POWERPC64  \
1132                                 || ((MODE != DFmode) && (MODE != DImode)))) \
1133                            || (CLASS1) == ALTIVEC_REGS                  \
1134                            || (CLASS2) == ALTIVEC_REGS))
1135
1136 /* Return the maximum number of consecutive registers
1137    needed to represent mode MODE in a register of class CLASS.
1138
1139    On RS/6000, this is the size of MODE in words,
1140    except in the FP regs, where a single reg is enough for two words.  */
1141 #define CLASS_MAX_NREGS(CLASS, MODE)                                    \
1142  (((CLASS) == FLOAT_REGS)                                               \
1143   ? ((GET_MODE_SIZE (MODE) + UNITS_PER_FP_WORD - 1) / UNITS_PER_FP_WORD) \
1144   : (TARGET_E500_DOUBLE && (CLASS) == GENERAL_REGS && (MODE) == DFmode) \
1145   ? 1                                                                   \
1146   : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD))
1147
1148 /* Return nonzero if for CLASS a mode change from FROM to TO is invalid.  */
1149
1150 #define CANNOT_CHANGE_MODE_CLASS(FROM, TO, CLASS)                       \
1151   (GET_MODE_SIZE (FROM) != GET_MODE_SIZE (TO)                           \
1152    ? ((GET_MODE_SIZE (FROM) < 8 || GET_MODE_SIZE (TO) < 8               \
1153        || TARGET_IEEEQUAD)                                              \
1154       && reg_classes_intersect_p (FLOAT_REGS, CLASS))                   \
1155    : (((TARGET_E500_DOUBLE                                              \
1156         && ((((TO) == DFmode) + ((FROM) == DFmode)) == 1                \
1157             || (((TO) == DImode) + ((FROM) == DImode)) == 1))           \
1158        || (TARGET_SPE                                                   \
1159            && (SPE_VECTOR_MODE (FROM) + SPE_VECTOR_MODE (TO)) == 1))    \
1160       && reg_classes_intersect_p (GENERAL_REGS, CLASS)))
1161
1162 /* Stack layout; function entry, exit and calling.  */
1163
1164 /* Enumeration to give which calling sequence to use.  */
1165 enum rs6000_abi {
1166   ABI_NONE,
1167   ABI_AIX,                      /* IBM's AIX */
1168   ABI_V4,                       /* System V.4/eabi */
1169   ABI_DARWIN                    /* Apple's Darwin (OS X kernel) */
1170 };
1171
1172 extern enum rs6000_abi rs6000_current_abi;      /* available for use by subtarget */
1173
1174 /* Define this if pushing a word on the stack
1175    makes the stack pointer a smaller address.  */
1176 #define STACK_GROWS_DOWNWARD
1177
1178 /* Offsets recorded in opcodes are a multiple of this alignment factor.  */
1179 #define DWARF_CIE_DATA_ALIGNMENT (-((int) (TARGET_32BIT ? 4 : 8)))
1180
1181 /* Define this to nonzero if the nominal address of the stack frame
1182    is at the high-address end of the local variables;
1183    that is, each additional local variable allocated
1184    goes at a more negative offset in the frame.
1185
1186    On the RS/6000, we grow upwards, from the area after the outgoing
1187    arguments.  */
1188 #define FRAME_GROWS_DOWNWARD (flag_stack_protect != 0)
1189
1190 /* Size of the outgoing register save area */
1191 #define RS6000_REG_SAVE ((DEFAULT_ABI == ABI_AIX                        \
1192                           || DEFAULT_ABI == ABI_DARWIN)                 \
1193                          ? (TARGET_64BIT ? 64 : 32)                     \
1194                          : 0)
1195
1196 /* Size of the fixed area on the stack */
1197 #define RS6000_SAVE_AREA \
1198   (((DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_DARWIN) ? 24 : 8)     \
1199    << (TARGET_64BIT ? 1 : 0))
1200
1201 /* MEM representing address to save the TOC register */
1202 #define RS6000_SAVE_TOC gen_rtx_MEM (Pmode, \
1203                                      plus_constant (stack_pointer_rtx, \
1204                                                     (TARGET_32BIT ? 20 : 40)))
1205
1206 /* Align an address */
1207 #define RS6000_ALIGN(n,a) (((n) + (a) - 1) & ~((a) - 1))
1208
1209 /* Offset within stack frame to start allocating local variables at.
1210    If FRAME_GROWS_DOWNWARD, this is the offset to the END of the
1211    first local allocated.  Otherwise, it is the offset to the BEGINNING
1212    of the first local allocated.
1213
1214    On the RS/6000, the frame pointer is the same as the stack pointer,
1215    except for dynamic allocations.  So we start after the fixed area and
1216    outgoing parameter area.  */
1217
1218 #define STARTING_FRAME_OFFSET                                           \
1219   (FRAME_GROWS_DOWNWARD                                                 \
1220    ? 0                                                                  \
1221    : (RS6000_ALIGN (current_function_outgoing_args_size,                \
1222                     TARGET_ALTIVEC ? 16 : 8)                            \
1223       + RS6000_SAVE_AREA))
1224
1225 /* Offset from the stack pointer register to an item dynamically
1226    allocated on the stack, e.g., by `alloca'.
1227
1228    The default value for this macro is `STACK_POINTER_OFFSET' plus the
1229    length of the outgoing arguments.  The default is correct for most
1230    machines.  See `function.c' for details.  */
1231 #define STACK_DYNAMIC_OFFSET(FUNDECL)                                   \
1232   (RS6000_ALIGN (current_function_outgoing_args_size,                   \
1233                  TARGET_ALTIVEC ? 16 : 8)                               \
1234    + (STACK_POINTER_OFFSET))
1235
1236 /* If we generate an insn to push BYTES bytes,
1237    this says how many the stack pointer really advances by.
1238    On RS/6000, don't define this because there are no push insns.  */
1239 /*  #define PUSH_ROUNDING(BYTES) */
1240
1241 /* Offset of first parameter from the argument pointer register value.
1242    On the RS/6000, we define the argument pointer to the start of the fixed
1243    area.  */
1244 #define FIRST_PARM_OFFSET(FNDECL) RS6000_SAVE_AREA
1245
1246 /* Offset from the argument pointer register value to the top of
1247    stack.  This is different from FIRST_PARM_OFFSET because of the
1248    register save area.  */
1249 #define ARG_POINTER_CFA_OFFSET(FNDECL) 0
1250
1251 /* Define this if stack space is still allocated for a parameter passed
1252    in a register.  The value is the number of bytes allocated to this
1253    area.  */
1254 #define REG_PARM_STACK_SPACE(FNDECL)    RS6000_REG_SAVE
1255
1256 /* Define this if the above stack space is to be considered part of the
1257    space allocated by the caller.  */
1258 #define OUTGOING_REG_PARM_STACK_SPACE
1259
1260 /* This is the difference between the logical top of stack and the actual sp.
1261
1262    For the RS/6000, sp points past the fixed area.  */
1263 #define STACK_POINTER_OFFSET RS6000_SAVE_AREA
1264
1265 /* Define this if the maximum size of all the outgoing args is to be
1266    accumulated and pushed during the prologue.  The amount can be
1267    found in the variable current_function_outgoing_args_size.  */
1268 #define ACCUMULATE_OUTGOING_ARGS 1
1269
1270 /* Value is the number of bytes of arguments automatically
1271    popped when returning from a subroutine call.
1272    FUNDECL is the declaration node of the function (as a tree),
1273    FUNTYPE is the data type of the function (as a tree),
1274    or for a library call it is an identifier node for the subroutine name.
1275    SIZE is the number of bytes of arguments passed on the stack.  */
1276
1277 #define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) 0
1278
1279 /* Define how to find the value returned by a function.
1280    VALTYPE is the data type of the value (as a tree).
1281    If the precise function being called is known, FUNC is its FUNCTION_DECL;
1282    otherwise, FUNC is 0.  */
1283
1284 #define FUNCTION_VALUE(VALTYPE, FUNC) rs6000_function_value ((VALTYPE), (FUNC))
1285
1286 /* Define how to find the value returned by a library function
1287    assuming the value has mode MODE.  */
1288
1289 #define LIBCALL_VALUE(MODE) rs6000_libcall_value ((MODE))
1290
1291 /* DRAFT_V4_STRUCT_RET defaults off.  */
1292 #define DRAFT_V4_STRUCT_RET 0
1293
1294 /* Let TARGET_RETURN_IN_MEMORY control what happens.  */
1295 #define DEFAULT_PCC_STRUCT_RETURN 0
1296
1297 /* Mode of stack savearea.
1298    FUNCTION is VOIDmode because calling convention maintains SP.
1299    BLOCK needs Pmode for SP.
1300    NONLOCAL needs twice Pmode to maintain both backchain and SP.  */
1301 #define STACK_SAVEAREA_MODE(LEVEL)      \
1302   (LEVEL == SAVE_FUNCTION ? VOIDmode    \
1303   : LEVEL == SAVE_NONLOCAL ? (TARGET_32BIT ? DImode : TImode) : Pmode)
1304
1305 /* Minimum and maximum general purpose registers used to hold arguments.  */
1306 #define GP_ARG_MIN_REG 3
1307 #define GP_ARG_MAX_REG 10
1308 #define GP_ARG_NUM_REG (GP_ARG_MAX_REG - GP_ARG_MIN_REG + 1)
1309
1310 /* Minimum and maximum floating point registers used to hold arguments.  */
1311 #define FP_ARG_MIN_REG 33
1312 #define FP_ARG_AIX_MAX_REG 45
1313 #define FP_ARG_V4_MAX_REG  40
1314 #define FP_ARG_MAX_REG ((DEFAULT_ABI == ABI_AIX                         \
1315                          || DEFAULT_ABI == ABI_DARWIN)                  \
1316                         ? FP_ARG_AIX_MAX_REG : FP_ARG_V4_MAX_REG)
1317 #define FP_ARG_NUM_REG (FP_ARG_MAX_REG - FP_ARG_MIN_REG + 1)
1318
1319 /* Minimum and maximum AltiVec registers used to hold arguments.  */
1320 #define ALTIVEC_ARG_MIN_REG (FIRST_ALTIVEC_REGNO + 2)
1321 #define ALTIVEC_ARG_MAX_REG (ALTIVEC_ARG_MIN_REG + 11)
1322 #define ALTIVEC_ARG_NUM_REG (ALTIVEC_ARG_MAX_REG - ALTIVEC_ARG_MIN_REG + 1)
1323
1324 /* Return registers */
1325 #define GP_ARG_RETURN GP_ARG_MIN_REG
1326 #define FP_ARG_RETURN FP_ARG_MIN_REG
1327 #define ALTIVEC_ARG_RETURN (FIRST_ALTIVEC_REGNO + 2)
1328
1329 /* Flags for the call/call_value rtl operations set up by function_arg */
1330 #define CALL_NORMAL             0x00000000      /* no special processing */
1331 /* Bits in 0x00000001 are unused.  */
1332 #define CALL_V4_CLEAR_FP_ARGS   0x00000002      /* V.4, no FP args passed */
1333 #define CALL_V4_SET_FP_ARGS     0x00000004      /* V.4, FP args were passed */
1334 #define CALL_LONG               0x00000008      /* always call indirect */
1335 #define CALL_LIBCALL            0x00000010      /* libcall */
1336
1337 /* We don't have prologue and epilogue functions to save/restore
1338    everything for most ABIs.  */
1339 #define WORLD_SAVE_P(INFO) 0
1340
1341 /* 1 if N is a possible register number for a function value
1342    as seen by the caller.
1343
1344    On RS/6000, this is r3, fp1, and v2 (for AltiVec).  */
1345 #define FUNCTION_VALUE_REGNO_P(N)                                       \
1346   ((N) == GP_ARG_RETURN                                                 \
1347    || ((N) == FP_ARG_RETURN && TARGET_HARD_FLOAT && TARGET_FPRS)        \
1348    || ((N) == ALTIVEC_ARG_RETURN && TARGET_ALTIVEC && TARGET_ALTIVEC_ABI))
1349
1350 /* 1 if N is a possible register number for function argument passing.
1351    On RS/6000, these are r3-r10 and fp1-fp13.
1352    On AltiVec, v2 - v13 are used for passing vectors.  */
1353 #define FUNCTION_ARG_REGNO_P(N)                                         \
1354   ((unsigned) (N) - GP_ARG_MIN_REG < GP_ARG_NUM_REG                     \
1355    || ((unsigned) (N) - ALTIVEC_ARG_MIN_REG < ALTIVEC_ARG_NUM_REG       \
1356        && TARGET_ALTIVEC && TARGET_ALTIVEC_ABI)                         \
1357    || ((unsigned) (N) - FP_ARG_MIN_REG < FP_ARG_NUM_REG                 \
1358        && TARGET_HARD_FLOAT && TARGET_FPRS))
1359 \f
1360 /* Define a data type for recording info about an argument list
1361    during the scan of that argument list.  This data type should
1362    hold all necessary information about the function itself
1363    and about the args processed so far, enough to enable macros
1364    such as FUNCTION_ARG to determine where the next arg should go.
1365
1366    On the RS/6000, this is a structure.  The first element is the number of
1367    total argument words, the second is used to store the next
1368    floating-point register number, and the third says how many more args we
1369    have prototype types for.
1370
1371    For ABI_V4, we treat these slightly differently -- `sysv_gregno' is
1372    the next available GP register, `fregno' is the next available FP
1373    register, and `words' is the number of words used on the stack.
1374
1375    The varargs/stdarg support requires that this structure's size
1376    be a multiple of sizeof(int).  */
1377
1378 typedef struct rs6000_args
1379 {
1380   int words;                    /* # words used for passing GP registers */
1381   int fregno;                   /* next available FP register */
1382   int vregno;                   /* next available AltiVec register */
1383   int nargs_prototype;          /* # args left in the current prototype */
1384   int prototype;                /* Whether a prototype was defined */
1385   int stdarg;                   /* Whether function is a stdarg function.  */
1386   int call_cookie;              /* Do special things for this call */
1387   int sysv_gregno;              /* next available GP register */
1388   int intoffset;                /* running offset in struct (darwin64) */
1389   int use_stack;                /* any part of struct on stack (darwin64) */
1390   int named;                    /* false for varargs params */
1391 } CUMULATIVE_ARGS;
1392
1393 /* Initialize a variable CUM of type CUMULATIVE_ARGS
1394    for a call to a function whose data type is FNTYPE.
1395    For a library call, FNTYPE is 0.  */
1396
1397 #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, INDIRECT, N_NAMED_ARGS) \
1398   init_cumulative_args (&CUM, FNTYPE, LIBNAME, FALSE, FALSE, N_NAMED_ARGS)
1399
1400 /* Similar, but when scanning the definition of a procedure.  We always
1401    set NARGS_PROTOTYPE large so we never return an EXPR_LIST.  */
1402
1403 #define INIT_CUMULATIVE_INCOMING_ARGS(CUM, FNTYPE, LIBNAME) \
1404   init_cumulative_args (&CUM, FNTYPE, LIBNAME, TRUE, FALSE, 1000)
1405
1406 /* Like INIT_CUMULATIVE_ARGS' but only used for outgoing libcalls.  */
1407
1408 #define INIT_CUMULATIVE_LIBCALL_ARGS(CUM, MODE, LIBNAME) \
1409   init_cumulative_args (&CUM, NULL_TREE, LIBNAME, FALSE, TRUE, 0)
1410
1411 /* Update the data in CUM to advance over an argument
1412    of mode MODE and data type TYPE.
1413    (TYPE is null for libcalls where that information may not be available.)  */
1414
1415 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED)    \
1416   function_arg_advance (&CUM, MODE, TYPE, NAMED, 0)
1417
1418 /* Determine where to put an argument to a function.
1419    Value is zero to push the argument on the stack,
1420    or a hard register in which to store the argument.
1421
1422    MODE is the argument's machine mode.
1423    TYPE is the data type of the argument (as a tree).
1424     This is null for libcalls where that information may
1425     not be available.
1426    CUM is a variable of type CUMULATIVE_ARGS which gives info about
1427     the preceding args and about the function being called.
1428    NAMED is nonzero if this argument is a named parameter
1429     (otherwise it is an extra parameter matching an ellipsis).
1430
1431    On RS/6000 the first eight words of non-FP are normally in registers
1432    and the rest are pushed.  The first 13 FP args are in registers.
1433
1434    If this is floating-point and no prototype is specified, we use
1435    both an FP and integer register (or possibly FP reg and stack).  Library
1436    functions (when TYPE is zero) always have the proper types for args,
1437    so we can pass the FP value just in one register.  emit_library_function
1438    doesn't support EXPR_LIST anyway.  */
1439
1440 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
1441   function_arg (&CUM, MODE, TYPE, NAMED)
1442
1443 /* If defined, a C expression which determines whether, and in which
1444    direction, to pad out an argument with extra space.  The value
1445    should be of type `enum direction': either `upward' to pad above
1446    the argument, `downward' to pad below, or `none' to inhibit
1447    padding.  */
1448
1449 #define FUNCTION_ARG_PADDING(MODE, TYPE) function_arg_padding (MODE, TYPE)
1450
1451 /* If defined, a C expression that gives the alignment boundary, in bits,
1452    of an argument with the specified mode and type.  If it is not defined,
1453    PARM_BOUNDARY is used for all arguments.  */
1454
1455 #define FUNCTION_ARG_BOUNDARY(MODE, TYPE) \
1456   function_arg_boundary (MODE, TYPE)
1457
1458 /* Implement `va_start' for varargs and stdarg.  */
1459 #define EXPAND_BUILTIN_VA_START(valist, nextarg) \
1460   rs6000_va_start (valist, nextarg)
1461
1462 #define PAD_VARARGS_DOWN \
1463    (FUNCTION_ARG_PADDING (TYPE_MODE (type), type) == downward)
1464
1465 /* Output assembler code to FILE to increment profiler label # LABELNO
1466    for profiling a function entry.  */
1467
1468 #define FUNCTION_PROFILER(FILE, LABELNO)        \
1469   output_function_profiler ((FILE), (LABELNO));
1470
1471 /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,
1472    the stack pointer does not matter. No definition is equivalent to
1473    always zero.
1474
1475    On the RS/6000, this is nonzero because we can restore the stack from
1476    its backpointer, which we maintain.  */
1477 #define EXIT_IGNORE_STACK       1
1478
1479 /* Define this macro as a C expression that is nonzero for registers
1480    that are used by the epilogue or the return' pattern.  The stack
1481    and frame pointer registers are already be assumed to be used as
1482    needed.  */
1483
1484 #define EPILOGUE_USES(REGNO)                                    \
1485   ((reload_completed && (REGNO) == LINK_REGISTER_REGNUM)        \
1486    || (TARGET_ALTIVEC && (REGNO) == VRSAVE_REGNO)               \
1487    || (current_function_calls_eh_return                         \
1488        && TARGET_AIX                                            \
1489        && (REGNO) == 2))
1490
1491 \f
1492 /* TRAMPOLINE_TEMPLATE deleted */
1493
1494 /* Length in units of the trampoline for entering a nested function.  */
1495
1496 #define TRAMPOLINE_SIZE rs6000_trampoline_size ()
1497
1498 /* Emit RTL insns to initialize the variable parts of a trampoline.
1499    FNADDR is an RTX for the address of the function's pure code.
1500    CXT is an RTX for the static chain value for the function.  */
1501
1502 #define INITIALIZE_TRAMPOLINE(ADDR, FNADDR, CXT)                \
1503   rs6000_initialize_trampoline (ADDR, FNADDR, CXT)
1504 \f
1505 /* Definitions for __builtin_return_address and __builtin_frame_address.
1506    __builtin_return_address (0) should give link register (65), enable
1507    this.  */
1508 /* This should be uncommented, so that the link register is used, but
1509    currently this would result in unmatched insns and spilling fixed
1510    registers so we'll leave it for another day.  When these problems are
1511    taken care of one additional fetch will be necessary in RETURN_ADDR_RTX.
1512    (mrs) */
1513 /* #define RETURN_ADDR_IN_PREVIOUS_FRAME */
1514
1515 /* Number of bytes into the frame return addresses can be found.  See
1516    rs6000_stack_info in rs6000.c for more information on how the different
1517    abi's store the return address.  */
1518 #define RETURN_ADDRESS_OFFSET                                           \
1519  ((DEFAULT_ABI == ABI_AIX                                               \
1520    || DEFAULT_ABI == ABI_DARWIN)        ? (TARGET_32BIT ? 8 : 16) :     \
1521   (DEFAULT_ABI == ABI_V4)               ? 4 :                           \
1522   (internal_error ("RETURN_ADDRESS_OFFSET not supported"), 0))
1523
1524 /* The current return address is in link register (65).  The return address
1525    of anything farther back is accessed normally at an offset of 8 from the
1526    frame pointer.  */
1527 #define RETURN_ADDR_RTX(COUNT, FRAME)                 \
1528   (rs6000_return_addr (COUNT, FRAME))
1529
1530 \f
1531 /* Definitions for register eliminations.
1532
1533    We have two registers that can be eliminated on the RS/6000.  First, the
1534    frame pointer register can often be eliminated in favor of the stack
1535    pointer register.  Secondly, the argument pointer register can always be
1536    eliminated; it is replaced with either the stack or frame pointer.
1537
1538    In addition, we use the elimination mechanism to see if r30 is needed
1539    Initially we assume that it isn't.  If it is, we spill it.  This is done
1540    by making it an eliminable register.  We replace it with itself so that
1541    if it isn't needed, then existing uses won't be modified.  */
1542
1543 /* This is an array of structures.  Each structure initializes one pair
1544    of eliminable registers.  The "from" register number is given first,
1545    followed by "to".  Eliminations of the same "from" register are listed
1546    in order of preference.  */
1547 #define ELIMINABLE_REGS                                 \
1548 {{ HARD_FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM},    \
1549  { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM},         \
1550  { FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM},    \
1551  { ARG_POINTER_REGNUM, STACK_POINTER_REGNUM},           \
1552  { ARG_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM},      \
1553  { RS6000_PIC_OFFSET_TABLE_REGNUM, RS6000_PIC_OFFSET_TABLE_REGNUM } }
1554
1555 /* Given FROM and TO register numbers, say whether this elimination is allowed.
1556    Frame pointer elimination is automatically handled.
1557
1558    For the RS/6000, if frame pointer elimination is being done, we would like
1559    to convert ap into fp, not sp.
1560
1561    We need r30 if -mminimal-toc was specified, and there are constant pool
1562    references.  */
1563
1564 #define CAN_ELIMINATE(FROM, TO)                                         \
1565  ((FROM) == ARG_POINTER_REGNUM && (TO) == STACK_POINTER_REGNUM          \
1566   ? ! frame_pointer_needed                                              \
1567   : (FROM) == RS6000_PIC_OFFSET_TABLE_REGNUM                            \
1568   ? ! TARGET_MINIMAL_TOC || TARGET_NO_TOC || get_pool_size () == 0      \
1569   : 1)
1570
1571 /* Define the offset between two registers, one to be eliminated, and the other
1572    its replacement, at the start of a routine.  */
1573 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
1574   ((OFFSET) = rs6000_initial_elimination_offset(FROM, TO))
1575 \f
1576 /* Addressing modes, and classification of registers for them.  */
1577
1578 #define HAVE_PRE_DECREMENT 1
1579 #define HAVE_PRE_INCREMENT 1
1580
1581 /* Macros to check register numbers against specific register classes.  */
1582
1583 /* These assume that REGNO is a hard or pseudo reg number.
1584    They give nonzero only if REGNO is a hard reg of the suitable class
1585    or a pseudo reg currently allocated to a suitable hard reg.
1586    Since they use reg_renumber, they are safe only once reg_renumber
1587    has been allocated, which happens in local-alloc.c.  */
1588
1589 #define REGNO_OK_FOR_INDEX_P(REGNO)                             \
1590 ((REGNO) < FIRST_PSEUDO_REGISTER                                \
1591  ? (REGNO) <= 31 || (REGNO) == 67                               \
1592    || (REGNO) == FRAME_POINTER_REGNUM                           \
1593  : (reg_renumber[REGNO] >= 0                                    \
1594     && (reg_renumber[REGNO] <= 31 || reg_renumber[REGNO] == 67  \
1595         || reg_renumber[REGNO] == FRAME_POINTER_REGNUM)))
1596
1597 #define REGNO_OK_FOR_BASE_P(REGNO)                              \
1598 ((REGNO) < FIRST_PSEUDO_REGISTER                                \
1599  ? ((REGNO) > 0 && (REGNO) <= 31) || (REGNO) == 67              \
1600    || (REGNO) == FRAME_POINTER_REGNUM                           \
1601  : (reg_renumber[REGNO] > 0                                     \
1602     && (reg_renumber[REGNO] <= 31 || reg_renumber[REGNO] == 67  \
1603         || reg_renumber[REGNO] == FRAME_POINTER_REGNUM)))
1604 \f
1605 /* Maximum number of registers that can appear in a valid memory address.  */
1606
1607 #define MAX_REGS_PER_ADDRESS 2
1608
1609 /* Recognize any constant value that is a valid address.  */
1610
1611 #define CONSTANT_ADDRESS_P(X)   \
1612   (GET_CODE (X) == LABEL_REF || GET_CODE (X) == SYMBOL_REF              \
1613    || GET_CODE (X) == CONST_INT || GET_CODE (X) == CONST                \
1614    || GET_CODE (X) == HIGH)
1615
1616 /* Nonzero if the constant value X is a legitimate general operand.
1617    It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE.
1618
1619    On the RS/6000, all integer constants are acceptable, most won't be valid
1620    for particular insns, though.  Only easy FP constants are
1621    acceptable.  */
1622
1623 #define LEGITIMATE_CONSTANT_P(X)                                \
1624   (((GET_CODE (X) != CONST_DOUBLE                               \
1625      && GET_CODE (X) != CONST_VECTOR)                           \
1626     || GET_MODE (X) == VOIDmode                                 \
1627     || (TARGET_POWERPC64 && GET_MODE (X) == DImode)             \
1628     || easy_fp_constant (X, GET_MODE (X))                       \
1629     || easy_vector_constant (X, GET_MODE (X)))                  \
1630    && !rs6000_tls_referenced_p (X))
1631
1632 #define EASY_VECTOR_15(n) ((n) >= -16 && (n) <= 15)
1633 #define EASY_VECTOR_15_ADD_SELF(n) (!EASY_VECTOR_15((n))        \
1634                                     && EASY_VECTOR_15((n) >> 1) \
1635                                     && ((n) & 1) == 0)
1636
1637 /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
1638    and check its validity for a certain class.
1639    We have two alternate definitions for each of them.
1640    The usual definition accepts all pseudo regs; the other rejects
1641    them unless they have been allocated suitable hard regs.
1642    The symbol REG_OK_STRICT causes the latter definition to be used.
1643
1644    Most source files want to accept pseudo regs in the hope that
1645    they will get allocated to the class that the insn wants them to be in.
1646    Source files for reload pass need to be strict.
1647    After reload, it makes no difference, since pseudo regs have
1648    been eliminated by then.  */
1649
1650 #ifdef REG_OK_STRICT
1651 # define REG_OK_STRICT_FLAG 1
1652 #else
1653 # define REG_OK_STRICT_FLAG 0
1654 #endif
1655
1656 /* Nonzero if X is a hard reg that can be used as an index
1657    or if it is a pseudo reg in the non-strict case.  */
1658 #define INT_REG_OK_FOR_INDEX_P(X, STRICT)                       \
1659   ((!(STRICT) && REGNO (X) >= FIRST_PSEUDO_REGISTER)            \
1660    || REGNO_OK_FOR_INDEX_P (REGNO (X)))
1661
1662 /* Nonzero if X is a hard reg that can be used as a base reg
1663    or if it is a pseudo reg in the non-strict case.  */
1664 #define INT_REG_OK_FOR_BASE_P(X, STRICT)                        \
1665   ((!(STRICT) && REGNO (X) >= FIRST_PSEUDO_REGISTER)            \
1666    || REGNO_OK_FOR_BASE_P (REGNO (X)))
1667
1668 #define REG_OK_FOR_INDEX_P(X) INT_REG_OK_FOR_INDEX_P (X, REG_OK_STRICT_FLAG)
1669 #define REG_OK_FOR_BASE_P(X)  INT_REG_OK_FOR_BASE_P (X, REG_OK_STRICT_FLAG)
1670 \f
1671 /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression
1672    that is a valid memory address for an instruction.
1673    The MODE argument is the machine mode for the MEM expression
1674    that wants to use this address.
1675
1676    On the RS/6000, there are four valid addresses: a SYMBOL_REF that
1677    refers to a constant pool entry of an address (or the sum of it
1678    plus a constant), a short (16-bit signed) constant plus a register,
1679    the sum of two registers, or a register indirect, possibly with an
1680    auto-increment.  For DFmode and DImode with a constant plus register,
1681    we must ensure that both words are addressable or PowerPC64 with offset
1682    word aligned.
1683
1684    For modes spanning multiple registers (DFmode in 32-bit GPRs,
1685    32-bit DImode, TImode), indexed addressing cannot be used because
1686    adjacent memory cells are accessed by adding word-sized offsets
1687    during assembly output.  */
1688
1689 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR)                 \
1690 { if (rs6000_legitimate_address (MODE, X, REG_OK_STRICT_FLAG))  \
1691     goto ADDR;                                                  \
1692 }
1693 \f
1694 /* Try machine-dependent ways of modifying an illegitimate address
1695    to be legitimate.  If we find one, return the new, valid address.
1696    This macro is used in only one place: `memory_address' in explow.c.
1697
1698    OLDX is the address as it was before break_out_memory_refs was called.
1699    In some cases it is useful to look at this to decide what needs to be done.
1700
1701    MODE and WIN are passed so that this macro can use
1702    GO_IF_LEGITIMATE_ADDRESS.
1703
1704    It is always safe for this macro to do nothing.  It exists to recognize
1705    opportunities to optimize the output.
1706
1707    On RS/6000, first check for the sum of a register with a constant
1708    integer that is out of range.  If so, generate code to add the
1709    constant with the low-order 16 bits masked to the register and force
1710    this result into another register (this can be done with `cau').
1711    Then generate an address of REG+(CONST&0xffff), allowing for the
1712    possibility of bit 16 being a one.
1713
1714    Then check for the sum of a register and something not constant, try to
1715    load the other things into a register and return the sum.  */
1716
1717 #define LEGITIMIZE_ADDRESS(X,OLDX,MODE,WIN)                     \
1718 {  rtx result = rs6000_legitimize_address (X, OLDX, MODE);      \
1719    if (result != NULL_RTX)                                      \
1720      {                                                          \
1721        (X) = result;                                            \
1722        goto WIN;                                                \
1723      }                                                          \
1724 }
1725
1726 /* Try a machine-dependent way of reloading an illegitimate address
1727    operand.  If we find one, push the reload and jump to WIN.  This
1728    macro is used in only one place: `find_reloads_address' in reload.c.
1729
1730    Implemented on rs6000 by rs6000_legitimize_reload_address.
1731    Note that (X) is evaluated twice; this is safe in current usage.  */
1732
1733 #define LEGITIMIZE_RELOAD_ADDRESS(X,MODE,OPNUM,TYPE,IND_LEVELS,WIN)          \
1734 do {                                                                         \
1735   int win;                                                                   \
1736   (X) = rs6000_legitimize_reload_address ((X), (MODE), (OPNUM),              \
1737                         (int)(TYPE), (IND_LEVELS), &win);                    \
1738   if ( win )                                                                 \
1739     goto WIN;                                                                \
1740 } while (0)
1741
1742 /* Go to LABEL if ADDR (a legitimate address expression)
1743    has an effect that depends on the machine mode it is used for.  */
1744
1745 #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL)                \
1746 do {                                                            \
1747   if (rs6000_mode_dependent_address (ADDR))                     \
1748     goto LABEL;                                                 \
1749 } while (0)
1750 \f
1751 /* The register number of the register used to address a table of
1752    static data addresses in memory.  In some cases this register is
1753    defined by a processor's "application binary interface" (ABI).
1754    When this macro is defined, RTL is generated for this register
1755    once, as with the stack pointer and frame pointer registers.  If
1756    this macro is not defined, it is up to the machine-dependent files
1757    to allocate such a register (if necessary).  */
1758
1759 #define RS6000_PIC_OFFSET_TABLE_REGNUM 30
1760 #define PIC_OFFSET_TABLE_REGNUM (flag_pic ? RS6000_PIC_OFFSET_TABLE_REGNUM : INVALID_REGNUM)
1761
1762 #define TOC_REGISTER (TARGET_MINIMAL_TOC ? RS6000_PIC_OFFSET_TABLE_REGNUM : 2)
1763
1764 /* Define this macro if the register defined by
1765    `PIC_OFFSET_TABLE_REGNUM' is clobbered by calls.  Do not define
1766    this macro if `PIC_OFFSET_TABLE_REGNUM' is not defined.  */
1767
1768 /* #define PIC_OFFSET_TABLE_REG_CALL_CLOBBERED */
1769
1770 /* A C expression that is nonzero if X is a legitimate immediate
1771    operand on the target machine when generating position independent
1772    code.  You can assume that X satisfies `CONSTANT_P', so you need
1773    not check this.  You can also assume FLAG_PIC is true, so you need
1774    not check it either.  You need not define this macro if all
1775    constants (including `SYMBOL_REF') can be immediate operands when
1776    generating position independent code.  */
1777
1778 /* #define LEGITIMATE_PIC_OPERAND_P (X) */
1779 \f
1780 /* Define this if some processing needs to be done immediately before
1781    emitting code for an insn.  */
1782
1783 /* #define FINAL_PRESCAN_INSN(INSN,OPERANDS,NOPERANDS) */
1784
1785 /* Specify the machine mode that this machine uses
1786    for the index in the tablejump instruction.  */
1787 #define CASE_VECTOR_MODE SImode
1788
1789 /* Define as C expression which evaluates to nonzero if the tablejump
1790    instruction expects the table to contain offsets from the address of the
1791    table.
1792    Do not define this if the table should contain absolute addresses.  */
1793 #define CASE_VECTOR_PC_RELATIVE 1
1794
1795 /* Define this as 1 if `char' should by default be signed; else as 0.  */
1796 #define DEFAULT_SIGNED_CHAR 0
1797
1798 /* This flag, if defined, says the same insns that convert to a signed fixnum
1799    also convert validly to an unsigned one.  */
1800
1801 /* #define FIXUNS_TRUNC_LIKE_FIX_TRUNC */
1802
1803 /* An integer expression for the size in bits of the largest integer machine
1804    mode that should actually be used.  */
1805
1806 /* Allow pairs of registers to be used, which is the intent of the default.  */
1807 #define MAX_FIXED_MODE_SIZE GET_MODE_BITSIZE (TARGET_POWERPC64 ? TImode : DImode)
1808
1809 /* Max number of bytes we can move from memory to memory
1810    in one reasonably fast instruction.  */
1811 #define MOVE_MAX (! TARGET_POWERPC64 ? 4 : 8)
1812 #define MAX_MOVE_MAX 8
1813
1814 /* Nonzero if access to memory by bytes is no faster than for words.
1815    Also nonzero if doing byte operations (specifically shifts) in registers
1816    is undesirable.  */
1817 #define SLOW_BYTE_ACCESS 1
1818
1819 /* Define if operations between registers always perform the operation
1820    on the full register even if a narrower mode is specified.  */
1821 #define WORD_REGISTER_OPERATIONS
1822
1823 /* Define if loading in MODE, an integral mode narrower than BITS_PER_WORD
1824    will either zero-extend or sign-extend.  The value of this macro should
1825    be the code that says which one of the two operations is implicitly
1826    done, UNKNOWN if none.  */
1827 #define LOAD_EXTEND_OP(MODE) ZERO_EXTEND
1828
1829 /* Define if loading short immediate values into registers sign extends.  */
1830 #define SHORT_IMMEDIATES_SIGN_EXTEND
1831 \f
1832 /* Value is 1 if truncating an integer of INPREC bits to OUTPREC bits
1833    is done just by pretending it is already truncated.  */
1834 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
1835
1836 /* The cntlzw and cntlzd instructions return 32 and 64 for input of zero.  */
1837 #define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) \
1838   ((VALUE) = ((MODE) == SImode ? 32 : 64))
1839
1840 /* The CTZ patterns return -1 for input of zero.  */
1841 #define CTZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE) ((VALUE) = -1)
1842
1843 /* Specify the machine mode that pointers have.
1844    After generation of rtl, the compiler makes no further distinction
1845    between pointers and any other objects of this machine mode.  */
1846 #define Pmode (TARGET_32BIT ? SImode : DImode)
1847
1848 /* Supply definition of STACK_SIZE_MODE for allocate_dynamic_stack_space.  */
1849 #define STACK_SIZE_MODE (TARGET_32BIT ? SImode : DImode)
1850
1851 /* Mode of a function address in a call instruction (for indexing purposes).
1852    Doesn't matter on RS/6000.  */
1853 #define FUNCTION_MODE SImode
1854
1855 /* Define this if addresses of constant functions
1856    shouldn't be put through pseudo regs where they can be cse'd.
1857    Desirable on machines where ordinary constants are expensive
1858    but a CALL with constant address is cheap.  */
1859 #define NO_FUNCTION_CSE
1860
1861 /* Define this to be nonzero if shift instructions ignore all but the low-order
1862    few bits.
1863
1864    The sle and sre instructions which allow SHIFT_COUNT_TRUNCATED
1865    have been dropped from the PowerPC architecture.  */
1866
1867 #define SHIFT_COUNT_TRUNCATED (TARGET_POWER ? 1 : 0)
1868
1869 /* Adjust the length of an INSN.  LENGTH is the currently-computed length and
1870    should be adjusted to reflect any required changes.  This macro is used when
1871    there is some systematic length adjustment required that would be difficult
1872    to express in the length attribute.  */
1873
1874 /* #define ADJUST_INSN_LENGTH(X,LENGTH) */
1875
1876 /* Given a comparison code (EQ, NE, etc.) and the first operand of a
1877    COMPARE, return the mode to be used for the comparison.  For
1878    floating-point, CCFPmode should be used.  CCUNSmode should be used
1879    for unsigned comparisons.  CCEQmode should be used when we are
1880    doing an inequality comparison on the result of a
1881    comparison.  CCmode should be used in all other cases.  */
1882
1883 #define SELECT_CC_MODE(OP,X,Y) \
1884   (SCALAR_FLOAT_MODE_P (GET_MODE (X)) ? CCFPmode        \
1885    : (OP) == GTU || (OP) == LTU || (OP) == GEU || (OP) == LEU ? CCUNSmode \
1886    : (((OP) == EQ || (OP) == NE) && COMPARISON_P (X)                      \
1887       ? CCEQmode : CCmode))
1888
1889 /* Can the condition code MODE be safely reversed?  This is safe in
1890    all cases on this port, because at present it doesn't use the
1891    trapping FP comparisons (fcmpo).  */
1892 #define REVERSIBLE_CC_MODE(MODE) 1
1893
1894 /* Given a condition code and a mode, return the inverse condition.  */
1895 #define REVERSE_CONDITION(CODE, MODE) rs6000_reverse_condition (MODE, CODE)
1896
1897 /* Define the information needed to generate branch and scc insns.  This is
1898    stored from the compare operation.  */
1899
1900 extern GTY(()) rtx rs6000_compare_op0;
1901 extern GTY(()) rtx rs6000_compare_op1;
1902 extern int rs6000_compare_fp_p;
1903 \f
1904 /* Control the assembler format that we output.  */
1905
1906 /* A C string constant describing how to begin a comment in the target
1907    assembler language.  The compiler assumes that the comment will end at
1908    the end of the line.  */
1909 #define ASM_COMMENT_START " #"
1910
1911 /* Flag to say the TOC is initialized */
1912 extern int toc_initialized;
1913
1914 /* Macro to output a special constant pool entry.  Go to WIN if we output
1915    it.  Otherwise, it is written the usual way.
1916
1917    On the RS/6000, toc entries are handled this way.  */
1918
1919 #define ASM_OUTPUT_SPECIAL_POOL_ENTRY(FILE, X, MODE, ALIGN, LABELNO, WIN) \
1920 { if (ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (X, MODE))                          \
1921     {                                                                     \
1922       output_toc (FILE, X, LABELNO, MODE);                                \
1923       goto WIN;                                                           \
1924     }                                                                     \
1925 }
1926
1927 #ifdef HAVE_GAS_WEAK
1928 #define RS6000_WEAK 1
1929 #else
1930 #define RS6000_WEAK 0
1931 #endif
1932
1933 #if RS6000_WEAK
1934 /* Used in lieu of ASM_WEAKEN_LABEL.  */
1935 #define ASM_WEAKEN_DECL(FILE, DECL, NAME, VAL)                          \
1936   do                                                                    \
1937     {                                                                   \
1938       fputs ("\t.weak\t", (FILE));                                      \
1939       RS6000_OUTPUT_BASENAME ((FILE), (NAME));                          \
1940       if ((DECL) && TREE_CODE (DECL) == FUNCTION_DECL                   \
1941           && DEFAULT_ABI == ABI_AIX && DOT_SYMBOLS)                     \
1942         {                                                               \
1943           if (TARGET_XCOFF)                                             \
1944             fputs ("[DS]", (FILE));                                     \
1945           fputs ("\n\t.weak\t.", (FILE));                               \
1946           RS6000_OUTPUT_BASENAME ((FILE), (NAME));                      \
1947         }                                                               \
1948       fputc ('\n', (FILE));                                             \
1949       if (VAL)                                                          \
1950         {                                                               \
1951           ASM_OUTPUT_DEF ((FILE), (NAME), (VAL));                       \
1952           if ((DECL) && TREE_CODE (DECL) == FUNCTION_DECL               \
1953               && DEFAULT_ABI == ABI_AIX && DOT_SYMBOLS)                 \
1954             {                                                           \
1955               fputs ("\t.set\t.", (FILE));                              \
1956               RS6000_OUTPUT_BASENAME ((FILE), (NAME));                  \
1957               fputs (",.", (FILE));                                     \
1958               RS6000_OUTPUT_BASENAME ((FILE), (VAL));                   \
1959               fputc ('\n', (FILE));                                     \
1960             }                                                           \
1961         }                                                               \
1962     }                                                                   \
1963   while (0)
1964 #endif
1965
1966 #if HAVE_GAS_WEAKREF
1967 #define ASM_OUTPUT_WEAKREF(FILE, DECL, NAME, VALUE)                     \
1968   do                                                                    \
1969     {                                                                   \
1970       fputs ("\t.weakref\t", (FILE));                                   \
1971       RS6000_OUTPUT_BASENAME ((FILE), (NAME));                          \
1972       fputs (", ", (FILE));                                             \
1973       RS6000_OUTPUT_BASENAME ((FILE), (VALUE));                         \
1974       if ((DECL) && TREE_CODE (DECL) == FUNCTION_DECL                   \
1975           && DEFAULT_ABI == ABI_AIX && DOT_SYMBOLS)                     \
1976         {                                                               \
1977           fputs ("\n\t.weakref\t.", (FILE));                            \
1978           RS6000_OUTPUT_BASENAME ((FILE), (NAME));                      \
1979           fputs (", .", (FILE));                                        \
1980           RS6000_OUTPUT_BASENAME ((FILE), (VALUE));                     \
1981         }                                                               \
1982       fputc ('\n', (FILE));                                             \
1983     } while (0)
1984 #endif
1985
1986 /* This implements the `alias' attribute.  */
1987 #undef  ASM_OUTPUT_DEF_FROM_DECLS
1988 #define ASM_OUTPUT_DEF_FROM_DECLS(FILE, DECL, TARGET)                   \
1989   do                                                                    \
1990     {                                                                   \
1991       const char *alias = XSTR (XEXP (DECL_RTL (DECL), 0), 0);          \
1992       const char *name = IDENTIFIER_POINTER (TARGET);                   \
1993       if (TREE_CODE (DECL) == FUNCTION_DECL                             \
1994           && DEFAULT_ABI == ABI_AIX && DOT_SYMBOLS)                     \
1995         {                                                               \
1996           if (TREE_PUBLIC (DECL))                                       \
1997             {                                                           \
1998               if (!RS6000_WEAK || !DECL_WEAK (DECL))                    \
1999                 {                                                       \
2000                   fputs ("\t.globl\t.", FILE);                          \
2001                   RS6000_OUTPUT_BASENAME (FILE, alias);                 \
2002                   putc ('\n', FILE);                                    \
2003                 }                                                       \
2004             }                                                           \
2005           else if (TARGET_XCOFF)                                        \
2006             {                                                           \
2007               fputs ("\t.lglobl\t.", FILE);                             \
2008               RS6000_OUTPUT_BASENAME (FILE, alias);                     \
2009               putc ('\n', FILE);                                        \
2010             }                                                           \
2011           fputs ("\t.set\t.", FILE);                                    \
2012           RS6000_OUTPUT_BASENAME (FILE, alias);                         \
2013           fputs (",.", FILE);                                           \
2014           RS6000_OUTPUT_BASENAME (FILE, name);                          \
2015           fputc ('\n', FILE);                                           \
2016         }                                                               \
2017       ASM_OUTPUT_DEF (FILE, alias, name);                               \
2018     }                                                                   \
2019    while (0)
2020
2021 #define TARGET_ASM_FILE_START rs6000_file_start
2022
2023 /* Output to assembler file text saying following lines
2024    may contain character constants, extra white space, comments, etc.  */
2025
2026 #define ASM_APP_ON ""
2027
2028 /* Output to assembler file text saying following lines
2029    no longer contain unusual constructs.  */
2030
2031 #define ASM_APP_OFF ""
2032
2033 /* How to refer to registers in assembler output.
2034    This sequence is indexed by compiler's hard-register-number (see above).  */
2035
2036 extern char rs6000_reg_names[][8];      /* register names (0 vs. %r0).  */
2037
2038 #define REGISTER_NAMES                                                  \
2039 {                                                                       \
2040   &rs6000_reg_names[ 0][0],     /* r0   */                              \
2041   &rs6000_reg_names[ 1][0],     /* r1   */                              \
2042   &rs6000_reg_names[ 2][0],     /* r2   */                              \
2043   &rs6000_reg_names[ 3][0],     /* r3   */                              \
2044   &rs6000_reg_names[ 4][0],     /* r4   */                              \
2045   &rs6000_reg_names[ 5][0],     /* r5   */                              \
2046   &rs6000_reg_names[ 6][0],     /* r6   */                              \
2047   &rs6000_reg_names[ 7][0],     /* r7   */                              \
2048   &rs6000_reg_names[ 8][0],     /* r8   */                              \
2049   &rs6000_reg_names[ 9][0],     /* r9   */                              \
2050   &rs6000_reg_names[10][0],     /* r10  */                              \
2051   &rs6000_reg_names[11][0],     /* r11  */                              \
2052   &rs6000_reg_names[12][0],     /* r12  */                              \
2053   &rs6000_reg_names[13][0],     /* r13  */                              \
2054   &rs6000_reg_names[14][0],     /* r14  */                              \
2055   &rs6000_reg_names[15][0],     /* r15  */                              \
2056   &rs6000_reg_names[16][0],     /* r16  */                              \
2057   &rs6000_reg_names[17][0],     /* r17  */                              \
2058   &rs6000_reg_names[18][0],     /* r18  */                              \
2059   &rs6000_reg_names[19][0],     /* r19  */                              \
2060   &rs6000_reg_names[20][0],     /* r20  */                              \
2061   &rs6000_reg_names[21][0],     /* r21  */                              \
2062   &rs6000_reg_names[22][0],     /* r22  */                              \
2063   &rs6000_reg_names[23][0],     /* r23  */                              \
2064   &rs6000_reg_names[24][0],     /* r24  */                              \
2065   &rs6000_reg_names[25][0],     /* r25  */                              \
2066   &rs6000_reg_names[26][0],     /* r26  */                              \
2067   &rs6000_reg_names[27][0],     /* r27  */                              \
2068   &rs6000_reg_names[28][0],     /* r28  */                              \
2069   &rs6000_reg_names[29][0],     /* r29  */                              \
2070   &rs6000_reg_names[30][0],     /* r30  */                              \
2071   &rs6000_reg_names[31][0],     /* r31  */                              \
2072                                                                         \
2073   &rs6000_reg_names[32][0],     /* fr0  */                              \
2074   &rs6000_reg_names[33][0],     /* fr1  */                              \
2075   &rs6000_reg_names[34][0],     /* fr2  */                              \
2076   &rs6000_reg_names[35][0],     /* fr3  */                              \
2077   &rs6000_reg_names[36][0],     /* fr4  */                              \
2078   &rs6000_reg_names[37][0],     /* fr5  */                              \
2079   &rs6000_reg_names[38][0],     /* fr6  */                              \
2080   &rs6000_reg_names[39][0],     /* fr7  */                              \
2081   &rs6000_reg_names[40][0],     /* fr8  */                              \
2082   &rs6000_reg_names[41][0],     /* fr9  */                              \
2083   &rs6000_reg_names[42][0],     /* fr10 */                              \
2084   &rs6000_reg_names[43][0],     /* fr11 */                              \
2085   &rs6000_reg_names[44][0],     /* fr12 */                              \
2086   &rs6000_reg_names[45][0],     /* fr13 */                              \
2087   &rs6000_reg_names[46][0],     /* fr14 */                              \
2088   &rs6000_reg_names[47][0],     /* fr15 */                              \
2089   &rs6000_reg_names[48][0],     /* fr16 */                              \
2090   &rs6000_reg_names[49][0],     /* fr17 */                              \
2091   &rs6000_reg_names[50][0],     /* fr18 */                              \
2092   &rs6000_reg_names[51][0],     /* fr19 */                              \
2093   &rs6000_reg_names[52][0],     /* fr20 */                              \
2094   &rs6000_reg_names[53][0],     /* fr21 */                              \
2095   &rs6000_reg_names[54][0],     /* fr22 */                              \
2096   &rs6000_reg_names[55][0],     /* fr23 */                              \
2097   &rs6000_reg_names[56][0],     /* fr24 */                              \
2098   &rs6000_reg_names[57][0],     /* fr25 */                              \
2099   &rs6000_reg_names[58][0],     /* fr26 */                              \
2100   &rs6000_reg_names[59][0],     /* fr27 */                              \
2101   &rs6000_reg_names[60][0],     /* fr28 */                              \
2102   &rs6000_reg_names[61][0],     /* fr29 */                              \
2103   &rs6000_reg_names[62][0],     /* fr30 */                              \
2104   &rs6000_reg_names[63][0],     /* fr31 */                              \
2105                                                                         \
2106   &rs6000_reg_names[64][0],     /* mq   */                              \
2107   &rs6000_reg_names[65][0],     /* lr   */                              \
2108   &rs6000_reg_names[66][0],     /* ctr  */                              \
2109   &rs6000_reg_names[67][0],     /* ap   */                              \
2110                                                                         \
2111   &rs6000_reg_names[68][0],     /* cr0  */                              \
2112   &rs6000_reg_names[69][0],     /* cr1  */                              \
2113   &rs6000_reg_names[70][0],     /* cr2  */                              \
2114   &rs6000_reg_names[71][0],     /* cr3  */                              \
2115   &rs6000_reg_names[72][0],     /* cr4  */                              \
2116   &rs6000_reg_names[73][0],     /* cr5  */                              \
2117   &rs6000_reg_names[74][0],     /* cr6  */                              \
2118   &rs6000_reg_names[75][0],     /* cr7  */                              \
2119                                                                         \
2120   &rs6000_reg_names[76][0],     /* xer  */                              \
2121                                                                         \
2122   &rs6000_reg_names[77][0],     /* v0  */                               \
2123   &rs6000_reg_names[78][0],     /* v1  */                               \
2124   &rs6000_reg_names[79][0],     /* v2  */                               \
2125   &rs6000_reg_names[80][0],     /* v3  */                               \
2126   &rs6000_reg_names[81][0],     /* v4  */                               \
2127   &rs6000_reg_names[82][0],     /* v5  */                               \
2128   &rs6000_reg_names[83][0],     /* v6  */                               \
2129   &rs6000_reg_names[84][0],     /* v7  */                               \
2130   &rs6000_reg_names[85][0],     /* v8  */                               \
2131   &rs6000_reg_names[86][0],     /* v9  */                               \
2132   &rs6000_reg_names[87][0],     /* v10  */                              \
2133   &rs6000_reg_names[88][0],     /* v11  */                              \
2134   &rs6000_reg_names[89][0],     /* v12  */                              \
2135   &rs6000_reg_names[90][0],     /* v13  */                              \
2136   &rs6000_reg_names[91][0],     /* v14  */                              \
2137   &rs6000_reg_names[92][0],     /* v15  */                              \
2138   &rs6000_reg_names[93][0],     /* v16  */                              \
2139   &rs6000_reg_names[94][0],     /* v17  */                              \
2140   &rs6000_reg_names[95][0],     /* v18  */                              \
2141   &rs6000_reg_names[96][0],     /* v19  */                              \
2142   &rs6000_reg_names[97][0],     /* v20  */                              \
2143   &rs6000_reg_names[98][0],     /* v21  */                              \
2144   &rs6000_reg_names[99][0],     /* v22  */                              \
2145   &rs6000_reg_names[100][0],    /* v23  */                              \
2146   &rs6000_reg_names[101][0],    /* v24  */                              \
2147   &rs6000_reg_names[102][0],    /* v25  */                              \
2148   &rs6000_reg_names[103][0],    /* v26  */                              \
2149   &rs6000_reg_names[104][0],    /* v27  */                              \
2150   &rs6000_reg_names[105][0],    /* v28  */                              \
2151   &rs6000_reg_names[106][0],    /* v29  */                              \
2152   &rs6000_reg_names[107][0],    /* v30  */                              \
2153   &rs6000_reg_names[108][0],    /* v31  */                              \
2154   &rs6000_reg_names[109][0],    /* vrsave  */                           \
2155   &rs6000_reg_names[110][0],    /* vscr  */                             \
2156   &rs6000_reg_names[111][0],    /* spe_acc */                           \
2157   &rs6000_reg_names[112][0],    /* spefscr */                           \
2158   &rs6000_reg_names[113][0],    /* sfp  */                              \
2159 }
2160
2161 /* Table of additional register names to use in user input.  */
2162
2163 #define ADDITIONAL_REGISTER_NAMES \
2164  {{"r0",    0}, {"r1",    1}, {"r2",    2}, {"r3",    3},       \
2165   {"r4",    4}, {"r5",    5}, {"r6",    6}, {"r7",    7},       \
2166   {"r8",    8}, {"r9",    9}, {"r10",  10}, {"r11",  11},       \
2167   {"r12",  12}, {"r13",  13}, {"r14",  14}, {"r15",  15},       \
2168   {"r16",  16}, {"r17",  17}, {"r18",  18}, {"r19",  19},       \
2169   {"r20",  20}, {"r21",  21}, {"r22",  22}, {"r23",  23},       \
2170   {"r24",  24}, {"r25",  25}, {"r26",  26}, {"r27",  27},       \
2171   {"r28",  28}, {"r29",  29}, {"r30",  30}, {"r31",  31},       \
2172   {"fr0",  32}, {"fr1",  33}, {"fr2",  34}, {"fr3",  35},       \
2173   {"fr4",  36}, {"fr5",  37}, {"fr6",  38}, {"fr7",  39},       \
2174   {"fr8",  40}, {"fr9",  41}, {"fr10", 42}, {"fr11", 43},       \
2175   {"fr12", 44}, {"fr13", 45}, {"fr14", 46}, {"fr15", 47},       \
2176   {"fr16", 48}, {"fr17", 49}, {"fr18", 50}, {"fr19", 51},       \
2177   {"fr20", 52}, {"fr21", 53}, {"fr22", 54}, {"fr23", 55},       \
2178   {"fr24", 56}, {"fr25", 57}, {"fr26", 58}, {"fr27", 59},       \
2179   {"fr28", 60}, {"fr29", 61}, {"fr30", 62}, {"fr31", 63},       \
2180   {"v0",   77}, {"v1",   78}, {"v2",   79}, {"v3",   80},       \
2181   {"v4",   81}, {"v5",   82}, {"v6",   83}, {"v7",   84},       \
2182   {"v8",   85}, {"v9",   86}, {"v10",  87}, {"v11",  88},       \
2183   {"v12",  89}, {"v13",  90}, {"v14",  91}, {"v15",  92},       \
2184   {"v16",  93}, {"v17",  94}, {"v18",  95}, {"v19",  96},       \
2185   {"v20",  97}, {"v21",  98}, {"v22",  99}, {"v23",  100},      \
2186   {"v24",  101},{"v25",  102},{"v26",  103},{"v27",  104},      \
2187   {"v28",  105},{"v29",  106},{"v30",  107},{"v31",  108},      \
2188   {"vrsave", 109}, {"vscr", 110},                               \
2189   {"spe_acc", 111}, {"spefscr", 112},                           \
2190   /* no additional names for: mq, lr, ctr, ap */                \
2191   {"cr0",  68}, {"cr1",  69}, {"cr2",  70}, {"cr3",  71},       \
2192   {"cr4",  72}, {"cr5",  73}, {"cr6",  74}, {"cr7",  75},       \
2193   {"cc",   68}, {"sp",    1}, {"toc",   2} }
2194
2195 /* Text to write out after a CALL that may be replaced by glue code by
2196    the loader.  This depends on the AIX version.  */
2197 #define RS6000_CALL_GLUE "cror 31,31,31"
2198
2199 /* This is how to output an element of a case-vector that is relative.  */
2200
2201 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) \
2202   do { char buf[100];                                   \
2203        fputs ("\t.long ", FILE);                        \
2204        ASM_GENERATE_INTERNAL_LABEL (buf, "L", VALUE);   \
2205        assemble_name (FILE, buf);                       \
2206        putc ('-', FILE);                                \
2207        ASM_GENERATE_INTERNAL_LABEL (buf, "L", REL);     \
2208        assemble_name (FILE, buf);                       \
2209        putc ('\n', FILE);                               \
2210      } while (0)
2211
2212 /* This is how to output an assembler line
2213    that says to advance the location counter
2214    to a multiple of 2**LOG bytes.  */
2215
2216 #define ASM_OUTPUT_ALIGN(FILE,LOG)      \
2217   if ((LOG) != 0)                       \
2218     fprintf (FILE, "\t.align %d\n", (LOG))
2219
2220 /* Pick up the return address upon entry to a procedure. Used for
2221    dwarf2 unwind information.  This also enables the table driven
2222    mechanism.  */
2223
2224 #define INCOMING_RETURN_ADDR_RTX   gen_rtx_REG (Pmode, LINK_REGISTER_REGNUM)
2225 #define DWARF_FRAME_RETURN_COLUMN  DWARF_FRAME_REGNUM (LINK_REGISTER_REGNUM)
2226
2227 /* Describe how we implement __builtin_eh_return.  */
2228 #define EH_RETURN_DATA_REGNO(N) ((N) < 4 ? (N) + 3 : INVALID_REGNUM)
2229 #define EH_RETURN_STACKADJ_RTX  gen_rtx_REG (Pmode, 10)
2230
2231 /* Print operand X (an rtx) in assembler syntax to file FILE.
2232    CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified.
2233    For `%' followed by punctuation, CODE is the punctuation and X is null.  */
2234
2235 #define PRINT_OPERAND(FILE, X, CODE)  print_operand (FILE, X, CODE)
2236
2237 /* Define which CODE values are valid.  */
2238
2239 #define PRINT_OPERAND_PUNCT_VALID_P(CODE)  \
2240   ((CODE) == '.' || (CODE) == '&')
2241
2242 /* Print a memory address as an operand to reference that memory location.  */
2243
2244 #define PRINT_OPERAND_ADDRESS(FILE, ADDR) print_operand_address (FILE, ADDR)
2245
2246 /* uncomment for disabling the corresponding default options */
2247 /* #define  MACHINE_no_sched_interblock */
2248 /* #define  MACHINE_no_sched_speculative */
2249 /* #define  MACHINE_no_sched_speculative_load */
2250
2251 /* General flags.  */
2252 extern int flag_pic;
2253 extern int optimize;
2254 extern int flag_expensive_optimizations;
2255 extern int frame_pointer_needed;
2256
2257 enum rs6000_builtins
2258 {
2259   /* AltiVec builtins.  */
2260   ALTIVEC_BUILTIN_ST_INTERNAL_4si,
2261   ALTIVEC_BUILTIN_LD_INTERNAL_4si,
2262   ALTIVEC_BUILTIN_ST_INTERNAL_8hi,
2263   ALTIVEC_BUILTIN_LD_INTERNAL_8hi,
2264   ALTIVEC_BUILTIN_ST_INTERNAL_16qi,
2265   ALTIVEC_BUILTIN_LD_INTERNAL_16qi,
2266   ALTIVEC_BUILTIN_ST_INTERNAL_4sf,
2267   ALTIVEC_BUILTIN_LD_INTERNAL_4sf,
2268   ALTIVEC_BUILTIN_VADDUBM,
2269   ALTIVEC_BUILTIN_VADDUHM,
2270   ALTIVEC_BUILTIN_VADDUWM,
2271   ALTIVEC_BUILTIN_VADDFP,
2272   ALTIVEC_BUILTIN_VADDCUW,
2273   ALTIVEC_BUILTIN_VADDUBS,
2274   ALTIVEC_BUILTIN_VADDSBS,
2275   ALTIVEC_BUILTIN_VADDUHS,
2276   ALTIVEC_BUILTIN_VADDSHS,
2277   ALTIVEC_BUILTIN_VADDUWS,
2278   ALTIVEC_BUILTIN_VADDSWS,
2279   ALTIVEC_BUILTIN_VAND,
2280   ALTIVEC_BUILTIN_VANDC,
2281   ALTIVEC_BUILTIN_VAVGUB,
2282   ALTIVEC_BUILTIN_VAVGSB,
2283   ALTIVEC_BUILTIN_VAVGUH,
2284   ALTIVEC_BUILTIN_VAVGSH,
2285   ALTIVEC_BUILTIN_VAVGUW,
2286   ALTIVEC_BUILTIN_VAVGSW,
2287   ALTIVEC_BUILTIN_VCFUX,
2288   ALTIVEC_BUILTIN_VCFSX,
2289   ALTIVEC_BUILTIN_VCTSXS,
2290   ALTIVEC_BUILTIN_VCTUXS,
2291   ALTIVEC_BUILTIN_VCMPBFP,
2292   ALTIVEC_BUILTIN_VCMPEQUB,
2293   ALTIVEC_BUILTIN_VCMPEQUH,
2294   ALTIVEC_BUILTIN_VCMPEQUW,
2295   ALTIVEC_BUILTIN_VCMPEQFP,
2296   ALTIVEC_BUILTIN_VCMPGEFP,
2297   ALTIVEC_BUILTIN_VCMPGTUB,
2298   ALTIVEC_BUILTIN_VCMPGTSB,
2299   ALTIVEC_BUILTIN_VCMPGTUH,
2300   ALTIVEC_BUILTIN_VCMPGTSH,
2301   ALTIVEC_BUILTIN_VCMPGTUW,
2302   ALTIVEC_BUILTIN_VCMPGTSW,
2303   ALTIVEC_BUILTIN_VCMPGTFP,
2304   ALTIVEC_BUILTIN_VEXPTEFP,
2305   ALTIVEC_BUILTIN_VLOGEFP,
2306   ALTIVEC_BUILTIN_VMADDFP,
2307   ALTIVEC_BUILTIN_VMAXUB,
2308   ALTIVEC_BUILTIN_VMAXSB,
2309   ALTIVEC_BUILTIN_VMAXUH,
2310   ALTIVEC_BUILTIN_VMAXSH,
2311   ALTIVEC_BUILTIN_VMAXUW,
2312   ALTIVEC_BUILTIN_VMAXSW,
2313   ALTIVEC_BUILTIN_VMAXFP,
2314   ALTIVEC_BUILTIN_VMHADDSHS,
2315   ALTIVEC_BUILTIN_VMHRADDSHS,
2316   ALTIVEC_BUILTIN_VMLADDUHM,
2317   ALTIVEC_BUILTIN_VMRGHB,
2318   ALTIVEC_BUILTIN_VMRGHH,
2319   ALTIVEC_BUILTIN_VMRGHW,
2320   ALTIVEC_BUILTIN_VMRGLB,
2321   ALTIVEC_BUILTIN_VMRGLH,
2322   ALTIVEC_BUILTIN_VMRGLW,
2323   ALTIVEC_BUILTIN_VMSUMUBM,
2324   ALTIVEC_BUILTIN_VMSUMMBM,
2325   ALTIVEC_BUILTIN_VMSUMUHM,
2326   ALTIVEC_BUILTIN_VMSUMSHM,
2327   ALTIVEC_BUILTIN_VMSUMUHS,
2328   ALTIVEC_BUILTIN_VMSUMSHS,
2329   ALTIVEC_BUILTIN_VMINUB,
2330   ALTIVEC_BUILTIN_VMINSB,
2331   ALTIVEC_BUILTIN_VMINUH,
2332   ALTIVEC_BUILTIN_VMINSH,
2333   ALTIVEC_BUILTIN_VMINUW,
2334   ALTIVEC_BUILTIN_VMINSW,
2335   ALTIVEC_BUILTIN_VMINFP,
2336   ALTIVEC_BUILTIN_VMULEUB,
2337   ALTIVEC_BUILTIN_VMULESB,
2338   ALTIVEC_BUILTIN_VMULEUH,
2339   ALTIVEC_BUILTIN_VMULESH,
2340   ALTIVEC_BUILTIN_VMULOUB,
2341   ALTIVEC_BUILTIN_VMULOSB,
2342   ALTIVEC_BUILTIN_VMULOUH,
2343   ALTIVEC_BUILTIN_VMULOSH,
2344   ALTIVEC_BUILTIN_VNMSUBFP,
2345   ALTIVEC_BUILTIN_VNOR,
2346   ALTIVEC_BUILTIN_VOR,
2347   ALTIVEC_BUILTIN_VSEL_4SI,
2348   ALTIVEC_BUILTIN_VSEL_4SF,
2349   ALTIVEC_BUILTIN_VSEL_8HI,
2350   ALTIVEC_BUILTIN_VSEL_16QI,
2351   ALTIVEC_BUILTIN_VPERM_4SI,
2352   ALTIVEC_BUILTIN_VPERM_4SF,
2353   ALTIVEC_BUILTIN_VPERM_8HI,
2354   ALTIVEC_BUILTIN_VPERM_16QI,
2355   ALTIVEC_BUILTIN_VPKUHUM,
2356   ALTIVEC_BUILTIN_VPKUWUM,
2357   ALTIVEC_BUILTIN_VPKPX,
2358   ALTIVEC_BUILTIN_VPKUHSS,
2359   ALTIVEC_BUILTIN_VPKSHSS,
2360   ALTIVEC_BUILTIN_VPKUWSS,
2361   ALTIVEC_BUILTIN_VPKSWSS,
2362   ALTIVEC_BUILTIN_VPKUHUS,
2363   ALTIVEC_BUILTIN_VPKSHUS,
2364   ALTIVEC_BUILTIN_VPKUWUS,
2365   ALTIVEC_BUILTIN_VPKSWUS,
2366   ALTIVEC_BUILTIN_VREFP,
2367   ALTIVEC_BUILTIN_VRFIM,
2368   ALTIVEC_BUILTIN_VRFIN,
2369   ALTIVEC_BUILTIN_VRFIP,
2370   ALTIVEC_BUILTIN_VRFIZ,
2371   ALTIVEC_BUILTIN_VRLB,
2372   ALTIVEC_BUILTIN_VRLH,
2373   ALTIVEC_BUILTIN_VRLW,
2374   ALTIVEC_BUILTIN_VRSQRTEFP,
2375   ALTIVEC_BUILTIN_VSLB,
2376   ALTIVEC_BUILTIN_VSLH,
2377   ALTIVEC_BUILTIN_VSLW,
2378   ALTIVEC_BUILTIN_VSL,
2379   ALTIVEC_BUILTIN_VSLO,
2380   ALTIVEC_BUILTIN_VSPLTB,
2381   ALTIVEC_BUILTIN_VSPLTH,
2382   ALTIVEC_BUILTIN_VSPLTW,
2383   ALTIVEC_BUILTIN_VSPLTISB,
2384   ALTIVEC_BUILTIN_VSPLTISH,
2385   ALTIVEC_BUILTIN_VSPLTISW,
2386   ALTIVEC_BUILTIN_VSRB,
2387   ALTIVEC_BUILTIN_VSRH,
2388   ALTIVEC_BUILTIN_VSRW,
2389   ALTIVEC_BUILTIN_VSRAB,
2390   ALTIVEC_BUILTIN_VSRAH,
2391   ALTIVEC_BUILTIN_VSRAW,
2392   ALTIVEC_BUILTIN_VSR,
2393   ALTIVEC_BUILTIN_VSRO,
2394   ALTIVEC_BUILTIN_VSUBUBM,
2395   ALTIVEC_BUILTIN_VSUBUHM,
2396   ALTIVEC_BUILTIN_VSUBUWM,
2397   ALTIVEC_BUILTIN_VSUBFP,
2398   ALTIVEC_BUILTIN_VSUBCUW,
2399   ALTIVEC_BUILTIN_VSUBUBS,
2400   ALTIVEC_BUILTIN_VSUBSBS,
2401   ALTIVEC_BUILTIN_VSUBUHS,
2402   ALTIVEC_BUILTIN_VSUBSHS,
2403   ALTIVEC_BUILTIN_VSUBUWS,
2404   ALTIVEC_BUILTIN_VSUBSWS,
2405   ALTIVEC_BUILTIN_VSUM4UBS,
2406   ALTIVEC_BUILTIN_VSUM4SBS,
2407   ALTIVEC_BUILTIN_VSUM4SHS,
2408   ALTIVEC_BUILTIN_VSUM2SWS,
2409   ALTIVEC_BUILTIN_VSUMSWS,
2410   ALTIVEC_BUILTIN_VXOR,
2411   ALTIVEC_BUILTIN_VSLDOI_16QI,
2412   ALTIVEC_BUILTIN_VSLDOI_8HI,
2413   ALTIVEC_BUILTIN_VSLDOI_4SI,
2414   ALTIVEC_BUILTIN_VSLDOI_4SF,
2415   ALTIVEC_BUILTIN_VUPKHSB,
2416   ALTIVEC_BUILTIN_VUPKHPX,
2417   ALTIVEC_BUILTIN_VUPKHSH,
2418   ALTIVEC_BUILTIN_VUPKLSB,
2419   ALTIVEC_BUILTIN_VUPKLPX,
2420   ALTIVEC_BUILTIN_VUPKLSH,
2421   ALTIVEC_BUILTIN_MTVSCR,
2422   ALTIVEC_BUILTIN_MFVSCR,
2423   ALTIVEC_BUILTIN_DSSALL,
2424   ALTIVEC_BUILTIN_DSS,
2425   ALTIVEC_BUILTIN_LVSL,
2426   ALTIVEC_BUILTIN_LVSR,
2427   ALTIVEC_BUILTIN_DSTT,
2428   ALTIVEC_BUILTIN_DSTST,
2429   ALTIVEC_BUILTIN_DSTSTT,
2430   ALTIVEC_BUILTIN_DST,
2431   ALTIVEC_BUILTIN_LVEBX,
2432   ALTIVEC_BUILTIN_LVEHX,
2433   ALTIVEC_BUILTIN_LVEWX,
2434   ALTIVEC_BUILTIN_LVXL,
2435   ALTIVEC_BUILTIN_LVX,
2436   ALTIVEC_BUILTIN_STVX,
2437   ALTIVEC_BUILTIN_STVEBX,
2438   ALTIVEC_BUILTIN_STVEHX,
2439   ALTIVEC_BUILTIN_STVEWX,
2440   ALTIVEC_BUILTIN_STVXL,
2441   ALTIVEC_BUILTIN_VCMPBFP_P,
2442   ALTIVEC_BUILTIN_VCMPEQFP_P,
2443   ALTIVEC_BUILTIN_VCMPEQUB_P,
2444   ALTIVEC_BUILTIN_VCMPEQUH_P,
2445   ALTIVEC_BUILTIN_VCMPEQUW_P,
2446   ALTIVEC_BUILTIN_VCMPGEFP_P,
2447   ALTIVEC_BUILTIN_VCMPGTFP_P,
2448   ALTIVEC_BUILTIN_VCMPGTSB_P,
2449   ALTIVEC_BUILTIN_VCMPGTSH_P,
2450   ALTIVEC_BUILTIN_VCMPGTSW_P,
2451   ALTIVEC_BUILTIN_VCMPGTUB_P,
2452   ALTIVEC_BUILTIN_VCMPGTUH_P,
2453   ALTIVEC_BUILTIN_VCMPGTUW_P,
2454   ALTIVEC_BUILTIN_ABSS_V4SI,
2455   ALTIVEC_BUILTIN_ABSS_V8HI,
2456   ALTIVEC_BUILTIN_ABSS_V16QI,
2457   ALTIVEC_BUILTIN_ABS_V4SI,
2458   ALTIVEC_BUILTIN_ABS_V4SF,
2459   ALTIVEC_BUILTIN_ABS_V8HI,
2460   ALTIVEC_BUILTIN_ABS_V16QI,
2461   ALTIVEC_BUILTIN_MASK_FOR_LOAD,
2462   ALTIVEC_BUILTIN_MASK_FOR_STORE,
2463   ALTIVEC_BUILTIN_VEC_INIT_V4SI,
2464   ALTIVEC_BUILTIN_VEC_INIT_V8HI,
2465   ALTIVEC_BUILTIN_VEC_INIT_V16QI,
2466   ALTIVEC_BUILTIN_VEC_INIT_V4SF,
2467   ALTIVEC_BUILTIN_VEC_SET_V4SI,
2468   ALTIVEC_BUILTIN_VEC_SET_V8HI,
2469   ALTIVEC_BUILTIN_VEC_SET_V16QI,
2470   ALTIVEC_BUILTIN_VEC_SET_V4SF,
2471   ALTIVEC_BUILTIN_VEC_EXT_V4SI,
2472   ALTIVEC_BUILTIN_VEC_EXT_V8HI,
2473   ALTIVEC_BUILTIN_VEC_EXT_V16QI,
2474   ALTIVEC_BUILTIN_VEC_EXT_V4SF,
2475
2476   /* Altivec overloaded builtins.  */
2477   ALTIVEC_BUILTIN_VCMPEQ_P,
2478   ALTIVEC_BUILTIN_OVERLOADED_FIRST = ALTIVEC_BUILTIN_VCMPEQ_P,
2479   ALTIVEC_BUILTIN_VCMPGT_P,
2480   ALTIVEC_BUILTIN_VCMPGE_P,
2481   ALTIVEC_BUILTIN_VEC_ABS,
2482   ALTIVEC_BUILTIN_VEC_ABSS,
2483   ALTIVEC_BUILTIN_VEC_ADD,
2484   ALTIVEC_BUILTIN_VEC_ADDC,
2485   ALTIVEC_BUILTIN_VEC_ADDS,
2486   ALTIVEC_BUILTIN_VEC_AND,
2487   ALTIVEC_BUILTIN_VEC_ANDC,
2488   ALTIVEC_BUILTIN_VEC_AVG,
2489   ALTIVEC_BUILTIN_VEC_CEIL,
2490   ALTIVEC_BUILTIN_VEC_CMPB,
2491   ALTIVEC_BUILTIN_VEC_CMPEQ,
2492   ALTIVEC_BUILTIN_VEC_CMPEQUB,
2493   ALTIVEC_BUILTIN_VEC_CMPEQUH,
2494   ALTIVEC_BUILTIN_VEC_CMPEQUW,
2495   ALTIVEC_BUILTIN_VEC_CMPGE,
2496   ALTIVEC_BUILTIN_VEC_CMPGT,
2497   ALTIVEC_BUILTIN_VEC_CMPLE,
2498   ALTIVEC_BUILTIN_VEC_CMPLT,
2499   ALTIVEC_BUILTIN_VEC_CTF,
2500   ALTIVEC_BUILTIN_VEC_CTS,
2501   ALTIVEC_BUILTIN_VEC_CTU,
2502   ALTIVEC_BUILTIN_VEC_DST,
2503   ALTIVEC_BUILTIN_VEC_DSTST,
2504   ALTIVEC_BUILTIN_VEC_DSTSTT,
2505   ALTIVEC_BUILTIN_VEC_DSTT,
2506   ALTIVEC_BUILTIN_VEC_EXPTE,
2507   ALTIVEC_BUILTIN_VEC_FLOOR,
2508   ALTIVEC_BUILTIN_VEC_LD,
2509   ALTIVEC_BUILTIN_VEC_LDE,
2510   ALTIVEC_BUILTIN_VEC_LDL,
2511   ALTIVEC_BUILTIN_VEC_LOGE,
2512   ALTIVEC_BUILTIN_VEC_LVEBX,
2513   ALTIVEC_BUILTIN_VEC_LVEHX,
2514   ALTIVEC_BUILTIN_VEC_LVEWX,
2515   ALTIVEC_BUILTIN_VEC_LVSL,
2516   ALTIVEC_BUILTIN_VEC_LVSR,
2517   ALTIVEC_BUILTIN_VEC_MADD,
2518   ALTIVEC_BUILTIN_VEC_MADDS,
2519   ALTIVEC_BUILTIN_VEC_MAX,
2520   ALTIVEC_BUILTIN_VEC_MERGEH,
2521   ALTIVEC_BUILTIN_VEC_MERGEL,
2522   ALTIVEC_BUILTIN_VEC_MIN,
2523   ALTIVEC_BUILTIN_VEC_MLADD,
2524   ALTIVEC_BUILTIN_VEC_MPERM,
2525   ALTIVEC_BUILTIN_VEC_MRADDS,
2526   ALTIVEC_BUILTIN_VEC_MRGHB,
2527   ALTIVEC_BUILTIN_VEC_MRGHH,
2528   ALTIVEC_BUILTIN_VEC_MRGHW,
2529   ALTIVEC_BUILTIN_VEC_MRGLB,
2530   ALTIVEC_BUILTIN_VEC_MRGLH,
2531   ALTIVEC_BUILTIN_VEC_MRGLW,
2532   ALTIVEC_BUILTIN_VEC_MSUM,
2533   ALTIVEC_BUILTIN_VEC_MSUMS,
2534   ALTIVEC_BUILTIN_VEC_MTVSCR,
2535   ALTIVEC_BUILTIN_VEC_MULE,
2536   ALTIVEC_BUILTIN_VEC_MULO,
2537   ALTIVEC_BUILTIN_VEC_NMSUB,
2538   ALTIVEC_BUILTIN_VEC_NOR,
2539   ALTIVEC_BUILTIN_VEC_OR,
2540   ALTIVEC_BUILTIN_VEC_PACK,
2541   ALTIVEC_BUILTIN_VEC_PACKPX,
2542   ALTIVEC_BUILTIN_VEC_PACKS,
2543   ALTIVEC_BUILTIN_VEC_PACKSU,
2544   ALTIVEC_BUILTIN_VEC_PERM,
2545   ALTIVEC_BUILTIN_VEC_RE,
2546   ALTIVEC_BUILTIN_VEC_RL,
2547   ALTIVEC_BUILTIN_VEC_ROUND,
2548   ALTIVEC_BUILTIN_VEC_RSQRTE,
2549   ALTIVEC_BUILTIN_VEC_SEL,
2550   ALTIVEC_BUILTIN_VEC_SL,
2551   ALTIVEC_BUILTIN_VEC_SLD,
2552   ALTIVEC_BUILTIN_VEC_SLL,
2553   ALTIVEC_BUILTIN_VEC_SLO,
2554   ALTIVEC_BUILTIN_VEC_SPLAT,
2555   ALTIVEC_BUILTIN_VEC_SPLAT_S16,
2556   ALTIVEC_BUILTIN_VEC_SPLAT_S32,
2557   ALTIVEC_BUILTIN_VEC_SPLAT_S8,
2558   ALTIVEC_BUILTIN_VEC_SPLAT_U16,
2559   ALTIVEC_BUILTIN_VEC_SPLAT_U32,
2560   ALTIVEC_BUILTIN_VEC_SPLAT_U8,
2561   ALTIVEC_BUILTIN_VEC_SPLTB,
2562   ALTIVEC_BUILTIN_VEC_SPLTH,
2563   ALTIVEC_BUILTIN_VEC_SPLTW,
2564   ALTIVEC_BUILTIN_VEC_SR,
2565   ALTIVEC_BUILTIN_VEC_SRA,
2566   ALTIVEC_BUILTIN_VEC_SRL,
2567   ALTIVEC_BUILTIN_VEC_SRO,
2568   ALTIVEC_BUILTIN_VEC_ST,
2569   ALTIVEC_BUILTIN_VEC_STE,
2570   ALTIVEC_BUILTIN_VEC_STL,
2571   ALTIVEC_BUILTIN_VEC_STVEBX,
2572   ALTIVEC_BUILTIN_VEC_STVEHX,
2573   ALTIVEC_BUILTIN_VEC_STVEWX,
2574   ALTIVEC_BUILTIN_VEC_SUB,
2575   ALTIVEC_BUILTIN_VEC_SUBC,
2576   ALTIVEC_BUILTIN_VEC_SUBS,
2577   ALTIVEC_BUILTIN_VEC_SUM2S,
2578   ALTIVEC_BUILTIN_VEC_SUM4S,
2579   ALTIVEC_BUILTIN_VEC_SUMS,
2580   ALTIVEC_BUILTIN_VEC_TRUNC,
2581   ALTIVEC_BUILTIN_VEC_UNPACKH,
2582   ALTIVEC_BUILTIN_VEC_UNPACKL,
2583   ALTIVEC_BUILTIN_VEC_VADDFP,
2584   ALTIVEC_BUILTIN_VEC_VADDSBS,
2585   ALTIVEC_BUILTIN_VEC_VADDSHS,
2586   ALTIVEC_BUILTIN_VEC_VADDSWS,
2587   ALTIVEC_BUILTIN_VEC_VADDUBM,
2588   ALTIVEC_BUILTIN_VEC_VADDUBS,
2589   ALTIVEC_BUILTIN_VEC_VADDUHM,
2590   ALTIVEC_BUILTIN_VEC_VADDUHS,
2591   ALTIVEC_BUILTIN_VEC_VADDUWM,
2592   ALTIVEC_BUILTIN_VEC_VADDUWS,
2593   ALTIVEC_BUILTIN_VEC_VAVGSB,
2594   ALTIVEC_BUILTIN_VEC_VAVGSH,
2595   ALTIVEC_BUILTIN_VEC_VAVGSW,
2596   ALTIVEC_BUILTIN_VEC_VAVGUB,
2597   ALTIVEC_BUILTIN_VEC_VAVGUH,
2598   ALTIVEC_BUILTIN_VEC_VAVGUW,
2599   ALTIVEC_BUILTIN_VEC_VCFSX,
2600   ALTIVEC_BUILTIN_VEC_VCFUX,
2601   ALTIVEC_BUILTIN_VEC_VCMPEQFP,
2602   ALTIVEC_BUILTIN_VEC_VCMPEQUB,
2603   ALTIVEC_BUILTIN_VEC_VCMPEQUH,
2604   ALTIVEC_BUILTIN_VEC_VCMPEQUW,
2605   ALTIVEC_BUILTIN_VEC_VCMPGTFP,
2606   ALTIVEC_BUILTIN_VEC_VCMPGTSB,
2607   ALTIVEC_BUILTIN_VEC_VCMPGTSH,
2608   ALTIVEC_BUILTIN_VEC_VCMPGTSW,
2609   ALTIVEC_BUILTIN_VEC_VCMPGTUB,
2610   ALTIVEC_BUILTIN_VEC_VCMPGTUH,
2611   ALTIVEC_BUILTIN_VEC_VCMPGTUW,
2612   ALTIVEC_BUILTIN_VEC_VMAXFP,
2613   ALTIVEC_BUILTIN_VEC_VMAXSB,
2614   ALTIVEC_BUILTIN_VEC_VMAXSH,
2615   ALTIVEC_BUILTIN_VEC_VMAXSW,
2616   ALTIVEC_BUILTIN_VEC_VMAXUB,
2617   ALTIVEC_BUILTIN_VEC_VMAXUH,
2618   ALTIVEC_BUILTIN_VEC_VMAXUW,
2619   ALTIVEC_BUILTIN_VEC_VMINFP,
2620   ALTIVEC_BUILTIN_VEC_VMINSB,
2621   ALTIVEC_BUILTIN_VEC_VMINSH,
2622   ALTIVEC_BUILTIN_VEC_VMINSW,
2623   ALTIVEC_BUILTIN_VEC_VMINUB,
2624   ALTIVEC_BUILTIN_VEC_VMINUH,
2625   ALTIVEC_BUILTIN_VEC_VMINUW,
2626   ALTIVEC_BUILTIN_VEC_VMRGHB,
2627   ALTIVEC_BUILTIN_VEC_VMRGHH,
2628   ALTIVEC_BUILTIN_VEC_VMRGHW,
2629   ALTIVEC_BUILTIN_VEC_VMRGLB,
2630   ALTIVEC_BUILTIN_VEC_VMRGLH,
2631   ALTIVEC_BUILTIN_VEC_VMRGLW,
2632   ALTIVEC_BUILTIN_VEC_VMSUMMBM,
2633   ALTIVEC_BUILTIN_VEC_VMSUMSHM,
2634   ALTIVEC_BUILTIN_VEC_VMSUMSHS,
2635   ALTIVEC_BUILTIN_VEC_VMSUMUBM,
2636   ALTIVEC_BUILTIN_VEC_VMSUMUHM,
2637   ALTIVEC_BUILTIN_VEC_VMSUMUHS,
2638   ALTIVEC_BUILTIN_VEC_VMULESB,
2639   ALTIVEC_BUILTIN_VEC_VMULESH,
2640   ALTIVEC_BUILTIN_VEC_VMULEUB,
2641   ALTIVEC_BUILTIN_VEC_VMULEUH,
2642   ALTIVEC_BUILTIN_VEC_VMULOSB,
2643   ALTIVEC_BUILTIN_VEC_VMULOSH,
2644   ALTIVEC_BUILTIN_VEC_VMULOUB,
2645   ALTIVEC_BUILTIN_VEC_VMULOUH,
2646   ALTIVEC_BUILTIN_VEC_VPKSHSS,
2647   ALTIVEC_BUILTIN_VEC_VPKSHUS,
2648   ALTIVEC_BUILTIN_VEC_VPKSWSS,
2649   ALTIVEC_BUILTIN_VEC_VPKSWUS,
2650   ALTIVEC_BUILTIN_VEC_VPKUHUM,
2651   ALTIVEC_BUILTIN_VEC_VPKUHUS,
2652   ALTIVEC_BUILTIN_VEC_VPKUWUM,
2653   ALTIVEC_BUILTIN_VEC_VPKUWUS,
2654   ALTIVEC_BUILTIN_VEC_VRLB,
2655   ALTIVEC_BUILTIN_VEC_VRLH,
2656   ALTIVEC_BUILTIN_VEC_VRLW,
2657   ALTIVEC_BUILTIN_VEC_VSLB,
2658   ALTIVEC_BUILTIN_VEC_VSLH,
2659   ALTIVEC_BUILTIN_VEC_VSLW,
2660   ALTIVEC_BUILTIN_VEC_VSPLTB,
2661   ALTIVEC_BUILTIN_VEC_VSPLTH,
2662   ALTIVEC_BUILTIN_VEC_VSPLTW,
2663   ALTIVEC_BUILTIN_VEC_VSRAB,
2664   ALTIVEC_BUILTIN_VEC_VSRAH,
2665   ALTIVEC_BUILTIN_VEC_VSRAW,
2666   ALTIVEC_BUILTIN_VEC_VSRB,
2667   ALTIVEC_BUILTIN_VEC_VSRH,
2668   ALTIVEC_BUILTIN_VEC_VSRW,
2669   ALTIVEC_BUILTIN_VEC_VSUBFP,
2670   ALTIVEC_BUILTIN_VEC_VSUBSBS,
2671   ALTIVEC_BUILTIN_VEC_VSUBSHS,
2672   ALTIVEC_BUILTIN_VEC_VSUBSWS,
2673   ALTIVEC_BUILTIN_VEC_VSUBUBM,
2674   ALTIVEC_BUILTIN_VEC_VSUBUBS,
2675   ALTIVEC_BUILTIN_VEC_VSUBUHM,
2676   ALTIVEC_BUILTIN_VEC_VSUBUHS,
2677   ALTIVEC_BUILTIN_VEC_VSUBUWM,
2678   ALTIVEC_BUILTIN_VEC_VSUBUWS,
2679   ALTIVEC_BUILTIN_VEC_VSUM4SBS,
2680   ALTIVEC_BUILTIN_VEC_VSUM4SHS,
2681   ALTIVEC_BUILTIN_VEC_VSUM4UBS,
2682   ALTIVEC_BUILTIN_VEC_VUPKHPX,
2683   ALTIVEC_BUILTIN_VEC_VUPKHSB,
2684   ALTIVEC_BUILTIN_VEC_VUPKHSH,
2685   ALTIVEC_BUILTIN_VEC_VUPKLPX,
2686   ALTIVEC_BUILTIN_VEC_VUPKLSB,
2687   ALTIVEC_BUILTIN_VEC_VUPKLSH,
2688   ALTIVEC_BUILTIN_VEC_XOR,
2689   ALTIVEC_BUILTIN_VEC_STEP,
2690   ALTIVEC_BUILTIN_OVERLOADED_LAST = ALTIVEC_BUILTIN_VEC_STEP,
2691
2692   /* SPE builtins.  */
2693   SPE_BUILTIN_EVADDW,
2694   SPE_BUILTIN_EVAND,
2695   SPE_BUILTIN_EVANDC,
2696   SPE_BUILTIN_EVDIVWS,
2697   SPE_BUILTIN_EVDIVWU,
2698   SPE_BUILTIN_EVEQV,
2699   SPE_BUILTIN_EVFSADD,
2700   SPE_BUILTIN_EVFSDIV,
2701   SPE_BUILTIN_EVFSMUL,
2702   SPE_BUILTIN_EVFSSUB,
2703   SPE_BUILTIN_EVLDDX,
2704   SPE_BUILTIN_EVLDHX,
2705   SPE_BUILTIN_EVLDWX,
2706   SPE_BUILTIN_EVLHHESPLATX,
2707   SPE_BUILTIN_EVLHHOSSPLATX,
2708   SPE_BUILTIN_EVLHHOUSPLATX,
2709   SPE_BUILTIN_EVLWHEX,
2710   SPE_BUILTIN_EVLWHOSX,
2711   SPE_BUILTIN_EVLWHOUX,
2712   SPE_BUILTIN_EVLWHSPLATX,
2713   SPE_BUILTIN_EVLWWSPLATX,
2714   SPE_BUILTIN_EVMERGEHI,
2715   SPE_BUILTIN_EVMERGEHILO,
2716   SPE_BUILTIN_EVMERGELO,
2717   SPE_BUILTIN_EVMERGELOHI,
2718   SPE_BUILTIN_EVMHEGSMFAA,
2719   SPE_BUILTIN_EVMHEGSMFAN,
2720   SPE_BUILTIN_EVMHEGSMIAA,
2721   SPE_BUILTIN_EVMHEGSMIAN,
2722   SPE_BUILTIN_EVMHEGUMIAA,
2723   SPE_BUILTIN_EVMHEGUMIAN,
2724   SPE_BUILTIN_EVMHESMF,
2725   SPE_BUILTIN_EVMHESMFA,
2726   SPE_BUILTIN_EVMHESMFAAW,
2727   SPE_BUILTIN_EVMHESMFANW,
2728   SPE_BUILTIN_EVMHESMI,
2729   SPE_BUILTIN_EVMHESMIA,
2730   SPE_BUILTIN_EVMHESMIAAW,
2731   SPE_BUILTIN_EVMHESMIANW,
2732   SPE_BUILTIN_EVMHESSF,
2733   SPE_BUILTIN_EVMHESSFA,
2734   SPE_BUILTIN_EVMHESSFAAW,
2735   SPE_BUILTIN_EVMHESSFANW,
2736   SPE_BUILTIN_EVMHESSIAAW,
2737   SPE_BUILTIN_EVMHESSIANW,
2738   SPE_BUILTIN_EVMHEUMI,
2739   SPE_BUILTIN_EVMHEUMIA,
2740   SPE_BUILTIN_EVMHEUMIAAW,
2741   SPE_BUILTIN_EVMHEUMIANW,
2742   SPE_BUILTIN_EVMHEUSIAAW,
2743   SPE_BUILTIN_EVMHEUSIANW,
2744   SPE_BUILTIN_EVMHOGSMFAA,
2745   SPE_BUILTIN_EVMHOGSMFAN,
2746   SPE_BUILTIN_EVMHOGSMIAA,
2747   SPE_BUILTIN_EVMHOGSMIAN,
2748   SPE_BUILTIN_EVMHOGUMIAA,
2749   SPE_BUILTIN_EVMHOGUMIAN,
2750   SPE_BUILTIN_EVMHOSMF,
2751   SPE_BUILTIN_EVMHOSMFA,
2752   SPE_BUILTIN_EVMHOSMFAAW,
2753   SPE_BUILTIN_EVMHOSMFANW,
2754   SPE_BUILTIN_EVMHOSMI,
2755   SPE_BUILTIN_EVMHOSMIA,
2756   SPE_BUILTIN_EVMHOSMIAAW,
2757   SPE_BUILTIN_EVMHOSMIANW,
2758   SPE_BUILTIN_EVMHOSSF,
2759   SPE_BUILTIN_EVMHOSSFA,
2760   SPE_BUILTIN_EVMHOSSFAAW,
2761   SPE_BUILTIN_EVMHOSSFANW,
2762   SPE_BUILTIN_EVMHOSSIAAW,
2763   SPE_BUILTIN_EVMHOSSIANW,
2764   SPE_BUILTIN_EVMHOUMI,
2765   SPE_BUILTIN_EVMHOUMIA,
2766   SPE_BUILTIN_EVMHOUMIAAW,
2767   SPE_BUILTIN_EVMHOUMIANW,
2768   SPE_BUILTIN_EVMHOUSIAAW,
2769   SPE_BUILTIN_EVMHOUSIANW,
2770   SPE_BUILTIN_EVMWHSMF,
2771   SPE_BUILTIN_EVMWHSMFA,
2772   SPE_BUILTIN_EVMWHSMI,
2773   SPE_BUILTIN_EVMWHSMIA,
2774   SPE_BUILTIN_EVMWHSSF,
2775   SPE_BUILTIN_EVMWHSSFA,
2776   SPE_BUILTIN_EVMWHUMI,
2777   SPE_BUILTIN_EVMWHUMIA,
2778   SPE_BUILTIN_EVMWLSMIAAW,
2779   SPE_BUILTIN_EVMWLSMIANW,
2780   SPE_BUILTIN_EVMWLSSIAAW,
2781   SPE_BUILTIN_EVMWLSSIANW,
2782   SPE_BUILTIN_EVMWLUMI,
2783   SPE_BUILTIN_EVMWLUMIA,
2784   SPE_BUILTIN_EVMWLUMIAAW,
2785   SPE_BUILTIN_EVMWLUMIANW,
2786   SPE_BUILTIN_EVMWLUSIAAW,
2787   SPE_BUILTIN_EVMWLUSIANW,
2788   SPE_BUILTIN_EVMWSMF,
2789   SPE_BUILTIN_EVMWSMFA,
2790   SPE_BUILTIN_EVMWSMFAA,
2791   SPE_BUILTIN_EVMWSMFAN,
2792   SPE_BUILTIN_EVMWSMI,
2793   SPE_BUILTIN_EVMWSMIA,
2794   SPE_BUILTIN_EVMWSMIAA,
2795   SPE_BUILTIN_EVMWSMIAN,
2796   SPE_BUILTIN_EVMWHSSFAA,
2797   SPE_BUILTIN_EVMWSSF,
2798   SPE_BUILTIN_EVMWSSFA,
2799   SPE_BUILTIN_EVMWSSFAA,
2800   SPE_BUILTIN_EVMWSSFAN,
2801   SPE_BUILTIN_EVMWUMI,
2802   SPE_BUILTIN_EVMWUMIA,
2803   SPE_BUILTIN_EVMWUMIAA,
2804   SPE_BUILTIN_EVMWUMIAN,
2805   SPE_BUILTIN_EVNAND,
2806   SPE_BUILTIN_EVNOR,
2807   SPE_BUILTIN_EVOR,
2808   SPE_BUILTIN_EVORC,
2809   SPE_BUILTIN_EVRLW,
2810   SPE_BUILTIN_EVSLW,
2811   SPE_BUILTIN_EVSRWS,
2812   SPE_BUILTIN_EVSRWU,
2813   SPE_BUILTIN_EVSTDDX,
2814   SPE_BUILTIN_EVSTDHX,
2815   SPE_BUILTIN_EVSTDWX,
2816   SPE_BUILTIN_EVSTWHEX,
2817   SPE_BUILTIN_EVSTWHOX,
2818   SPE_BUILTIN_EVSTWWEX,
2819   SPE_BUILTIN_EVSTWWOX,
2820   SPE_BUILTIN_EVSUBFW,
2821   SPE_BUILTIN_EVXOR,
2822   SPE_BUILTIN_EVABS,
2823   SPE_BUILTIN_EVADDSMIAAW,
2824   SPE_BUILTIN_EVADDSSIAAW,
2825   SPE_BUILTIN_EVADDUMIAAW,
2826   SPE_BUILTIN_EVADDUSIAAW,
2827   SPE_BUILTIN_EVCNTLSW,
2828   SPE_BUILTIN_EVCNTLZW,
2829   SPE_BUILTIN_EVEXTSB,
2830   SPE_BUILTIN_EVEXTSH,
2831   SPE_BUILTIN_EVFSABS,
2832   SPE_BUILTIN_EVFSCFSF,
2833   SPE_BUILTIN_EVFSCFSI,
2834   SPE_BUILTIN_EVFSCFUF,
2835   SPE_BUILTIN_EVFSCFUI,
2836   SPE_BUILTIN_EVFSCTSF,
2837   SPE_BUILTIN_EVFSCTSI,
2838   SPE_BUILTIN_EVFSCTSIZ,
2839   SPE_BUILTIN_EVFSCTUF,
2840   SPE_BUILTIN_EVFSCTUI,
2841   SPE_BUILTIN_EVFSCTUIZ,
2842   SPE_BUILTIN_EVFSNABS,
2843   SPE_BUILTIN_EVFSNEG,
2844   SPE_BUILTIN_EVMRA,
2845   SPE_BUILTIN_EVNEG,
2846   SPE_BUILTIN_EVRNDW,
2847   SPE_BUILTIN_EVSUBFSMIAAW,
2848   SPE_BUILTIN_EVSUBFSSIAAW,
2849   SPE_BUILTIN_EVSUBFUMIAAW,
2850   SPE_BUILTIN_EVSUBFUSIAAW,
2851   SPE_BUILTIN_EVADDIW,
2852   SPE_BUILTIN_EVLDD,
2853   SPE_BUILTIN_EVLDH,
2854   SPE_BUILTIN_EVLDW,
2855   SPE_BUILTIN_EVLHHESPLAT,
2856   SPE_BUILTIN_EVLHHOSSPLAT,
2857   SPE_BUILTIN_EVLHHOUSPLAT,
2858   SPE_BUILTIN_EVLWHE,
2859   SPE_BUILTIN_EVLWHOS,
2860   SPE_BUILTIN_EVLWHOU,
2861   SPE_BUILTIN_EVLWHSPLAT,
2862   SPE_BUILTIN_EVLWWSPLAT,
2863   SPE_BUILTIN_EVRLWI,
2864   SPE_BUILTIN_EVSLWI,
2865   SPE_BUILTIN_EVSRWIS,
2866   SPE_BUILTIN_EVSRWIU,
2867   SPE_BUILTIN_EVSTDD,
2868   SPE_BUILTIN_EVSTDH,
2869   SPE_BUILTIN_EVSTDW,
2870   SPE_BUILTIN_EVSTWHE,
2871   SPE_BUILTIN_EVSTWHO,
2872   SPE_BUILTIN_EVSTWWE,
2873   SPE_BUILTIN_EVSTWWO,
2874   SPE_BUILTIN_EVSUBIFW,
2875
2876   /* Compares.  */
2877   SPE_BUILTIN_EVCMPEQ,
2878   SPE_BUILTIN_EVCMPGTS,
2879   SPE_BUILTIN_EVCMPGTU,
2880   SPE_BUILTIN_EVCMPLTS,
2881   SPE_BUILTIN_EVCMPLTU,
2882   SPE_BUILTIN_EVFSCMPEQ,
2883   SPE_BUILTIN_EVFSCMPGT,
2884   SPE_BUILTIN_EVFSCMPLT,
2885   SPE_BUILTIN_EVFSTSTEQ,
2886   SPE_BUILTIN_EVFSTSTGT,
2887   SPE_BUILTIN_EVFSTSTLT,
2888
2889   /* EVSEL compares.  */
2890   SPE_BUILTIN_EVSEL_CMPEQ,
2891   SPE_BUILTIN_EVSEL_CMPGTS,
2892   SPE_BUILTIN_EVSEL_CMPGTU,
2893   SPE_BUILTIN_EVSEL_CMPLTS,
2894   SPE_BUILTIN_EVSEL_CMPLTU,
2895   SPE_BUILTIN_EVSEL_FSCMPEQ,
2896   SPE_BUILTIN_EVSEL_FSCMPGT,
2897   SPE_BUILTIN_EVSEL_FSCMPLT,
2898   SPE_BUILTIN_EVSEL_FSTSTEQ,
2899   SPE_BUILTIN_EVSEL_FSTSTGT,
2900   SPE_BUILTIN_EVSEL_FSTSTLT,
2901
2902   SPE_BUILTIN_EVSPLATFI,
2903   SPE_BUILTIN_EVSPLATI,
2904   SPE_BUILTIN_EVMWHSSMAA,
2905   SPE_BUILTIN_EVMWHSMFAA,
2906   SPE_BUILTIN_EVMWHSMIAA,
2907   SPE_BUILTIN_EVMWHUSIAA,
2908   SPE_BUILTIN_EVMWHUMIAA,
2909   SPE_BUILTIN_EVMWHSSFAN,
2910   SPE_BUILTIN_EVMWHSSIAN,
2911   SPE_BUILTIN_EVMWHSMFAN,
2912   SPE_BUILTIN_EVMWHSMIAN,
2913   SPE_BUILTIN_EVMWHUSIAN,
2914   SPE_BUILTIN_EVMWHUMIAN,
2915   SPE_BUILTIN_EVMWHGSSFAA,
2916   SPE_BUILTIN_EVMWHGSMFAA,
2917   SPE_BUILTIN_EVMWHGSMIAA,
2918   SPE_BUILTIN_EVMWHGUMIAA,
2919   SPE_BUILTIN_EVMWHGSSFAN,
2920   SPE_BUILTIN_EVMWHGSMFAN,
2921   SPE_BUILTIN_EVMWHGSMIAN,
2922   SPE_BUILTIN_EVMWHGUMIAN,
2923   SPE_BUILTIN_MTSPEFSCR,
2924   SPE_BUILTIN_MFSPEFSCR,
2925   SPE_BUILTIN_BRINC,
2926
2927   RS6000_BUILTIN_COUNT
2928 };
2929
2930 enum rs6000_builtin_type_index
2931 {
2932   RS6000_BTI_NOT_OPAQUE,
2933   RS6000_BTI_opaque_V2SI,
2934   RS6000_BTI_opaque_V2SF,
2935   RS6000_BTI_opaque_p_V2SI,
2936   RS6000_BTI_opaque_V4SI,
2937   RS6000_BTI_V16QI,
2938   RS6000_BTI_V2SI,
2939   RS6000_BTI_V2SF,
2940   RS6000_BTI_V4HI,
2941   RS6000_BTI_V4SI,
2942   RS6000_BTI_V4SF,
2943   RS6000_BTI_V8HI,
2944   RS6000_BTI_unsigned_V16QI,
2945   RS6000_BTI_unsigned_V8HI,
2946   RS6000_BTI_unsigned_V4SI,
2947   RS6000_BTI_bool_char,          /* __bool char */
2948   RS6000_BTI_bool_short,         /* __bool short */
2949   RS6000_BTI_bool_int,           /* __bool int */
2950   RS6000_BTI_pixel,              /* __pixel */
2951   RS6000_BTI_bool_V16QI,         /* __vector __bool char */
2952   RS6000_BTI_bool_V8HI,          /* __vector __bool short */
2953   RS6000_BTI_bool_V4SI,          /* __vector __bool int */
2954   RS6000_BTI_pixel_V8HI,         /* __vector __pixel */
2955   RS6000_BTI_long,               /* long_integer_type_node */
2956   RS6000_BTI_unsigned_long,      /* long_unsigned_type_node */
2957   RS6000_BTI_INTQI,              /* intQI_type_node */
2958   RS6000_BTI_UINTQI,             /* unsigned_intQI_type_node */
2959   RS6000_BTI_INTHI,              /* intHI_type_node */
2960   RS6000_BTI_UINTHI,             /* unsigned_intHI_type_node */
2961   RS6000_BTI_INTSI,              /* intSI_type_node */
2962   RS6000_BTI_UINTSI,             /* unsigned_intSI_type_node */
2963   RS6000_BTI_float,              /* float_type_node */
2964   RS6000_BTI_void,               /* void_type_node */
2965   RS6000_BTI_MAX
2966 };
2967
2968
2969 #define opaque_V2SI_type_node         (rs6000_builtin_types[RS6000_BTI_opaque_V2SI])
2970 #define opaque_V2SF_type_node         (rs6000_builtin_types[RS6000_BTI_opaque_V2SF])
2971 #define opaque_p_V2SI_type_node       (rs6000_builtin_types[RS6000_BTI_opaque_p_V2SI])
2972 #define opaque_V4SI_type_node         (rs6000_builtin_types[RS6000_BTI_opaque_V4SI])
2973 #define V16QI_type_node               (rs6000_builtin_types[RS6000_BTI_V16QI])
2974 #define V2SI_type_node                (rs6000_builtin_types[RS6000_BTI_V2SI])
2975 #define V2SF_type_node                (rs6000_builtin_types[RS6000_BTI_V2SF])
2976 #define V4HI_type_node                (rs6000_builtin_types[RS6000_BTI_V4HI])
2977 #define V4SI_type_node                (rs6000_builtin_types[RS6000_BTI_V4SI])
2978 #define V4SF_type_node                (rs6000_builtin_types[RS6000_BTI_V4SF])
2979 #define V8HI_type_node                (rs6000_builtin_types[RS6000_BTI_V8HI])
2980 #define unsigned_V16QI_type_node      (rs6000_builtin_types[RS6000_BTI_unsigned_V16QI])
2981 #define unsigned_V8HI_type_node       (rs6000_builtin_types[RS6000_BTI_unsigned_V8HI])
2982 #define unsigned_V4SI_type_node       (rs6000_builtin_types[RS6000_BTI_unsigned_V4SI])
2983 #define bool_char_type_node           (rs6000_builtin_types[RS6000_BTI_bool_char])
2984 #define bool_short_type_node          (rs6000_builtin_types[RS6000_BTI_bool_short])
2985 #define bool_int_type_node            (rs6000_builtin_types[RS6000_BTI_bool_int])
2986 #define pixel_type_node               (rs6000_builtin_types[RS6000_BTI_pixel])
2987 #define bool_V16QI_type_node          (rs6000_builtin_types[RS6000_BTI_bool_V16QI])
2988 #define bool_V8HI_type_node           (rs6000_builtin_types[RS6000_BTI_bool_V8HI])
2989 #define bool_V4SI_type_node           (rs6000_builtin_types[RS6000_BTI_bool_V4SI])
2990 #define pixel_V8HI_type_node          (rs6000_builtin_types[RS6000_BTI_pixel_V8HI])
2991
2992 #define long_integer_type_internal_node  (rs6000_builtin_types[RS6000_BTI_long])
2993 #define long_unsigned_type_internal_node (rs6000_builtin_types[RS6000_BTI_unsigned_long])
2994 #define intQI_type_internal_node         (rs6000_builtin_types[RS6000_BTI_INTQI])
2995 #define uintQI_type_internal_node        (rs6000_builtin_types[RS6000_BTI_UINTQI])
2996 #define intHI_type_internal_node         (rs6000_builtin_types[RS6000_BTI_INTHI])
2997 #define uintHI_type_internal_node        (rs6000_builtin_types[RS6000_BTI_UINTHI])
2998 #define intSI_type_internal_node         (rs6000_builtin_types[RS6000_BTI_INTSI])
2999 #define uintSI_type_internal_node        (rs6000_builtin_types[RS6000_BTI_UINTSI])
3000 #define float_type_internal_node         (rs6000_builtin_types[RS6000_BTI_float])
3001 #define void_type_internal_node          (rs6000_builtin_types[RS6000_BTI_void])
3002
3003 extern GTY(()) tree rs6000_builtin_types[RS6000_BTI_MAX];
3004 extern GTY(()) tree rs6000_builtin_decls[RS6000_BUILTIN_COUNT];
3005