OSDN Git Service

f265dce42fe1045bbc47170ac9836c0587f04c81
[pf3gnuchains/gcc-fork.git] / gcc / config / rs6000 / rs6000.c
1 /* Subroutines used for code generation on IBM RS/6000.
2    Copyright (C) 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
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 3, 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 COPYING3.  If not see
21    <http://www.gnu.org/licenses/>.  */
22
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
27 #include "rtl.h"
28 #include "regs.h"
29 #include "hard-reg-set.h"
30 #include "insn-config.h"
31 #include "conditions.h"
32 #include "insn-attr.h"
33 #include "flags.h"
34 #include "recog.h"
35 #include "obstack.h"
36 #include "tree.h"
37 #include "expr.h"
38 #include "optabs.h"
39 #include "except.h"
40 #include "function.h"
41 #include "output.h"
42 #include "basic-block.h"
43 #include "integrate.h"
44 #include "diagnostic-core.h"
45 #include "toplev.h"
46 #include "ggc.h"
47 #include "hashtab.h"
48 #include "tm_p.h"
49 #include "target.h"
50 #include "target-def.h"
51 #include "langhooks.h"
52 #include "reload.h"
53 #include "cfglayout.h"
54 #include "sched-int.h"
55 #include "gimple.h"
56 #include "tree-flow.h"
57 #include "intl.h"
58 #include "params.h"
59 #include "tm-constrs.h"
60 #if TARGET_XCOFF
61 #include "xcoffout.h"  /* get declarations of xcoff_*_section_name */
62 #endif
63 #if TARGET_MACHO
64 #include "gstab.h"  /* for N_SLINE */
65 #endif
66
67 #ifndef TARGET_NO_PROTOTYPE
68 #define TARGET_NO_PROTOTYPE 0
69 #endif
70
71 #define min(A,B)        ((A) < (B) ? (A) : (B))
72 #define max(A,B)        ((A) > (B) ? (A) : (B))
73
74 /* Structure used to define the rs6000 stack */
75 typedef struct rs6000_stack {
76   int first_gp_reg_save;        /* first callee saved GP register used */
77   int first_fp_reg_save;        /* first callee saved FP register used */
78   int first_altivec_reg_save;   /* first callee saved AltiVec register used */
79   int lr_save_p;                /* true if the link reg needs to be saved */
80   int cr_save_p;                /* true if the CR reg needs to be saved */
81   unsigned int vrsave_mask;     /* mask of vec registers to save */
82   int push_p;                   /* true if we need to allocate stack space */
83   int calls_p;                  /* true if the function makes any calls */
84   int world_save_p;             /* true if we're saving *everything*:
85                                    r13-r31, cr, f14-f31, vrsave, v20-v31  */
86   enum rs6000_abi abi;          /* which ABI to use */
87   int gp_save_offset;           /* offset to save GP regs from initial SP */
88   int fp_save_offset;           /* offset to save FP regs from initial SP */
89   int altivec_save_offset;      /* offset to save AltiVec regs from initial SP */
90   int lr_save_offset;           /* offset to save LR from initial SP */
91   int cr_save_offset;           /* offset to save CR from initial SP */
92   int vrsave_save_offset;       /* offset to save VRSAVE from initial SP */
93   int spe_gp_save_offset;       /* offset to save spe 64-bit gprs  */
94   int varargs_save_offset;      /* offset to save the varargs registers */
95   int ehrd_offset;              /* offset to EH return data */
96   int reg_size;                 /* register size (4 or 8) */
97   HOST_WIDE_INT vars_size;      /* variable save area size */
98   int parm_size;                /* outgoing parameter size */
99   int save_size;                /* save area size */
100   int fixed_size;               /* fixed size of stack frame */
101   int gp_size;                  /* size of saved GP registers */
102   int fp_size;                  /* size of saved FP registers */
103   int altivec_size;             /* size of saved AltiVec registers */
104   int cr_size;                  /* size to hold CR if not in save_size */
105   int vrsave_size;              /* size to hold VRSAVE if not in save_size */
106   int altivec_padding_size;     /* size of altivec alignment padding if
107                                    not in save_size */
108   int spe_gp_size;              /* size of 64-bit GPR save size for SPE */
109   int spe_padding_size;
110   HOST_WIDE_INT total_size;     /* total bytes allocated for stack */
111   int spe_64bit_regs_used;
112 } rs6000_stack_t;
113
114 /* A C structure for machine-specific, per-function data.
115    This is added to the cfun structure.  */
116 typedef struct GTY(()) machine_function
117 {
118   /* Some local-dynamic symbol.  */
119   const char *some_ld_name;
120   /* Whether the instruction chain has been scanned already.  */
121   int insn_chain_scanned_p;
122   /* Flags if __builtin_return_address (n) with n >= 1 was used.  */
123   int ra_needs_full_frame;
124   /* Flags if __builtin_return_address (0) was used.  */
125   int ra_need_lr;
126   /* Cache lr_save_p after expansion of builtin_eh_return.  */
127   int lr_save_state;
128   /* Offset from virtual_stack_vars_rtx to the start of the ABI_V4
129      varargs save area.  */
130   HOST_WIDE_INT varargs_save_offset;
131   /* Temporary stack slot to use for SDmode copies.  This slot is
132      64-bits wide and is allocated early enough so that the offset
133      does not overflow the 16-bit load/store offset field.  */
134   rtx sdmode_stack_slot;
135 } machine_function;
136
137 /* Target cpu type */
138
139 enum processor_type rs6000_cpu;
140 struct rs6000_cpu_select rs6000_select[3] =
141 {
142   /* switch             name,                   tune    arch */
143   { (const char *)0,    "--with-cpu=",          1,      1 },
144   { (const char *)0,    "-mcpu=",               1,      1 },
145   { (const char *)0,    "-mtune=",              1,      0 },
146 };
147
148 /* Always emit branch hint bits.  */
149 static GTY(()) bool rs6000_always_hint;
150
151 /* Schedule instructions for group formation.  */
152 static GTY(()) bool rs6000_sched_groups;
153
154 /* Align branch targets.  */
155 static GTY(()) bool rs6000_align_branch_targets;
156
157 /* Support for -msched-costly-dep option.  */
158 const char *rs6000_sched_costly_dep_str;
159 enum rs6000_dependence_cost rs6000_sched_costly_dep;
160
161 /* Support for -minsert-sched-nops option.  */
162 const char *rs6000_sched_insert_nops_str;
163 enum rs6000_nop_insertion rs6000_sched_insert_nops;
164
165 /* Support targetm.vectorize.builtin_mask_for_load.  */
166 static GTY(()) tree altivec_builtin_mask_for_load;
167
168 /* Size of long double.  */
169 int rs6000_long_double_type_size;
170
171 /* IEEE quad extended precision long double. */
172 int rs6000_ieeequad;
173
174 /* Nonzero to use AltiVec ABI.  */
175 int rs6000_altivec_abi;
176
177 /* Nonzero if we want SPE SIMD instructions.  */
178 int rs6000_spe;
179
180 /* Nonzero if we want SPE ABI extensions.  */
181 int rs6000_spe_abi;
182
183 /* Nonzero if floating point operations are done in the GPRs.  */
184 int rs6000_float_gprs = 0;
185
186 /* Nonzero if we want Darwin's struct-by-value-in-regs ABI.  */
187 int rs6000_darwin64_abi;
188
189 /* Set to nonzero once AIX common-mode calls have been defined.  */
190 static GTY(()) int common_mode_defined;
191
192 /* Label number of label created for -mrelocatable, to call to so we can
193    get the address of the GOT section */
194 int rs6000_pic_labelno;
195
196 #ifdef USING_ELFOS_H
197 /* Which abi to adhere to */
198 const char *rs6000_abi_name;
199
200 /* Semantics of the small data area */
201 enum rs6000_sdata_type rs6000_sdata = SDATA_DATA;
202
203 /* Which small data model to use */
204 const char *rs6000_sdata_name = (char *)0;
205
206 /* Counter for labels which are to be placed in .fixup.  */
207 int fixuplabelno = 0;
208 #endif
209
210 /* Bit size of immediate TLS offsets and string from which it is decoded.  */
211 int rs6000_tls_size = 32;
212 const char *rs6000_tls_size_string;
213
214 /* ABI enumeration available for subtarget to use.  */
215 enum rs6000_abi rs6000_current_abi;
216
217 /* Whether to use variant of AIX ABI for PowerPC64 Linux.  */
218 int dot_symbols;
219
220 /* Debug flags */
221 const char *rs6000_debug_name;
222 int rs6000_debug_stack;         /* debug stack applications */
223 int rs6000_debug_arg;           /* debug argument handling */
224 int rs6000_debug_reg;           /* debug register classes */
225 int rs6000_debug_addr;          /* debug memory addressing */
226 int rs6000_debug_cost;          /* debug rtx_costs */
227
228 /* Specify the machine mode that pointers have.  After generation of rtl, the
229    compiler makes no further distinction between pointers and any other objects
230    of this machine mode.  The type is unsigned since not all things that
231    include rs6000.h also include machmode.h.  */
232 unsigned rs6000_pmode;
233
234 /* Width in bits of a pointer.  */
235 unsigned rs6000_pointer_size;
236
237
238 /* Value is TRUE if register/mode pair is acceptable.  */
239 bool rs6000_hard_regno_mode_ok_p[NUM_MACHINE_MODES][FIRST_PSEUDO_REGISTER];
240
241 /* Maximum number of registers needed for a given register class and mode.  */
242 unsigned char rs6000_class_max_nregs[NUM_MACHINE_MODES][LIM_REG_CLASSES];
243
244 /* How many registers are needed for a given register and mode.  */
245 unsigned char rs6000_hard_regno_nregs[NUM_MACHINE_MODES][FIRST_PSEUDO_REGISTER];
246
247 /* Map register number to register class.  */
248 enum reg_class rs6000_regno_regclass[FIRST_PSEUDO_REGISTER];
249
250 /* Reload functions based on the type and the vector unit.  */
251 static enum insn_code rs6000_vector_reload[NUM_MACHINE_MODES][2];
252
253 /* Built in types.  */
254 tree rs6000_builtin_types[RS6000_BTI_MAX];
255 tree rs6000_builtin_decls[RS6000_BUILTIN_COUNT];
256
257 const char *rs6000_traceback_name;
258 static enum {
259   traceback_default = 0,
260   traceback_none,
261   traceback_part,
262   traceback_full
263 } rs6000_traceback;
264
265 /* Flag to say the TOC is initialized */
266 int toc_initialized;
267 char toc_label_name[10];
268
269 /* Cached value of rs6000_variable_issue. This is cached in
270    rs6000_variable_issue hook and returned from rs6000_sched_reorder2.  */
271 static short cached_can_issue_more;
272
273 static GTY(()) section *read_only_data_section;
274 static GTY(()) section *private_data_section;
275 static GTY(()) section *read_only_private_data_section;
276 static GTY(()) section *sdata2_section;
277 static GTY(()) section *toc_section;
278
279 /* Control alignment for fields within structures.  */
280 /* String from -malign-XXXXX.  */
281 int rs6000_alignment_flags;
282
283 /* Code model for 64-bit linux.  */
284 enum rs6000_cmodel cmodel;
285
286 /* True for any options that were explicitly set.  */
287 static struct {
288   bool aix_struct_ret;          /* True if -maix-struct-ret was used.  */
289   bool alignment;               /* True if -malign- was used.  */
290   bool spe_abi;                 /* True if -mabi=spe/no-spe was used.  */
291   bool altivec_abi;             /* True if -mabi=altivec/no-altivec used.  */
292   bool spe;                     /* True if -mspe= was used.  */
293   bool float_gprs;              /* True if -mfloat-gprs= was used.  */
294   bool long_double;             /* True if -mlong-double- was used.  */
295   bool ieee;                    /* True if -mabi=ieee/ibmlongdouble used.  */
296   bool vrsave;                  /* True if -mvrsave was used.  */
297   bool cmodel;                  /* True if -mcmodel was used.  */
298 } rs6000_explicit_options;
299
300 struct builtin_description
301 {
302   /* mask is not const because we're going to alter it below.  This
303      nonsense will go away when we rewrite the -march infrastructure
304      to give us more target flag bits.  */
305   unsigned int mask;
306   const enum insn_code icode;
307   const char *const name;
308   const enum rs6000_builtins code;
309 };
310
311 /* Describe the vector unit used for modes.  */
312 enum rs6000_vector rs6000_vector_unit[NUM_MACHINE_MODES];
313 enum rs6000_vector rs6000_vector_mem[NUM_MACHINE_MODES];
314
315 /* Register classes for various constraints that are based on the target
316    switches.  */
317 enum reg_class rs6000_constraints[RS6000_CONSTRAINT_MAX];
318
319 /* Describe the alignment of a vector.  */
320 int rs6000_vector_align[NUM_MACHINE_MODES];
321
322 /* Map selected modes to types for builtins.  */
323 static GTY(()) tree builtin_mode_to_type[MAX_MACHINE_MODE][2];
324
325 /* What modes to automatically generate reciprocal divide estimate (fre) and
326    reciprocal sqrt (frsqrte) for.  */
327 unsigned char rs6000_recip_bits[MAX_MACHINE_MODE];
328
329 /* Masks to determine which reciprocal esitmate instructions to generate
330    automatically.  */
331 enum rs6000_recip_mask {
332   RECIP_SF_DIV          = 0x001,        /* Use divide estimate */
333   RECIP_DF_DIV          = 0x002,
334   RECIP_V4SF_DIV        = 0x004,
335   RECIP_V2DF_DIV        = 0x008,
336
337   RECIP_SF_RSQRT        = 0x010,        /* Use reciprocal sqrt estimate.  */
338   RECIP_DF_RSQRT        = 0x020,
339   RECIP_V4SF_RSQRT      = 0x040,
340   RECIP_V2DF_RSQRT      = 0x080,
341
342   /* Various combination of flags for -mrecip=xxx.  */
343   RECIP_NONE            = 0,
344   RECIP_ALL             = (RECIP_SF_DIV | RECIP_DF_DIV | RECIP_V4SF_DIV
345                            | RECIP_V2DF_DIV | RECIP_SF_RSQRT | RECIP_DF_RSQRT
346                            | RECIP_V4SF_RSQRT | RECIP_V2DF_RSQRT),
347
348   RECIP_HIGH_PRECISION  = RECIP_ALL,
349
350   /* On low precision machines like the power5, don't enable double precision
351      reciprocal square root estimate, since it isn't accurate enough.  */
352   RECIP_LOW_PRECISION   = (RECIP_ALL & ~(RECIP_DF_RSQRT | RECIP_V2DF_RSQRT))
353 };
354
355 static unsigned int rs6000_recip_control;
356 static const char *rs6000_recip_name;
357
358 /* -mrecip options.  */
359 static struct
360 {
361   const char *string;           /* option name */
362   unsigned int mask;            /* mask bits to set */
363 } recip_options[] = {
364   { "all",       RECIP_ALL },
365   { "none",      RECIP_NONE },
366   { "div",       (RECIP_SF_DIV | RECIP_DF_DIV | RECIP_V4SF_DIV
367                   | RECIP_V2DF_DIV) },
368   { "divf",      (RECIP_SF_DIV | RECIP_V4SF_DIV) },
369   { "divd",      (RECIP_DF_DIV | RECIP_V2DF_DIV) },
370   { "rsqrt",     (RECIP_SF_RSQRT | RECIP_DF_RSQRT | RECIP_V4SF_RSQRT
371                   | RECIP_V2DF_RSQRT) },
372   { "rsqrtf",    (RECIP_SF_RSQRT | RECIP_V4SF_RSQRT) },
373   { "rsqrtd",    (RECIP_DF_RSQRT | RECIP_V2DF_RSQRT) },
374 };
375
376 /* 2 argument gen function typedef.  */
377 typedef rtx (*gen_2arg_fn_t) (rtx, rtx, rtx);
378
379 \f
380 /* Target cpu costs.  */
381
382 struct processor_costs {
383   const int mulsi;        /* cost of SImode multiplication.  */
384   const int mulsi_const;  /* cost of SImode multiplication by constant.  */
385   const int mulsi_const9; /* cost of SImode mult by short constant.  */
386   const int muldi;        /* cost of DImode multiplication.  */
387   const int divsi;        /* cost of SImode division.  */
388   const int divdi;        /* cost of DImode division.  */
389   const int fp;           /* cost of simple SFmode and DFmode insns.  */
390   const int dmul;         /* cost of DFmode multiplication (and fmadd).  */
391   const int sdiv;         /* cost of SFmode division (fdivs).  */
392   const int ddiv;         /* cost of DFmode division (fdiv).  */
393   const int cache_line_size;    /* cache line size in bytes. */
394   const int l1_cache_size;      /* size of l1 cache, in kilobytes.  */
395   const int l2_cache_size;      /* size of l2 cache, in kilobytes.  */
396   const int simultaneous_prefetches; /* number of parallel prefetch
397                                         operations.  */
398 };
399
400 const struct processor_costs *rs6000_cost;
401
402 /* Processor costs (relative to an add) */
403
404 /* Instruction size costs on 32bit processors.  */
405 static const
406 struct processor_costs size32_cost = {
407   COSTS_N_INSNS (1),    /* mulsi */
408   COSTS_N_INSNS (1),    /* mulsi_const */
409   COSTS_N_INSNS (1),    /* mulsi_const9 */
410   COSTS_N_INSNS (1),    /* muldi */
411   COSTS_N_INSNS (1),    /* divsi */
412   COSTS_N_INSNS (1),    /* divdi */
413   COSTS_N_INSNS (1),    /* fp */
414   COSTS_N_INSNS (1),    /* dmul */
415   COSTS_N_INSNS (1),    /* sdiv */
416   COSTS_N_INSNS (1),    /* ddiv */
417   32,
418   0,
419   0,
420   0,
421 };
422
423 /* Instruction size costs on 64bit processors.  */
424 static const
425 struct processor_costs size64_cost = {
426   COSTS_N_INSNS (1),    /* mulsi */
427   COSTS_N_INSNS (1),    /* mulsi_const */
428   COSTS_N_INSNS (1),    /* mulsi_const9 */
429   COSTS_N_INSNS (1),    /* muldi */
430   COSTS_N_INSNS (1),    /* divsi */
431   COSTS_N_INSNS (1),    /* divdi */
432   COSTS_N_INSNS (1),    /* fp */
433   COSTS_N_INSNS (1),    /* dmul */
434   COSTS_N_INSNS (1),    /* sdiv */
435   COSTS_N_INSNS (1),    /* ddiv */
436   128,
437   0,
438   0,
439   0,
440 };
441
442 /* Instruction costs on RIOS1 processors.  */
443 static const
444 struct processor_costs rios1_cost = {
445   COSTS_N_INSNS (5),    /* mulsi */
446   COSTS_N_INSNS (4),    /* mulsi_const */
447   COSTS_N_INSNS (3),    /* mulsi_const9 */
448   COSTS_N_INSNS (5),    /* muldi */
449   COSTS_N_INSNS (19),   /* divsi */
450   COSTS_N_INSNS (19),   /* divdi */
451   COSTS_N_INSNS (2),    /* fp */
452   COSTS_N_INSNS (2),    /* dmul */
453   COSTS_N_INSNS (19),   /* sdiv */
454   COSTS_N_INSNS (19),   /* ddiv */
455   128,                  /* cache line size */
456   64,                   /* l1 cache */
457   512,                  /* l2 cache */
458   0,                    /* streams */
459 };
460
461 /* Instruction costs on RIOS2 processors.  */
462 static const
463 struct processor_costs rios2_cost = {
464   COSTS_N_INSNS (2),    /* mulsi */
465   COSTS_N_INSNS (2),    /* mulsi_const */
466   COSTS_N_INSNS (2),    /* mulsi_const9 */
467   COSTS_N_INSNS (2),    /* muldi */
468   COSTS_N_INSNS (13),   /* divsi */
469   COSTS_N_INSNS (13),   /* divdi */
470   COSTS_N_INSNS (2),    /* fp */
471   COSTS_N_INSNS (2),    /* dmul */
472   COSTS_N_INSNS (17),   /* sdiv */
473   COSTS_N_INSNS (17),   /* ddiv */
474   256,                  /* cache line size */
475   256,                  /* l1 cache */
476   1024,                 /* l2 cache */
477   0,                    /* streams */
478 };
479
480 /* Instruction costs on RS64A processors.  */
481 static const
482 struct processor_costs rs64a_cost = {
483   COSTS_N_INSNS (20),   /* mulsi */
484   COSTS_N_INSNS (12),   /* mulsi_const */
485   COSTS_N_INSNS (8),    /* mulsi_const9 */
486   COSTS_N_INSNS (34),   /* muldi */
487   COSTS_N_INSNS (65),   /* divsi */
488   COSTS_N_INSNS (67),   /* divdi */
489   COSTS_N_INSNS (4),    /* fp */
490   COSTS_N_INSNS (4),    /* dmul */
491   COSTS_N_INSNS (31),   /* sdiv */
492   COSTS_N_INSNS (31),   /* ddiv */
493   128,                  /* cache line size */
494   128,                  /* l1 cache */
495   2048,                 /* l2 cache */
496   1,                    /* streams */
497 };
498
499 /* Instruction costs on MPCCORE processors.  */
500 static const
501 struct processor_costs mpccore_cost = {
502   COSTS_N_INSNS (2),    /* mulsi */
503   COSTS_N_INSNS (2),    /* mulsi_const */
504   COSTS_N_INSNS (2),    /* mulsi_const9 */
505   COSTS_N_INSNS (2),    /* muldi */
506   COSTS_N_INSNS (6),    /* divsi */
507   COSTS_N_INSNS (6),    /* divdi */
508   COSTS_N_INSNS (4),    /* fp */
509   COSTS_N_INSNS (5),    /* dmul */
510   COSTS_N_INSNS (10),   /* sdiv */
511   COSTS_N_INSNS (17),   /* ddiv */
512   32,                   /* cache line size */
513   4,                    /* l1 cache */
514   16,                   /* l2 cache */
515   1,                    /* streams */
516 };
517
518 /* Instruction costs on PPC403 processors.  */
519 static const
520 struct processor_costs ppc403_cost = {
521   COSTS_N_INSNS (4),    /* mulsi */
522   COSTS_N_INSNS (4),    /* mulsi_const */
523   COSTS_N_INSNS (4),    /* mulsi_const9 */
524   COSTS_N_INSNS (4),    /* muldi */
525   COSTS_N_INSNS (33),   /* divsi */
526   COSTS_N_INSNS (33),   /* divdi */
527   COSTS_N_INSNS (11),   /* fp */
528   COSTS_N_INSNS (11),   /* dmul */
529   COSTS_N_INSNS (11),   /* sdiv */
530   COSTS_N_INSNS (11),   /* ddiv */
531   32,                   /* cache line size */
532   4,                    /* l1 cache */
533   16,                   /* l2 cache */
534   1,                    /* streams */
535 };
536
537 /* Instruction costs on PPC405 processors.  */
538 static const
539 struct processor_costs ppc405_cost = {
540   COSTS_N_INSNS (5),    /* mulsi */
541   COSTS_N_INSNS (4),    /* mulsi_const */
542   COSTS_N_INSNS (3),    /* mulsi_const9 */
543   COSTS_N_INSNS (5),    /* muldi */
544   COSTS_N_INSNS (35),   /* divsi */
545   COSTS_N_INSNS (35),   /* divdi */
546   COSTS_N_INSNS (11),   /* fp */
547   COSTS_N_INSNS (11),   /* dmul */
548   COSTS_N_INSNS (11),   /* sdiv */
549   COSTS_N_INSNS (11),   /* ddiv */
550   32,                   /* cache line size */
551   16,                   /* l1 cache */
552   128,                  /* l2 cache */
553   1,                    /* streams */
554 };
555
556 /* Instruction costs on PPC440 processors.  */
557 static const
558 struct processor_costs ppc440_cost = {
559   COSTS_N_INSNS (3),    /* mulsi */
560   COSTS_N_INSNS (2),    /* mulsi_const */
561   COSTS_N_INSNS (2),    /* mulsi_const9 */
562   COSTS_N_INSNS (3),    /* muldi */
563   COSTS_N_INSNS (34),   /* divsi */
564   COSTS_N_INSNS (34),   /* divdi */
565   COSTS_N_INSNS (5),    /* fp */
566   COSTS_N_INSNS (5),    /* dmul */
567   COSTS_N_INSNS (19),   /* sdiv */
568   COSTS_N_INSNS (33),   /* ddiv */
569   32,                   /* cache line size */
570   32,                   /* l1 cache */
571   256,                  /* l2 cache */
572   1,                    /* streams */
573 };
574
575 /* Instruction costs on PPC476 processors.  */
576 static const
577 struct processor_costs ppc476_cost = {
578   COSTS_N_INSNS (4),    /* mulsi */
579   COSTS_N_INSNS (4),    /* mulsi_const */
580   COSTS_N_INSNS (4),    /* mulsi_const9 */
581   COSTS_N_INSNS (4),    /* muldi */
582   COSTS_N_INSNS (11),   /* divsi */
583   COSTS_N_INSNS (11),   /* divdi */
584   COSTS_N_INSNS (6),    /* fp */
585   COSTS_N_INSNS (6),    /* dmul */
586   COSTS_N_INSNS (19),   /* sdiv */
587   COSTS_N_INSNS (33),   /* ddiv */
588   32,                   /* l1 cache line size */
589   32,                   /* l1 cache */
590   512,                  /* l2 cache */
591   1,                    /* streams */
592 };
593
594 /* Instruction costs on PPC601 processors.  */
595 static const
596 struct processor_costs ppc601_cost = {
597   COSTS_N_INSNS (5),    /* mulsi */
598   COSTS_N_INSNS (5),    /* mulsi_const */
599   COSTS_N_INSNS (5),    /* mulsi_const9 */
600   COSTS_N_INSNS (5),    /* muldi */
601   COSTS_N_INSNS (36),   /* divsi */
602   COSTS_N_INSNS (36),   /* divdi */
603   COSTS_N_INSNS (4),    /* fp */
604   COSTS_N_INSNS (5),    /* dmul */
605   COSTS_N_INSNS (17),   /* sdiv */
606   COSTS_N_INSNS (31),   /* ddiv */
607   32,                   /* cache line size */
608   32,                   /* l1 cache */
609   256,                  /* l2 cache */
610   1,                    /* streams */
611 };
612
613 /* Instruction costs on PPC603 processors.  */
614 static const
615 struct processor_costs ppc603_cost = {
616   COSTS_N_INSNS (5),    /* mulsi */
617   COSTS_N_INSNS (3),    /* mulsi_const */
618   COSTS_N_INSNS (2),    /* mulsi_const9 */
619   COSTS_N_INSNS (5),    /* muldi */
620   COSTS_N_INSNS (37),   /* divsi */
621   COSTS_N_INSNS (37),   /* divdi */
622   COSTS_N_INSNS (3),    /* fp */
623   COSTS_N_INSNS (4),    /* dmul */
624   COSTS_N_INSNS (18),   /* sdiv */
625   COSTS_N_INSNS (33),   /* ddiv */
626   32,                   /* cache line size */
627   8,                    /* l1 cache */
628   64,                   /* l2 cache */
629   1,                    /* streams */
630 };
631
632 /* Instruction costs on PPC604 processors.  */
633 static const
634 struct processor_costs ppc604_cost = {
635   COSTS_N_INSNS (4),    /* mulsi */
636   COSTS_N_INSNS (4),    /* mulsi_const */
637   COSTS_N_INSNS (4),    /* mulsi_const9 */
638   COSTS_N_INSNS (4),    /* muldi */
639   COSTS_N_INSNS (20),   /* divsi */
640   COSTS_N_INSNS (20),   /* divdi */
641   COSTS_N_INSNS (3),    /* fp */
642   COSTS_N_INSNS (3),    /* dmul */
643   COSTS_N_INSNS (18),   /* sdiv */
644   COSTS_N_INSNS (32),   /* ddiv */
645   32,                   /* cache line size */
646   16,                   /* l1 cache */
647   512,                  /* l2 cache */
648   1,                    /* streams */
649 };
650
651 /* Instruction costs on PPC604e processors.  */
652 static const
653 struct processor_costs ppc604e_cost = {
654   COSTS_N_INSNS (2),    /* mulsi */
655   COSTS_N_INSNS (2),    /* mulsi_const */
656   COSTS_N_INSNS (2),    /* mulsi_const9 */
657   COSTS_N_INSNS (2),    /* muldi */
658   COSTS_N_INSNS (20),   /* divsi */
659   COSTS_N_INSNS (20),   /* divdi */
660   COSTS_N_INSNS (3),    /* fp */
661   COSTS_N_INSNS (3),    /* dmul */
662   COSTS_N_INSNS (18),   /* sdiv */
663   COSTS_N_INSNS (32),   /* ddiv */
664   32,                   /* cache line size */
665   32,                   /* l1 cache */
666   1024,                 /* l2 cache */
667   1,                    /* streams */
668 };
669
670 /* Instruction costs on PPC620 processors.  */
671 static const
672 struct processor_costs ppc620_cost = {
673   COSTS_N_INSNS (5),    /* mulsi */
674   COSTS_N_INSNS (4),    /* mulsi_const */
675   COSTS_N_INSNS (3),    /* mulsi_const9 */
676   COSTS_N_INSNS (7),    /* muldi */
677   COSTS_N_INSNS (21),   /* divsi */
678   COSTS_N_INSNS (37),   /* divdi */
679   COSTS_N_INSNS (3),    /* fp */
680   COSTS_N_INSNS (3),    /* dmul */
681   COSTS_N_INSNS (18),   /* sdiv */
682   COSTS_N_INSNS (32),   /* ddiv */
683   128,                  /* cache line size */
684   32,                   /* l1 cache */
685   1024,                 /* l2 cache */
686   1,                    /* streams */
687 };
688
689 /* Instruction costs on PPC630 processors.  */
690 static const
691 struct processor_costs ppc630_cost = {
692   COSTS_N_INSNS (5),    /* mulsi */
693   COSTS_N_INSNS (4),    /* mulsi_const */
694   COSTS_N_INSNS (3),    /* mulsi_const9 */
695   COSTS_N_INSNS (7),    /* muldi */
696   COSTS_N_INSNS (21),   /* divsi */
697   COSTS_N_INSNS (37),   /* divdi */
698   COSTS_N_INSNS (3),    /* fp */
699   COSTS_N_INSNS (3),    /* dmul */
700   COSTS_N_INSNS (17),   /* sdiv */
701   COSTS_N_INSNS (21),   /* ddiv */
702   128,                  /* cache line size */
703   64,                   /* l1 cache */
704   1024,                 /* l2 cache */
705   1,                    /* streams */
706 };
707
708 /* Instruction costs on Cell processor.  */
709 /* COSTS_N_INSNS (1) ~ one add.  */
710 static const
711 struct processor_costs ppccell_cost = {
712   COSTS_N_INSNS (9/2)+2,    /* mulsi */
713   COSTS_N_INSNS (6/2),    /* mulsi_const */
714   COSTS_N_INSNS (6/2),    /* mulsi_const9 */
715   COSTS_N_INSNS (15/2)+2,   /* muldi */
716   COSTS_N_INSNS (38/2),   /* divsi */
717   COSTS_N_INSNS (70/2),   /* divdi */
718   COSTS_N_INSNS (10/2),   /* fp */
719   COSTS_N_INSNS (10/2),   /* dmul */
720   COSTS_N_INSNS (74/2),   /* sdiv */
721   COSTS_N_INSNS (74/2),   /* ddiv */
722   128,                  /* cache line size */
723   32,                   /* l1 cache */
724   512,                  /* l2 cache */
725   6,                    /* streams */
726 };
727
728 /* Instruction costs on PPC750 and PPC7400 processors.  */
729 static const
730 struct processor_costs ppc750_cost = {
731   COSTS_N_INSNS (5),    /* mulsi */
732   COSTS_N_INSNS (3),    /* mulsi_const */
733   COSTS_N_INSNS (2),    /* mulsi_const9 */
734   COSTS_N_INSNS (5),    /* muldi */
735   COSTS_N_INSNS (17),   /* divsi */
736   COSTS_N_INSNS (17),   /* divdi */
737   COSTS_N_INSNS (3),    /* fp */
738   COSTS_N_INSNS (3),    /* dmul */
739   COSTS_N_INSNS (17),   /* sdiv */
740   COSTS_N_INSNS (31),   /* ddiv */
741   32,                   /* cache line size */
742   32,                   /* l1 cache */
743   512,                  /* l2 cache */
744   1,                    /* streams */
745 };
746
747 /* Instruction costs on PPC7450 processors.  */
748 static const
749 struct processor_costs ppc7450_cost = {
750   COSTS_N_INSNS (4),    /* mulsi */
751   COSTS_N_INSNS (3),    /* mulsi_const */
752   COSTS_N_INSNS (3),    /* mulsi_const9 */
753   COSTS_N_INSNS (4),    /* muldi */
754   COSTS_N_INSNS (23),   /* divsi */
755   COSTS_N_INSNS (23),   /* divdi */
756   COSTS_N_INSNS (5),    /* fp */
757   COSTS_N_INSNS (5),    /* dmul */
758   COSTS_N_INSNS (21),   /* sdiv */
759   COSTS_N_INSNS (35),   /* ddiv */
760   32,                   /* cache line size */
761   32,                   /* l1 cache */
762   1024,                 /* l2 cache */
763   1,                    /* streams */
764 };
765
766 /* Instruction costs on PPC8540 processors.  */
767 static const
768 struct processor_costs ppc8540_cost = {
769   COSTS_N_INSNS (4),    /* mulsi */
770   COSTS_N_INSNS (4),    /* mulsi_const */
771   COSTS_N_INSNS (4),    /* mulsi_const9 */
772   COSTS_N_INSNS (4),    /* muldi */
773   COSTS_N_INSNS (19),   /* divsi */
774   COSTS_N_INSNS (19),   /* divdi */
775   COSTS_N_INSNS (4),    /* fp */
776   COSTS_N_INSNS (4),    /* dmul */
777   COSTS_N_INSNS (29),   /* sdiv */
778   COSTS_N_INSNS (29),   /* ddiv */
779   32,                   /* cache line size */
780   32,                   /* l1 cache */
781   256,                  /* l2 cache */
782   1,                    /* prefetch streams /*/
783 };
784
785 /* Instruction costs on E300C2 and E300C3 cores.  */
786 static const
787 struct processor_costs ppce300c2c3_cost = {
788   COSTS_N_INSNS (4),    /* mulsi */
789   COSTS_N_INSNS (4),    /* mulsi_const */
790   COSTS_N_INSNS (4),    /* mulsi_const9 */
791   COSTS_N_INSNS (4),    /* muldi */
792   COSTS_N_INSNS (19),   /* divsi */
793   COSTS_N_INSNS (19),   /* divdi */
794   COSTS_N_INSNS (3),    /* fp */
795   COSTS_N_INSNS (4),    /* dmul */
796   COSTS_N_INSNS (18),   /* sdiv */
797   COSTS_N_INSNS (33),   /* ddiv */
798   32,
799   16,                   /* l1 cache */
800   16,                   /* l2 cache */
801   1,                    /* prefetch streams /*/
802 };
803
804 /* Instruction costs on PPCE500MC processors.  */
805 static const
806 struct processor_costs ppce500mc_cost = {
807   COSTS_N_INSNS (4),    /* mulsi */
808   COSTS_N_INSNS (4),    /* mulsi_const */
809   COSTS_N_INSNS (4),    /* mulsi_const9 */
810   COSTS_N_INSNS (4),    /* muldi */
811   COSTS_N_INSNS (14),   /* divsi */
812   COSTS_N_INSNS (14),   /* divdi */
813   COSTS_N_INSNS (8),    /* fp */
814   COSTS_N_INSNS (10),   /* dmul */
815   COSTS_N_INSNS (36),   /* sdiv */
816   COSTS_N_INSNS (66),   /* ddiv */
817   64,                   /* cache line size */
818   32,                   /* l1 cache */
819   128,                  /* l2 cache */
820   1,                    /* prefetch streams /*/
821 };
822
823 /* Instruction costs on PPCE500MC64 processors.  */
824 static const
825 struct processor_costs ppce500mc64_cost = {
826   COSTS_N_INSNS (4),    /* mulsi */
827   COSTS_N_INSNS (4),    /* mulsi_const */
828   COSTS_N_INSNS (4),    /* mulsi_const9 */
829   COSTS_N_INSNS (4),    /* muldi */
830   COSTS_N_INSNS (14),   /* divsi */
831   COSTS_N_INSNS (14),   /* divdi */
832   COSTS_N_INSNS (4),    /* fp */
833   COSTS_N_INSNS (10),   /* dmul */
834   COSTS_N_INSNS (36),   /* sdiv */
835   COSTS_N_INSNS (66),   /* ddiv */
836   64,                   /* cache line size */
837   32,                   /* l1 cache */
838   128,                  /* l2 cache */
839   1,                    /* prefetch streams /*/
840 };
841
842 /* Instruction costs on AppliedMicro Titan processors.  */
843 static const
844 struct processor_costs titan_cost = {
845   COSTS_N_INSNS (5),    /* mulsi */
846   COSTS_N_INSNS (5),    /* mulsi_const */
847   COSTS_N_INSNS (5),    /* mulsi_const9 */
848   COSTS_N_INSNS (5),    /* muldi */
849   COSTS_N_INSNS (18),   /* divsi */
850   COSTS_N_INSNS (18),   /* divdi */
851   COSTS_N_INSNS (10),   /* fp */
852   COSTS_N_INSNS (10),   /* dmul */
853   COSTS_N_INSNS (46),   /* sdiv */
854   COSTS_N_INSNS (72),   /* ddiv */
855   32,                   /* cache line size */
856   32,                   /* l1 cache */
857   512,                  /* l2 cache */
858   1,                    /* prefetch streams /*/
859 };
860
861 /* Instruction costs on POWER4 and POWER5 processors.  */
862 static const
863 struct processor_costs power4_cost = {
864   COSTS_N_INSNS (3),    /* mulsi */
865   COSTS_N_INSNS (2),    /* mulsi_const */
866   COSTS_N_INSNS (2),    /* mulsi_const9 */
867   COSTS_N_INSNS (4),    /* muldi */
868   COSTS_N_INSNS (18),   /* divsi */
869   COSTS_N_INSNS (34),   /* divdi */
870   COSTS_N_INSNS (3),    /* fp */
871   COSTS_N_INSNS (3),    /* dmul */
872   COSTS_N_INSNS (17),   /* sdiv */
873   COSTS_N_INSNS (17),   /* ddiv */
874   128,                  /* cache line size */
875   32,                   /* l1 cache */
876   1024,                 /* l2 cache */
877   8,                    /* prefetch streams /*/
878 };
879
880 /* Instruction costs on POWER6 processors.  */
881 static const
882 struct processor_costs power6_cost = {
883   COSTS_N_INSNS (8),    /* mulsi */
884   COSTS_N_INSNS (8),    /* mulsi_const */
885   COSTS_N_INSNS (8),    /* mulsi_const9 */
886   COSTS_N_INSNS (8),    /* muldi */
887   COSTS_N_INSNS (22),   /* divsi */
888   COSTS_N_INSNS (28),   /* divdi */
889   COSTS_N_INSNS (3),    /* fp */
890   COSTS_N_INSNS (3),    /* dmul */
891   COSTS_N_INSNS (13),   /* sdiv */
892   COSTS_N_INSNS (16),   /* ddiv */
893   128,                  /* cache line size */
894   64,                   /* l1 cache */
895   2048,                 /* l2 cache */
896   16,                   /* prefetch streams */
897 };
898
899 /* Instruction costs on POWER7 processors.  */
900 static const
901 struct processor_costs power7_cost = {
902   COSTS_N_INSNS (2),    /* mulsi */
903   COSTS_N_INSNS (2),    /* mulsi_const */
904   COSTS_N_INSNS (2),    /* mulsi_const9 */
905   COSTS_N_INSNS (2),    /* muldi */
906   COSTS_N_INSNS (18),   /* divsi */
907   COSTS_N_INSNS (34),   /* divdi */
908   COSTS_N_INSNS (3),    /* fp */
909   COSTS_N_INSNS (3),    /* dmul */
910   COSTS_N_INSNS (13),   /* sdiv */
911   COSTS_N_INSNS (16),   /* ddiv */
912   128,                  /* cache line size */
913   32,                   /* l1 cache */
914   256,                  /* l2 cache */
915   12,                   /* prefetch streams */
916 };
917
918 /* Instruction costs on POWER A2 processors.  */
919 static const
920 struct processor_costs ppca2_cost = {
921   COSTS_N_INSNS (16),    /* mulsi */
922   COSTS_N_INSNS (16),    /* mulsi_const */
923   COSTS_N_INSNS (16),    /* mulsi_const9 */
924   COSTS_N_INSNS (16),   /* muldi */
925   COSTS_N_INSNS (22),   /* divsi */
926   COSTS_N_INSNS (28),   /* divdi */
927   COSTS_N_INSNS (3),    /* fp */
928   COSTS_N_INSNS (3),    /* dmul */
929   COSTS_N_INSNS (59),   /* sdiv */
930   COSTS_N_INSNS (72),   /* ddiv */
931   64,
932   16,                   /* l1 cache */
933   2048,                 /* l2 cache */
934   16,                   /* prefetch streams */
935 };
936
937 \f
938 /* Table that classifies rs6000 builtin functions (pure, const, etc.).  */
939 #undef RS6000_BUILTIN
940 #undef RS6000_BUILTIN_EQUATE
941 #define RS6000_BUILTIN(NAME, TYPE) TYPE,
942 #define RS6000_BUILTIN_EQUATE(NAME, VALUE)
943
944 static const enum rs6000_btc builtin_classify[(int)RS6000_BUILTIN_COUNT] =
945 {
946 #include "rs6000-builtin.def"
947 };
948
949 #undef RS6000_BUILTIN
950 #undef RS6000_BUILTIN_EQUATE
951
952 /* Support for -mveclibabi=<xxx> to control which vector library to use.  */
953 static tree (*rs6000_veclib_handler) (tree, tree, tree);
954
955 \f
956 static bool rs6000_function_ok_for_sibcall (tree, tree);
957 static const char *rs6000_invalid_within_doloop (const_rtx);
958 static bool rs6000_legitimate_address_p (enum machine_mode, rtx, bool);
959 static bool rs6000_debug_legitimate_address_p (enum machine_mode, rtx, bool);
960 static rtx rs6000_generate_compare (rtx, enum machine_mode);
961 static void rs6000_emit_stack_tie (void);
962 static void rs6000_frame_related (rtx, rtx, HOST_WIDE_INT, rtx, rtx);
963 static bool spe_func_has_64bit_regs_p (void);
964 static void emit_frame_save (rtx, rtx, enum machine_mode, unsigned int,
965                              int, HOST_WIDE_INT);
966 static rtx gen_frame_mem_offset (enum machine_mode, rtx, int);
967 static unsigned rs6000_hash_constant (rtx);
968 static unsigned toc_hash_function (const void *);
969 static int toc_hash_eq (const void *, const void *);
970 static bool reg_offset_addressing_ok_p (enum machine_mode);
971 static bool virtual_stack_registers_memory_p (rtx);
972 static bool constant_pool_expr_p (rtx);
973 static bool legitimate_small_data_p (enum machine_mode, rtx);
974 static bool legitimate_lo_sum_address_p (enum machine_mode, rtx, int);
975 static struct machine_function * rs6000_init_machine_status (void);
976 static bool rs6000_assemble_integer (rtx, unsigned int, int);
977 static bool no_global_regs_above (int, bool);
978 #ifdef HAVE_GAS_HIDDEN
979 static void rs6000_assemble_visibility (tree, int);
980 #endif
981 static int rs6000_ra_ever_killed (void);
982 static bool rs6000_attribute_takes_identifier_p (const_tree);
983 static tree rs6000_handle_longcall_attribute (tree *, tree, tree, int, bool *);
984 static tree rs6000_handle_altivec_attribute (tree *, tree, tree, int, bool *);
985 static bool rs6000_ms_bitfield_layout_p (const_tree);
986 static tree rs6000_handle_struct_attribute (tree *, tree, tree, int, bool *);
987 static void rs6000_eliminate_indexed_memrefs (rtx operands[2]);
988 static const char *rs6000_mangle_type (const_tree);
989 static void rs6000_set_default_type_attributes (tree);
990 static rtx rs6000_savres_routine_sym (rs6000_stack_t *, bool, bool, bool);
991 static rtx rs6000_emit_stack_reset (rs6000_stack_t *, rtx, rtx, int, bool);
992 static rtx rs6000_make_savres_rtx (rs6000_stack_t *, rtx, int,
993                                    enum machine_mode, bool, bool, bool);
994 static bool rs6000_reg_live_or_pic_offset_p (int);
995 static tree rs6000_builtin_vectorized_libmass (tree, tree, tree);
996 static tree rs6000_builtin_vectorized_function (tree, tree, tree);
997 static int rs6000_savres_strategy (rs6000_stack_t *, bool, int, int);
998 static void rs6000_restore_saved_cr (rtx, int);
999 static bool rs6000_output_addr_const_extra (FILE *, rtx);
1000 static void rs6000_output_function_prologue (FILE *, HOST_WIDE_INT);
1001 static void rs6000_output_function_epilogue (FILE *, HOST_WIDE_INT);
1002 static void rs6000_output_mi_thunk (FILE *, tree, HOST_WIDE_INT, HOST_WIDE_INT,
1003                                     tree);
1004 static rtx rs6000_emit_set_long_const (rtx, HOST_WIDE_INT, HOST_WIDE_INT);
1005 static bool rs6000_return_in_memory (const_tree, const_tree);
1006 static rtx rs6000_function_value (const_tree, const_tree, bool);
1007 static void rs6000_file_start (void);
1008 #if TARGET_ELF
1009 static int rs6000_elf_reloc_rw_mask (void);
1010 static void rs6000_elf_asm_out_constructor (rtx, int);
1011 static void rs6000_elf_asm_out_destructor (rtx, int);
1012 static void rs6000_elf_end_indicate_exec_stack (void) ATTRIBUTE_UNUSED;
1013 static void rs6000_elf_asm_init_sections (void);
1014 static section *rs6000_elf_select_rtx_section (enum machine_mode, rtx,
1015                                                unsigned HOST_WIDE_INT);
1016 static void rs6000_elf_encode_section_info (tree, rtx, int)
1017      ATTRIBUTE_UNUSED;
1018 #endif
1019 static bool rs6000_use_blocks_for_constant_p (enum machine_mode, const_rtx);
1020 static void rs6000_alloc_sdmode_stack_slot (void);
1021 static void rs6000_instantiate_decls (void);
1022 #if TARGET_XCOFF
1023 static void rs6000_xcoff_asm_output_anchor (rtx);
1024 static void rs6000_xcoff_asm_globalize_label (FILE *, const char *);
1025 static void rs6000_xcoff_asm_init_sections (void);
1026 static int rs6000_xcoff_reloc_rw_mask (void);
1027 static void rs6000_xcoff_asm_named_section (const char *, unsigned int, tree);
1028 static section *rs6000_xcoff_select_section (tree, int,
1029                                              unsigned HOST_WIDE_INT);
1030 static void rs6000_xcoff_unique_section (tree, int);
1031 static section *rs6000_xcoff_select_rtx_section
1032   (enum machine_mode, rtx, unsigned HOST_WIDE_INT);
1033 static const char * rs6000_xcoff_strip_name_encoding (const char *);
1034 static unsigned int rs6000_xcoff_section_type_flags (tree, const char *, int);
1035 static void rs6000_xcoff_file_start (void);
1036 static void rs6000_xcoff_file_end (void);
1037 #endif
1038 static int rs6000_variable_issue (FILE *, int, rtx, int);
1039 static int rs6000_register_move_cost (enum machine_mode,
1040                                       reg_class_t, reg_class_t);
1041 static int rs6000_memory_move_cost (enum machine_mode, reg_class_t, bool);
1042 static bool rs6000_rtx_costs (rtx, int, int, int *, bool);
1043 static bool rs6000_debug_rtx_costs (rtx, int, int, int *, bool);
1044 static int rs6000_debug_address_cost (rtx, bool);
1045 static int rs6000_adjust_cost (rtx, rtx, rtx, int);
1046 static int rs6000_debug_adjust_cost (rtx, rtx, rtx, int);
1047 static void rs6000_sched_init (FILE *, int, int);
1048 static bool is_microcoded_insn (rtx);
1049 static bool is_nonpipeline_insn (rtx);
1050 static bool is_cracked_insn (rtx);
1051 static bool is_branch_slot_insn (rtx);
1052 static bool is_load_insn (rtx);
1053 static rtx get_store_dest (rtx pat);
1054 static bool is_store_insn (rtx);
1055 static bool set_to_load_agen (rtx,rtx);
1056 static bool adjacent_mem_locations (rtx,rtx);
1057 static int rs6000_adjust_priority (rtx, int);
1058 static int rs6000_issue_rate (void);
1059 static bool rs6000_is_costly_dependence (dep_t, int, int);
1060 static rtx get_next_active_insn (rtx, rtx);
1061 static bool insn_terminates_group_p (rtx , enum group_termination);
1062 static bool insn_must_be_first_in_group (rtx);
1063 static bool insn_must_be_last_in_group (rtx);
1064 static bool is_costly_group (rtx *, rtx);
1065 static int force_new_group (int, FILE *, rtx *, rtx, bool *, int, int *);
1066 static int redefine_groups (FILE *, int, rtx, rtx);
1067 static int pad_groups (FILE *, int, rtx, rtx);
1068 static void rs6000_sched_finish (FILE *, int);
1069 static int rs6000_sched_reorder (FILE *, int, rtx *, int *, int);
1070 static int rs6000_sched_reorder2 (FILE *, int, rtx *, int *, int);
1071 static int rs6000_use_sched_lookahead (void);
1072 static int rs6000_use_sched_lookahead_guard (rtx);
1073 static void * rs6000_alloc_sched_context (void);
1074 static void rs6000_init_sched_context (void *, bool);
1075 static void rs6000_set_sched_context (void *);
1076 static void rs6000_free_sched_context (void *);
1077 static tree rs6000_builtin_reciprocal (unsigned int, bool, bool);
1078 static tree rs6000_builtin_mask_for_load (void);
1079 static tree rs6000_builtin_mul_widen_even (tree);
1080 static tree rs6000_builtin_mul_widen_odd (tree);
1081 static tree rs6000_builtin_conversion (unsigned int, tree, tree);
1082 static tree rs6000_builtin_vec_perm (tree, tree *);
1083 static bool rs6000_builtin_support_vector_misalignment (enum
1084                                                         machine_mode,
1085                                                         const_tree,
1086                                                         int, bool);
1087 static int rs6000_builtin_vectorization_cost (enum vect_cost_for_stmt,
1088                                               tree, int);
1089 static enum machine_mode rs6000_preferred_simd_mode (enum machine_mode);
1090
1091 static void def_builtin (int, const char *, tree, int);
1092 static bool rs6000_vector_alignment_reachable (const_tree, bool);
1093 static void rs6000_init_builtins (void);
1094 static tree rs6000_builtin_decl (unsigned, bool);
1095
1096 static rtx rs6000_expand_unop_builtin (enum insn_code, tree, rtx);
1097 static rtx rs6000_expand_binop_builtin (enum insn_code, tree, rtx);
1098 static rtx rs6000_expand_ternop_builtin (enum insn_code, tree, rtx);
1099 static rtx rs6000_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
1100 static void altivec_init_builtins (void);
1101 static unsigned builtin_hash_function (const void *);
1102 static int builtin_hash_eq (const void *, const void *);
1103 static tree builtin_function_type (enum machine_mode, enum machine_mode,
1104                                    enum machine_mode, enum machine_mode,
1105                                    enum rs6000_builtins, const char *name);
1106 static void rs6000_common_init_builtins (void);
1107 static void rs6000_init_libfuncs (void);
1108
1109 static void paired_init_builtins (void);
1110 static rtx paired_expand_builtin (tree, rtx, bool *);
1111 static rtx paired_expand_lv_builtin (enum insn_code, tree, rtx);
1112 static rtx paired_expand_stv_builtin (enum insn_code, tree);
1113 static rtx paired_expand_predicate_builtin (enum insn_code, tree, rtx);
1114
1115 static void enable_mask_for_builtins (struct builtin_description *, int,
1116                                       enum rs6000_builtins,
1117                                       enum rs6000_builtins);
1118 static void spe_init_builtins (void);
1119 static rtx spe_expand_builtin (tree, rtx, bool *);
1120 static rtx spe_expand_stv_builtin (enum insn_code, tree);
1121 static rtx spe_expand_predicate_builtin (enum insn_code, tree, rtx);
1122 static rtx spe_expand_evsel_builtin (enum insn_code, tree, rtx);
1123 static int rs6000_emit_int_cmove (rtx, rtx, rtx, rtx);
1124 static rs6000_stack_t *rs6000_stack_info (void);
1125 static void debug_stack_info (rs6000_stack_t *);
1126
1127 static rtx altivec_expand_builtin (tree, rtx, bool *);
1128 static rtx altivec_expand_ld_builtin (tree, rtx, bool *);
1129 static rtx altivec_expand_st_builtin (tree, rtx, bool *);
1130 static rtx altivec_expand_dst_builtin (tree, rtx, bool *);
1131 static rtx altivec_expand_abs_builtin (enum insn_code, tree, rtx);
1132 static rtx altivec_expand_predicate_builtin (enum insn_code, tree, rtx);
1133 static rtx altivec_expand_stv_builtin (enum insn_code, tree);
1134 static rtx altivec_expand_vec_init_builtin (tree, tree, rtx);
1135 static rtx altivec_expand_vec_set_builtin (tree);
1136 static rtx altivec_expand_vec_ext_builtin (tree, rtx);
1137 static int get_element_number (tree, tree);
1138 static void rs6000_option_override (void);
1139 static void rs6000_option_init_struct (struct gcc_options *);
1140 static void rs6000_option_default_params (void);
1141 static bool rs6000_handle_option (size_t, const char *, int);
1142 static void rs6000_parse_tls_size_option (void);
1143 static void rs6000_parse_yes_no_option (const char *, const char *, int *);
1144 static int first_altivec_reg_to_save (void);
1145 static unsigned int compute_vrsave_mask (void);
1146 static void compute_save_world_info (rs6000_stack_t *info_ptr);
1147 static void is_altivec_return_reg (rtx, void *);
1148 static rtx generate_set_vrsave (rtx, rs6000_stack_t *, int);
1149 int easy_vector_constant (rtx, enum machine_mode);
1150 static rtx rs6000_dwarf_register_span (rtx);
1151 static void rs6000_init_dwarf_reg_sizes_extra (tree);
1152 static rtx rs6000_legitimize_address (rtx, rtx, enum machine_mode);
1153 static rtx rs6000_debug_legitimize_address (rtx, rtx, enum machine_mode);
1154 static rtx rs6000_legitimize_tls_address (rtx, enum tls_model);
1155 static void rs6000_output_dwarf_dtprel (FILE *, int, rtx) ATTRIBUTE_UNUSED;
1156 static rtx rs6000_delegitimize_address (rtx);
1157 static rtx rs6000_tls_get_addr (void);
1158 static rtx rs6000_got_sym (void);
1159 static int rs6000_tls_symbol_ref_1 (rtx *, void *);
1160 static const char *rs6000_get_some_local_dynamic_name (void);
1161 static int rs6000_get_some_local_dynamic_name_1 (rtx *, void *);
1162 static rtx rs6000_complex_function_value (enum machine_mode);
1163 static rtx rs6000_spe_function_arg (const CUMULATIVE_ARGS *,
1164                                     enum machine_mode, const_tree);
1165 static void rs6000_darwin64_record_arg_advance_flush (CUMULATIVE_ARGS *,
1166                                                       HOST_WIDE_INT, int);
1167 static void rs6000_darwin64_record_arg_advance_recurse (CUMULATIVE_ARGS *,
1168                                                         const_tree,
1169                                                         HOST_WIDE_INT);
1170 static void rs6000_darwin64_record_arg_flush (CUMULATIVE_ARGS *,
1171                                               HOST_WIDE_INT,
1172                                               rtx[], int *);
1173 static void rs6000_darwin64_record_arg_recurse (CUMULATIVE_ARGS *,
1174                                                 const_tree, HOST_WIDE_INT,
1175                                                 rtx[], int *);
1176 static rtx rs6000_darwin64_record_arg (CUMULATIVE_ARGS *, const_tree, bool, bool);
1177 static rtx rs6000_mixed_function_arg (enum machine_mode, const_tree, int);
1178 static void rs6000_function_arg_advance (CUMULATIVE_ARGS *, enum machine_mode,
1179                                          const_tree, bool);
1180 static rtx rs6000_function_arg (CUMULATIVE_ARGS *, enum machine_mode,
1181                                 const_tree, bool);
1182 static void rs6000_move_block_from_reg (int regno, rtx x, int nregs);
1183 static void setup_incoming_varargs (CUMULATIVE_ARGS *,
1184                                     enum machine_mode, tree,
1185                                     int *, int);
1186 static bool rs6000_pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode,
1187                                       const_tree, bool);
1188 static int rs6000_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode,
1189                                      tree, bool);
1190 static const char *invalid_arg_for_unprototyped_fn (const_tree, const_tree, const_tree);
1191 #if TARGET_MACHO
1192 static void macho_branch_islands (void);
1193 static int no_previous_def (tree function_name);
1194 static tree get_prev_label (tree function_name);
1195 static void rs6000_darwin_file_start (void);
1196 #endif
1197
1198 static tree rs6000_build_builtin_va_list (void);
1199 static void rs6000_va_start (tree, rtx);
1200 static tree rs6000_gimplify_va_arg (tree, tree, gimple_seq *, gimple_seq *);
1201 static bool rs6000_must_pass_in_stack (enum machine_mode, const_tree);
1202 static bool rs6000_scalar_mode_supported_p (enum machine_mode);
1203 static bool rs6000_vector_mode_supported_p (enum machine_mode);
1204 static rtx rs6000_emit_vector_compare_inner (enum rtx_code, rtx, rtx);
1205 static rtx rs6000_emit_vector_compare (enum rtx_code, rtx, rtx,
1206                                        enum machine_mode);
1207 static tree rs6000_stack_protect_fail (void);
1208
1209 static rtx rs6000_legitimize_reload_address (rtx, enum machine_mode, int, int,
1210                                              int, int *);
1211
1212 static rtx rs6000_debug_legitimize_reload_address (rtx, enum machine_mode, int,
1213                                                    int, int, int *);
1214
1215 rtx (*rs6000_legitimize_reload_address_ptr) (rtx, enum machine_mode, int, int,
1216                                              int, int *)
1217   = rs6000_legitimize_reload_address;
1218
1219 static bool rs6000_mode_dependent_address_p (const_rtx);
1220 static bool rs6000_mode_dependent_address (const_rtx);
1221 static bool rs6000_debug_mode_dependent_address (const_rtx);
1222 static bool (*rs6000_mode_dependent_address_ptr) (const_rtx)
1223   = rs6000_mode_dependent_address;
1224
1225 static enum reg_class rs6000_secondary_reload_class (enum reg_class,
1226                                                      enum machine_mode, rtx);
1227 static enum reg_class rs6000_debug_secondary_reload_class (enum reg_class,
1228                                                            enum machine_mode,
1229                                                            rtx);
1230 enum reg_class (*rs6000_secondary_reload_class_ptr) (enum reg_class,
1231                                                      enum machine_mode, rtx)
1232   = rs6000_secondary_reload_class;
1233
1234 static enum reg_class rs6000_preferred_reload_class (rtx, enum reg_class);
1235 static enum reg_class rs6000_debug_preferred_reload_class (rtx,
1236                                                            enum reg_class);
1237 enum reg_class (*rs6000_preferred_reload_class_ptr) (rtx, enum reg_class)
1238   = rs6000_preferred_reload_class;
1239
1240 static bool rs6000_secondary_memory_needed (enum reg_class, enum reg_class,
1241                                             enum machine_mode);
1242
1243 static bool rs6000_debug_secondary_memory_needed (enum reg_class,
1244                                                   enum reg_class,
1245                                                   enum machine_mode);
1246
1247 bool (*rs6000_secondary_memory_needed_ptr) (enum reg_class, enum reg_class,
1248                                             enum machine_mode)
1249   = rs6000_secondary_memory_needed;
1250
1251 static bool rs6000_cannot_change_mode_class (enum machine_mode,
1252                                              enum machine_mode,
1253                                              enum reg_class);
1254 static bool rs6000_debug_cannot_change_mode_class (enum machine_mode,
1255                                                    enum machine_mode,
1256                                                    enum reg_class);
1257
1258 bool (*rs6000_cannot_change_mode_class_ptr) (enum machine_mode,
1259                                              enum machine_mode,
1260                                              enum reg_class)
1261   = rs6000_cannot_change_mode_class;
1262
1263 static reg_class_t rs6000_secondary_reload (bool, rtx, reg_class_t,
1264                                             enum machine_mode,
1265                                             struct secondary_reload_info *);
1266
1267 static const reg_class_t *rs6000_ira_cover_classes (void);
1268
1269 const int INSN_NOT_AVAILABLE = -1;
1270 static enum machine_mode rs6000_eh_return_filter_mode (void);
1271 static bool rs6000_can_eliminate (const int, const int);
1272 static void rs6000_trampoline_init (rtx, tree, rtx);
1273
1274 /* Hash table stuff for keeping track of TOC entries.  */
1275
1276 struct GTY(()) toc_hash_struct
1277 {
1278   /* `key' will satisfy CONSTANT_P; in fact, it will satisfy
1279      ASM_OUTPUT_SPECIAL_POOL_ENTRY_P.  */
1280   rtx key;
1281   enum machine_mode key_mode;
1282   int labelno;
1283 };
1284
1285 static GTY ((param_is (struct toc_hash_struct))) htab_t toc_hash_table;
1286
1287 /* Hash table to keep track of the argument types for builtin functions.  */
1288
1289 struct GTY(()) builtin_hash_struct
1290 {
1291   tree type;
1292   enum machine_mode mode[4];    /* return value + 3 arguments.  */
1293   unsigned char uns_p[4];       /* and whether the types are unsigned.  */
1294 };
1295
1296 static GTY ((param_is (struct builtin_hash_struct))) htab_t builtin_hash_table;
1297 \f
1298 /* Default register names.  */
1299 char rs6000_reg_names[][8] =
1300 {
1301       "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",
1302       "8",  "9", "10", "11", "12", "13", "14", "15",
1303      "16", "17", "18", "19", "20", "21", "22", "23",
1304      "24", "25", "26", "27", "28", "29", "30", "31",
1305       "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",
1306       "8",  "9", "10", "11", "12", "13", "14", "15",
1307      "16", "17", "18", "19", "20", "21", "22", "23",
1308      "24", "25", "26", "27", "28", "29", "30", "31",
1309      "mq", "lr", "ctr","ap",
1310       "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",
1311       "ca",
1312       /* AltiVec registers.  */
1313       "0",  "1",  "2",  "3",  "4",  "5",  "6", "7",
1314       "8",  "9",  "10", "11", "12", "13", "14", "15",
1315       "16", "17", "18", "19", "20", "21", "22", "23",
1316       "24", "25", "26", "27", "28", "29", "30", "31",
1317       "vrsave", "vscr",
1318       /* SPE registers.  */
1319       "spe_acc", "spefscr",
1320       /* Soft frame pointer.  */
1321       "sfp"
1322 };
1323
1324 #ifdef TARGET_REGNAMES
1325 static const char alt_reg_names[][8] =
1326 {
1327    "%r0",   "%r1",  "%r2",  "%r3",  "%r4",  "%r5",  "%r6",  "%r7",
1328    "%r8",   "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15",
1329   "%r16",  "%r17", "%r18", "%r19", "%r20", "%r21", "%r22", "%r23",
1330   "%r24",  "%r25", "%r26", "%r27", "%r28", "%r29", "%r30", "%r31",
1331    "%f0",   "%f1",  "%f2",  "%f3",  "%f4",  "%f5",  "%f6",  "%f7",
1332    "%f8",   "%f9", "%f10", "%f11", "%f12", "%f13", "%f14", "%f15",
1333   "%f16",  "%f17", "%f18", "%f19", "%f20", "%f21", "%f22", "%f23",
1334   "%f24",  "%f25", "%f26", "%f27", "%f28", "%f29", "%f30", "%f31",
1335     "mq",    "lr",  "ctr",   "ap",
1336   "%cr0",  "%cr1", "%cr2", "%cr3", "%cr4", "%cr5", "%cr6", "%cr7",
1337    "ca",
1338   /* AltiVec registers.  */
1339    "%v0",  "%v1",  "%v2",  "%v3",  "%v4",  "%v5",  "%v6", "%v7",
1340    "%v8",  "%v9", "%v10", "%v11", "%v12", "%v13", "%v14", "%v15",
1341   "%v16", "%v17", "%v18", "%v19", "%v20", "%v21", "%v22", "%v23",
1342   "%v24", "%v25", "%v26", "%v27", "%v28", "%v29", "%v30", "%v31",
1343   "vrsave", "vscr",
1344   /* SPE registers.  */
1345   "spe_acc", "spefscr",
1346   /* Soft frame pointer.  */
1347   "sfp"
1348 };
1349 #endif
1350
1351 /* Table of valid machine attributes.  */
1352
1353 static const struct attribute_spec rs6000_attribute_table[] =
1354 {
1355   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
1356   { "altivec",   1, 1, false, true,  false, rs6000_handle_altivec_attribute },
1357   { "longcall",  0, 0, false, true,  true,  rs6000_handle_longcall_attribute },
1358   { "shortcall", 0, 0, false, true,  true,  rs6000_handle_longcall_attribute },
1359   { "ms_struct", 0, 0, false, false, false, rs6000_handle_struct_attribute },
1360   { "gcc_struct", 0, 0, false, false, false, rs6000_handle_struct_attribute },
1361 #ifdef SUBTARGET_ATTRIBUTE_TABLE
1362   SUBTARGET_ATTRIBUTE_TABLE,
1363 #endif
1364   { NULL,        0, 0, false, false, false, NULL }
1365 };
1366
1367 /* Implement TARGET_OPTION_OPTIMIZATION_TABLE.  */
1368 static const struct default_options rs6000_option_optimization_table[] =
1369   {
1370     { OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
1371     { OPT_LEVELS_NONE, 0, NULL, 0 }
1372   };
1373 \f
1374 #ifndef MASK_STRICT_ALIGN
1375 #define MASK_STRICT_ALIGN 0
1376 #endif
1377 #ifndef TARGET_PROFILE_KERNEL
1378 #define TARGET_PROFILE_KERNEL 0
1379 #endif
1380
1381 /* The VRSAVE bitmask puts bit %v0 as the most significant bit.  */
1382 #define ALTIVEC_REG_BIT(REGNO) (0x80000000 >> ((REGNO) - FIRST_ALTIVEC_REGNO))
1383 \f
1384 /* Initialize the GCC target structure.  */
1385 #undef TARGET_ATTRIBUTE_TABLE
1386 #define TARGET_ATTRIBUTE_TABLE rs6000_attribute_table
1387 #undef TARGET_SET_DEFAULT_TYPE_ATTRIBUTES
1388 #define TARGET_SET_DEFAULT_TYPE_ATTRIBUTES rs6000_set_default_type_attributes
1389 #undef TARGET_ATTRIBUTE_TAKES_IDENTIFIER_P
1390 #define TARGET_ATTRIBUTE_TAKES_IDENTIFIER_P rs6000_attribute_takes_identifier_p
1391
1392 #undef TARGET_ASM_ALIGNED_DI_OP
1393 #define TARGET_ASM_ALIGNED_DI_OP DOUBLE_INT_ASM_OP
1394
1395 /* Default unaligned ops are only provided for ELF.  Find the ops needed
1396    for non-ELF systems.  */
1397 #ifndef OBJECT_FORMAT_ELF
1398 #if TARGET_XCOFF
1399 /* For XCOFF.  rs6000_assemble_integer will handle unaligned DIs on
1400    64-bit targets.  */
1401 #undef TARGET_ASM_UNALIGNED_HI_OP
1402 #define TARGET_ASM_UNALIGNED_HI_OP "\t.vbyte\t2,"
1403 #undef TARGET_ASM_UNALIGNED_SI_OP
1404 #define TARGET_ASM_UNALIGNED_SI_OP "\t.vbyte\t4,"
1405 #undef TARGET_ASM_UNALIGNED_DI_OP
1406 #define TARGET_ASM_UNALIGNED_DI_OP "\t.vbyte\t8,"
1407 #else
1408 /* For Darwin.  */
1409 #undef TARGET_ASM_UNALIGNED_HI_OP
1410 #define TARGET_ASM_UNALIGNED_HI_OP "\t.short\t"
1411 #undef TARGET_ASM_UNALIGNED_SI_OP
1412 #define TARGET_ASM_UNALIGNED_SI_OP "\t.long\t"
1413 #undef TARGET_ASM_UNALIGNED_DI_OP
1414 #define TARGET_ASM_UNALIGNED_DI_OP "\t.quad\t"
1415 #undef TARGET_ASM_ALIGNED_DI_OP
1416 #define TARGET_ASM_ALIGNED_DI_OP "\t.quad\t"
1417 #endif
1418 #endif
1419
1420 /* This hook deals with fixups for relocatable code and DI-mode objects
1421    in 64-bit code.  */
1422 #undef TARGET_ASM_INTEGER
1423 #define TARGET_ASM_INTEGER rs6000_assemble_integer
1424
1425 #ifdef HAVE_GAS_HIDDEN
1426 #undef TARGET_ASM_ASSEMBLE_VISIBILITY
1427 #define TARGET_ASM_ASSEMBLE_VISIBILITY rs6000_assemble_visibility
1428 #endif
1429
1430 #undef TARGET_HAVE_TLS
1431 #define TARGET_HAVE_TLS HAVE_AS_TLS
1432
1433 #undef TARGET_CANNOT_FORCE_CONST_MEM
1434 #define TARGET_CANNOT_FORCE_CONST_MEM rs6000_tls_referenced_p
1435
1436 #undef TARGET_DELEGITIMIZE_ADDRESS
1437 #define TARGET_DELEGITIMIZE_ADDRESS rs6000_delegitimize_address
1438
1439 #undef TARGET_ASM_FUNCTION_PROLOGUE
1440 #define TARGET_ASM_FUNCTION_PROLOGUE rs6000_output_function_prologue
1441 #undef TARGET_ASM_FUNCTION_EPILOGUE
1442 #define TARGET_ASM_FUNCTION_EPILOGUE rs6000_output_function_epilogue
1443
1444 #undef TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA
1445 #define TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA rs6000_output_addr_const_extra
1446
1447 #undef TARGET_LEGITIMIZE_ADDRESS
1448 #define TARGET_LEGITIMIZE_ADDRESS rs6000_legitimize_address
1449
1450 #undef  TARGET_SCHED_VARIABLE_ISSUE
1451 #define TARGET_SCHED_VARIABLE_ISSUE rs6000_variable_issue
1452
1453 #undef TARGET_SCHED_ISSUE_RATE
1454 #define TARGET_SCHED_ISSUE_RATE rs6000_issue_rate
1455 #undef TARGET_SCHED_ADJUST_COST
1456 #define TARGET_SCHED_ADJUST_COST rs6000_adjust_cost
1457 #undef TARGET_SCHED_ADJUST_PRIORITY
1458 #define TARGET_SCHED_ADJUST_PRIORITY rs6000_adjust_priority
1459 #undef TARGET_SCHED_IS_COSTLY_DEPENDENCE
1460 #define TARGET_SCHED_IS_COSTLY_DEPENDENCE rs6000_is_costly_dependence
1461 #undef TARGET_SCHED_INIT
1462 #define TARGET_SCHED_INIT rs6000_sched_init
1463 #undef TARGET_SCHED_FINISH
1464 #define TARGET_SCHED_FINISH rs6000_sched_finish
1465 #undef TARGET_SCHED_REORDER
1466 #define TARGET_SCHED_REORDER rs6000_sched_reorder
1467 #undef TARGET_SCHED_REORDER2
1468 #define TARGET_SCHED_REORDER2 rs6000_sched_reorder2
1469
1470 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
1471 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD rs6000_use_sched_lookahead
1472
1473 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD
1474 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD rs6000_use_sched_lookahead_guard
1475
1476 #undef TARGET_SCHED_ALLOC_SCHED_CONTEXT
1477 #define TARGET_SCHED_ALLOC_SCHED_CONTEXT rs6000_alloc_sched_context
1478 #undef TARGET_SCHED_INIT_SCHED_CONTEXT
1479 #define TARGET_SCHED_INIT_SCHED_CONTEXT rs6000_init_sched_context
1480 #undef TARGET_SCHED_SET_SCHED_CONTEXT
1481 #define TARGET_SCHED_SET_SCHED_CONTEXT rs6000_set_sched_context
1482 #undef TARGET_SCHED_FREE_SCHED_CONTEXT
1483 #define TARGET_SCHED_FREE_SCHED_CONTEXT rs6000_free_sched_context
1484
1485 #undef TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD
1486 #define TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD rs6000_builtin_mask_for_load
1487 #undef TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_EVEN
1488 #define TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_EVEN rs6000_builtin_mul_widen_even
1489 #undef TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_ODD
1490 #define TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_ODD rs6000_builtin_mul_widen_odd
1491 #undef TARGET_VECTORIZE_BUILTIN_CONVERSION
1492 #define TARGET_VECTORIZE_BUILTIN_CONVERSION rs6000_builtin_conversion
1493 #undef TARGET_VECTORIZE_BUILTIN_VEC_PERM
1494 #define TARGET_VECTORIZE_BUILTIN_VEC_PERM rs6000_builtin_vec_perm
1495 #undef TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT
1496 #define TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT            \
1497   rs6000_builtin_support_vector_misalignment
1498 #undef TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE
1499 #define TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE rs6000_vector_alignment_reachable
1500 #undef TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST
1501 #define TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST \
1502   rs6000_builtin_vectorization_cost
1503 #undef TARGET_VECTORIZE_PREFERRED_SIMD_MODE
1504 #define TARGET_VECTORIZE_PREFERRED_SIMD_MODE \
1505   rs6000_preferred_simd_mode
1506
1507 #undef TARGET_INIT_BUILTINS
1508 #define TARGET_INIT_BUILTINS rs6000_init_builtins
1509 #undef TARGET_BUILTIN_DECL
1510 #define TARGET_BUILTIN_DECL rs6000_builtin_decl
1511
1512 #undef TARGET_EXPAND_BUILTIN
1513 #define TARGET_EXPAND_BUILTIN rs6000_expand_builtin
1514
1515 #undef TARGET_MANGLE_TYPE
1516 #define TARGET_MANGLE_TYPE rs6000_mangle_type
1517
1518 #undef TARGET_INIT_LIBFUNCS
1519 #define TARGET_INIT_LIBFUNCS rs6000_init_libfuncs
1520
1521 #if TARGET_MACHO
1522 #undef TARGET_BINDS_LOCAL_P
1523 #define TARGET_BINDS_LOCAL_P darwin_binds_local_p
1524 #endif
1525
1526 #undef TARGET_MS_BITFIELD_LAYOUT_P
1527 #define TARGET_MS_BITFIELD_LAYOUT_P rs6000_ms_bitfield_layout_p
1528
1529 #undef TARGET_ASM_OUTPUT_MI_THUNK
1530 #define TARGET_ASM_OUTPUT_MI_THUNK rs6000_output_mi_thunk
1531
1532 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
1533 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK hook_bool_const_tree_hwi_hwi_const_tree_true
1534
1535 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
1536 #define TARGET_FUNCTION_OK_FOR_SIBCALL rs6000_function_ok_for_sibcall
1537
1538 #undef TARGET_INVALID_WITHIN_DOLOOP
1539 #define TARGET_INVALID_WITHIN_DOLOOP rs6000_invalid_within_doloop
1540
1541 #undef TARGET_REGISTER_MOVE_COST
1542 #define TARGET_REGISTER_MOVE_COST rs6000_register_move_cost
1543 #undef TARGET_MEMORY_MOVE_COST
1544 #define TARGET_MEMORY_MOVE_COST rs6000_memory_move_cost
1545 #undef TARGET_RTX_COSTS
1546 #define TARGET_RTX_COSTS rs6000_rtx_costs
1547 #undef TARGET_ADDRESS_COST
1548 #define TARGET_ADDRESS_COST hook_int_rtx_bool_0
1549
1550 #undef TARGET_DWARF_REGISTER_SPAN
1551 #define TARGET_DWARF_REGISTER_SPAN rs6000_dwarf_register_span
1552
1553 #undef TARGET_INIT_DWARF_REG_SIZES_EXTRA
1554 #define TARGET_INIT_DWARF_REG_SIZES_EXTRA rs6000_init_dwarf_reg_sizes_extra
1555
1556 /* On rs6000, function arguments are promoted, as are function return
1557    values.  */
1558 #undef TARGET_PROMOTE_FUNCTION_MODE
1559 #define TARGET_PROMOTE_FUNCTION_MODE default_promote_function_mode_always_promote
1560
1561 #undef TARGET_RETURN_IN_MEMORY
1562 #define TARGET_RETURN_IN_MEMORY rs6000_return_in_memory
1563
1564 #undef TARGET_SETUP_INCOMING_VARARGS
1565 #define TARGET_SETUP_INCOMING_VARARGS setup_incoming_varargs
1566
1567 /* Always strict argument naming on rs6000.  */
1568 #undef TARGET_STRICT_ARGUMENT_NAMING
1569 #define TARGET_STRICT_ARGUMENT_NAMING hook_bool_CUMULATIVE_ARGS_true
1570 #undef TARGET_PRETEND_OUTGOING_VARARGS_NAMED
1571 #define TARGET_PRETEND_OUTGOING_VARARGS_NAMED hook_bool_CUMULATIVE_ARGS_true
1572 #undef TARGET_SPLIT_COMPLEX_ARG
1573 #define TARGET_SPLIT_COMPLEX_ARG hook_bool_const_tree_true
1574 #undef TARGET_MUST_PASS_IN_STACK
1575 #define TARGET_MUST_PASS_IN_STACK rs6000_must_pass_in_stack
1576 #undef TARGET_PASS_BY_REFERENCE
1577 #define TARGET_PASS_BY_REFERENCE rs6000_pass_by_reference
1578 #undef TARGET_ARG_PARTIAL_BYTES
1579 #define TARGET_ARG_PARTIAL_BYTES rs6000_arg_partial_bytes
1580 #undef TARGET_FUNCTION_ARG_ADVANCE
1581 #define TARGET_FUNCTION_ARG_ADVANCE rs6000_function_arg_advance
1582 #undef TARGET_FUNCTION_ARG
1583 #define TARGET_FUNCTION_ARG rs6000_function_arg
1584
1585 #undef TARGET_BUILD_BUILTIN_VA_LIST
1586 #define TARGET_BUILD_BUILTIN_VA_LIST rs6000_build_builtin_va_list
1587
1588 #undef TARGET_EXPAND_BUILTIN_VA_START
1589 #define TARGET_EXPAND_BUILTIN_VA_START rs6000_va_start
1590
1591 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
1592 #define TARGET_GIMPLIFY_VA_ARG_EXPR rs6000_gimplify_va_arg
1593
1594 #undef TARGET_EH_RETURN_FILTER_MODE
1595 #define TARGET_EH_RETURN_FILTER_MODE rs6000_eh_return_filter_mode
1596
1597 #undef TARGET_SCALAR_MODE_SUPPORTED_P
1598 #define TARGET_SCALAR_MODE_SUPPORTED_P rs6000_scalar_mode_supported_p
1599
1600 #undef TARGET_VECTOR_MODE_SUPPORTED_P
1601 #define TARGET_VECTOR_MODE_SUPPORTED_P rs6000_vector_mode_supported_p
1602
1603 #undef TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN
1604 #define TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN invalid_arg_for_unprototyped_fn
1605
1606 #undef TARGET_HANDLE_OPTION
1607 #define TARGET_HANDLE_OPTION rs6000_handle_option
1608
1609 #undef TARGET_OPTION_OVERRIDE
1610 #define TARGET_OPTION_OVERRIDE rs6000_option_override
1611
1612 #undef TARGET_OPTION_INIT_STRUCT
1613 #define TARGET_OPTION_INIT_STRUCT rs6000_option_init_struct
1614
1615 #undef TARGET_OPTION_DEFAULT_PARAMS
1616 #define TARGET_OPTION_DEFAULT_PARAMS rs6000_option_default_params
1617
1618 #undef TARGET_OPTION_OPTIMIZATION_TABLE
1619 #define TARGET_OPTION_OPTIMIZATION_TABLE rs6000_option_optimization_table
1620
1621 #undef TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION
1622 #define TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION \
1623   rs6000_builtin_vectorized_function
1624
1625 #undef TARGET_DEFAULT_TARGET_FLAGS
1626 #define TARGET_DEFAULT_TARGET_FLAGS \
1627   (TARGET_DEFAULT)
1628
1629 #undef TARGET_STACK_PROTECT_FAIL
1630 #define TARGET_STACK_PROTECT_FAIL rs6000_stack_protect_fail
1631
1632 /* MPC604EUM 3.5.2 Weak Consistency between Multiple Processors
1633    The PowerPC architecture requires only weak consistency among
1634    processors--that is, memory accesses between processors need not be
1635    sequentially consistent and memory accesses among processors can occur
1636    in any order. The ability to order memory accesses weakly provides
1637    opportunities for more efficient use of the system bus. Unless a
1638    dependency exists, the 604e allows read operations to precede store
1639    operations.  */
1640 #undef TARGET_RELAXED_ORDERING
1641 #define TARGET_RELAXED_ORDERING true
1642
1643 #ifdef HAVE_AS_TLS
1644 #undef TARGET_ASM_OUTPUT_DWARF_DTPREL
1645 #define TARGET_ASM_OUTPUT_DWARF_DTPREL rs6000_output_dwarf_dtprel
1646 #endif
1647
1648 /* Use a 32-bit anchor range.  This leads to sequences like:
1649
1650         addis   tmp,anchor,high
1651         add     dest,tmp,low
1652
1653    where tmp itself acts as an anchor, and can be shared between
1654    accesses to the same 64k page.  */
1655 #undef TARGET_MIN_ANCHOR_OFFSET
1656 #define TARGET_MIN_ANCHOR_OFFSET -0x7fffffff - 1
1657 #undef TARGET_MAX_ANCHOR_OFFSET
1658 #define TARGET_MAX_ANCHOR_OFFSET 0x7fffffff
1659 #undef TARGET_USE_BLOCKS_FOR_CONSTANT_P
1660 #define TARGET_USE_BLOCKS_FOR_CONSTANT_P rs6000_use_blocks_for_constant_p
1661
1662 #undef TARGET_BUILTIN_RECIPROCAL
1663 #define TARGET_BUILTIN_RECIPROCAL rs6000_builtin_reciprocal
1664
1665 #undef TARGET_EXPAND_TO_RTL_HOOK
1666 #define TARGET_EXPAND_TO_RTL_HOOK rs6000_alloc_sdmode_stack_slot
1667
1668 #undef TARGET_INSTANTIATE_DECLS
1669 #define TARGET_INSTANTIATE_DECLS rs6000_instantiate_decls
1670
1671 #undef TARGET_SECONDARY_RELOAD
1672 #define TARGET_SECONDARY_RELOAD rs6000_secondary_reload
1673
1674 #undef TARGET_IRA_COVER_CLASSES
1675 #define TARGET_IRA_COVER_CLASSES rs6000_ira_cover_classes
1676
1677 #undef TARGET_LEGITIMATE_ADDRESS_P
1678 #define TARGET_LEGITIMATE_ADDRESS_P rs6000_legitimate_address_p
1679
1680 #undef TARGET_MODE_DEPENDENT_ADDRESS_P
1681 #define TARGET_MODE_DEPENDENT_ADDRESS_P rs6000_mode_dependent_address_p
1682
1683 #undef TARGET_CAN_ELIMINATE
1684 #define TARGET_CAN_ELIMINATE rs6000_can_eliminate
1685
1686 #undef TARGET_TRAMPOLINE_INIT
1687 #define TARGET_TRAMPOLINE_INIT rs6000_trampoline_init
1688
1689 #undef TARGET_FUNCTION_VALUE
1690 #define TARGET_FUNCTION_VALUE rs6000_function_value
1691
1692 struct gcc_target targetm = TARGET_INITIALIZER;
1693 \f
1694 /* Return number of consecutive hard regs needed starting at reg REGNO
1695    to hold something of mode MODE.
1696    This is ordinarily the length in words of a value of mode MODE
1697    but can be less for certain modes in special long registers.
1698
1699    For the SPE, GPRs are 64 bits but only 32 bits are visible in
1700    scalar instructions.  The upper 32 bits are only available to the
1701    SIMD instructions.
1702
1703    POWER and PowerPC GPRs hold 32 bits worth;
1704    PowerPC64 GPRs and FPRs point register holds 64 bits worth.  */
1705
1706 static int
1707 rs6000_hard_regno_nregs_internal (int regno, enum machine_mode mode)
1708 {
1709   unsigned HOST_WIDE_INT reg_size;
1710
1711   if (FP_REGNO_P (regno))
1712     reg_size = (VECTOR_MEM_VSX_P (mode)
1713                 ? UNITS_PER_VSX_WORD
1714                 : UNITS_PER_FP_WORD);
1715
1716   else if (SPE_SIMD_REGNO_P (regno) && TARGET_SPE && SPE_VECTOR_MODE (mode))
1717     reg_size = UNITS_PER_SPE_WORD;
1718
1719   else if (ALTIVEC_REGNO_P (regno))
1720     reg_size = UNITS_PER_ALTIVEC_WORD;
1721
1722   /* The value returned for SCmode in the E500 double case is 2 for
1723      ABI compatibility; storing an SCmode value in a single register
1724      would require function_arg and rs6000_spe_function_arg to handle
1725      SCmode so as to pass the value correctly in a pair of
1726      registers.  */
1727   else if (TARGET_E500_DOUBLE && FLOAT_MODE_P (mode) && mode != SCmode
1728            && !DECIMAL_FLOAT_MODE_P (mode))
1729     reg_size = UNITS_PER_FP_WORD;
1730
1731   else
1732     reg_size = UNITS_PER_WORD;
1733
1734   return (GET_MODE_SIZE (mode) + reg_size - 1) / reg_size;
1735 }
1736
1737 /* Value is 1 if hard register REGNO can hold a value of machine-mode
1738    MODE.  */
1739 static int
1740 rs6000_hard_regno_mode_ok (int regno, enum machine_mode mode)
1741 {
1742   int last_regno = regno + rs6000_hard_regno_nregs[mode][regno] - 1;
1743
1744   /* VSX registers that overlap the FPR registers are larger than for non-VSX
1745      implementations.  Don't allow an item to be split between a FP register
1746      and an Altivec register.  */
1747   if (VECTOR_MEM_VSX_P (mode))
1748     {
1749       if (FP_REGNO_P (regno))
1750         return FP_REGNO_P (last_regno);
1751
1752       if (ALTIVEC_REGNO_P (regno))
1753         return ALTIVEC_REGNO_P (last_regno);
1754     }
1755
1756   /* The GPRs can hold any mode, but values bigger than one register
1757      cannot go past R31.  */
1758   if (INT_REGNO_P (regno))
1759     return INT_REGNO_P (last_regno);
1760
1761   /* The float registers (except for VSX vector modes) can only hold floating
1762      modes and DImode.  This excludes the 32-bit decimal float mode for
1763      now.  */
1764   if (FP_REGNO_P (regno))
1765     {
1766       if (SCALAR_FLOAT_MODE_P (mode)
1767           && (mode != TDmode || (regno % 2) == 0)
1768           && FP_REGNO_P (last_regno))
1769         return 1;
1770
1771       if (GET_MODE_CLASS (mode) == MODE_INT
1772           && GET_MODE_SIZE (mode) == UNITS_PER_FP_WORD)
1773         return 1;
1774
1775       if (PAIRED_SIMD_REGNO_P (regno) && TARGET_PAIRED_FLOAT
1776           && PAIRED_VECTOR_MODE (mode))
1777         return 1;
1778
1779       return 0;
1780     }
1781
1782   /* The CR register can only hold CC modes.  */
1783   if (CR_REGNO_P (regno))
1784     return GET_MODE_CLASS (mode) == MODE_CC;
1785
1786   if (CA_REGNO_P (regno))
1787     return mode == BImode;
1788
1789   /* AltiVec only in AldyVec registers.  */
1790   if (ALTIVEC_REGNO_P (regno))
1791     return VECTOR_MEM_ALTIVEC_OR_VSX_P (mode);
1792
1793   /* ...but GPRs can hold SIMD data on the SPE in one register.  */
1794   if (SPE_SIMD_REGNO_P (regno) && TARGET_SPE && SPE_VECTOR_MODE (mode))
1795     return 1;
1796
1797   /* We cannot put TImode anywhere except general register and it must be able
1798      to fit within the register set.  In the future, allow TImode in the
1799      Altivec or VSX registers.  */
1800
1801   return GET_MODE_SIZE (mode) <= UNITS_PER_WORD;
1802 }
1803
1804 /* Print interesting facts about registers.  */
1805 static void
1806 rs6000_debug_reg_print (int first_regno, int last_regno, const char *reg_name)
1807 {
1808   int r, m;
1809
1810   for (r = first_regno; r <= last_regno; ++r)
1811     {
1812       const char *comma = "";
1813       int len;
1814
1815       if (first_regno == last_regno)
1816         fprintf (stderr, "%s:\t", reg_name);
1817       else
1818         fprintf (stderr, "%s%d:\t", reg_name, r - first_regno);
1819
1820       len = 8;
1821       for (m = 0; m < NUM_MACHINE_MODES; ++m)
1822         if (rs6000_hard_regno_mode_ok_p[m][r] && rs6000_hard_regno_nregs[m][r])
1823           {
1824             if (len > 70)
1825               {
1826                 fprintf (stderr, ",\n\t");
1827                 len = 8;
1828                 comma = "";
1829               }
1830
1831             if (rs6000_hard_regno_nregs[m][r] > 1)
1832               len += fprintf (stderr, "%s%s/%d", comma, GET_MODE_NAME (m),
1833                              rs6000_hard_regno_nregs[m][r]);
1834             else
1835               len += fprintf (stderr, "%s%s", comma, GET_MODE_NAME (m));
1836
1837             comma = ", ";
1838           }
1839
1840       if (call_used_regs[r])
1841         {
1842           if (len > 70)
1843             {
1844               fprintf (stderr, ",\n\t");
1845               len = 8;
1846               comma = "";
1847             }
1848
1849           len += fprintf (stderr, "%s%s", comma, "call-used");
1850           comma = ", ";
1851         }
1852
1853       if (fixed_regs[r])
1854         {
1855           if (len > 70)
1856             {
1857               fprintf (stderr, ",\n\t");
1858               len = 8;
1859               comma = "";
1860             }
1861
1862           len += fprintf (stderr, "%s%s", comma, "fixed");
1863           comma = ", ";
1864         }
1865
1866       if (len > 70)
1867         {
1868           fprintf (stderr, ",\n\t");
1869           comma = "";
1870         }
1871
1872       fprintf (stderr, "%sregno = %d\n", comma, r);
1873     }
1874 }
1875
1876 /* Print various interesting information with -mdebug=reg.  */
1877 static void
1878 rs6000_debug_reg_global (void)
1879 {
1880   const char *nl = (const char *)0;
1881   int m;
1882   char costly_num[20];
1883   char nop_num[20];
1884   const char *costly_str;
1885   const char *nop_str;
1886
1887   /* Map enum rs6000_vector to string.  */
1888   static const char *rs6000_debug_vector_unit[] = {
1889     "none",
1890     "altivec",
1891     "vsx",
1892     "paired",
1893     "spe",
1894     "other"
1895   };
1896
1897   fprintf (stderr, "Register information: (last virtual reg = %d)\n",
1898            LAST_VIRTUAL_REGISTER);
1899   rs6000_debug_reg_print (0, 31, "gr");
1900   rs6000_debug_reg_print (32, 63, "fp");
1901   rs6000_debug_reg_print (FIRST_ALTIVEC_REGNO,
1902                           LAST_ALTIVEC_REGNO,
1903                           "vs");
1904   rs6000_debug_reg_print (LR_REGNO, LR_REGNO, "lr");
1905   rs6000_debug_reg_print (CTR_REGNO, CTR_REGNO, "ctr");
1906   rs6000_debug_reg_print (CR0_REGNO, CR7_REGNO, "cr");
1907   rs6000_debug_reg_print (MQ_REGNO, MQ_REGNO, "mq");
1908   rs6000_debug_reg_print (CA_REGNO, CA_REGNO, "ca");
1909   rs6000_debug_reg_print (VRSAVE_REGNO, VRSAVE_REGNO, "vrsave");
1910   rs6000_debug_reg_print (VSCR_REGNO, VSCR_REGNO, "vscr");
1911   rs6000_debug_reg_print (SPE_ACC_REGNO, SPE_ACC_REGNO, "spe_a");
1912   rs6000_debug_reg_print (SPEFSCR_REGNO, SPEFSCR_REGNO, "spe_f");
1913
1914   fprintf (stderr,
1915            "\n"
1916            "d  reg_class = %s\n"
1917            "f  reg_class = %s\n"
1918            "v  reg_class = %s\n"
1919            "wa reg_class = %s\n"
1920            "wd reg_class = %s\n"
1921            "wf reg_class = %s\n"
1922            "ws reg_class = %s\n\n",
1923            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_d]],
1924            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_f]],
1925            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_v]],
1926            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_wa]],
1927            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_wd]],
1928            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_wf]],
1929            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_ws]]);
1930
1931   for (m = 0; m < NUM_MACHINE_MODES; ++m)
1932     if (rs6000_vector_unit[m] || rs6000_vector_mem[m])
1933       {
1934         nl = "\n";
1935         fprintf (stderr, "Vector mode: %-5s arithmetic: %-8s move: %-8s\n",
1936                  GET_MODE_NAME (m),
1937                  rs6000_debug_vector_unit[ rs6000_vector_unit[m] ],
1938                  rs6000_debug_vector_unit[ rs6000_vector_mem[m] ]);
1939       }
1940
1941   if (nl)
1942     fputs (nl, stderr);
1943
1944   if (rs6000_recip_control)
1945     {
1946       fprintf (stderr, "\nReciprocal mask = 0x%x\n", rs6000_recip_control);
1947
1948       for (m = 0; m < NUM_MACHINE_MODES; ++m)
1949         if (rs6000_recip_bits[m])
1950           {
1951             fprintf (stderr,
1952                      "Reciprocal estimate mode: %-5s divide: %s rsqrt: %s\n",
1953                      GET_MODE_NAME (m),
1954                      (RS6000_RECIP_AUTO_RE_P (m)
1955                       ? "auto"
1956                       : (RS6000_RECIP_HAVE_RE_P (m) ? "have" : "none")),
1957                      (RS6000_RECIP_AUTO_RSQRTE_P (m)
1958                       ? "auto"
1959                       : (RS6000_RECIP_HAVE_RSQRTE_P (m) ? "have" : "none")));
1960           }
1961
1962       fputs ("\n", stderr);
1963     }
1964
1965   switch (rs6000_sched_costly_dep)
1966     {
1967     case max_dep_latency:
1968       costly_str = "max_dep_latency";
1969       break;
1970
1971     case no_dep_costly:
1972       costly_str = "no_dep_costly";
1973       break;
1974
1975     case all_deps_costly:
1976       costly_str = "all_deps_costly";
1977       break;
1978
1979     case true_store_to_load_dep_costly:
1980       costly_str = "true_store_to_load_dep_costly";
1981       break;
1982
1983     case store_to_load_dep_costly:
1984       costly_str = "store_to_load_dep_costly";
1985       break;
1986
1987     default:
1988       costly_str = costly_num;
1989       sprintf (costly_num, "%d", (int)rs6000_sched_costly_dep);
1990       break;
1991     }
1992
1993   switch (rs6000_sched_insert_nops)
1994     {
1995     case sched_finish_regroup_exact:
1996       nop_str = "sched_finish_regroup_exact";
1997       break;
1998
1999     case sched_finish_pad_groups:
2000       nop_str = "sched_finish_pad_groups";
2001       break;
2002
2003     case sched_finish_none:
2004       nop_str = "sched_finish_none";
2005       break;
2006
2007     default:
2008       nop_str = nop_num;
2009       sprintf (nop_num, "%d", (int)rs6000_sched_insert_nops);
2010       break;
2011     }
2012
2013   fprintf (stderr,
2014            "always_hint                     = %s\n"
2015            "align_branch_targets            = %s\n"
2016            "sched_restricted_insns_priority = %d\n"
2017            "sched_costly_dep                = %s\n"
2018            "sched_insert_nops               = %s\n\n",
2019            rs6000_always_hint ? "true" : "false",
2020            rs6000_align_branch_targets ? "true" : "false",
2021            (int)rs6000_sched_restricted_insns_priority,
2022            costly_str, nop_str);
2023 }
2024
2025 /* Initialize the various global tables that are based on register size.  */
2026 static void
2027 rs6000_init_hard_regno_mode_ok (void)
2028 {
2029   int r, m, c;
2030   int align64;
2031   int align32;
2032
2033   /* Precalculate REGNO_REG_CLASS.  */
2034   rs6000_regno_regclass[0] = GENERAL_REGS;
2035   for (r = 1; r < 32; ++r)
2036     rs6000_regno_regclass[r] = BASE_REGS;
2037
2038   for (r = 32; r < 64; ++r)
2039     rs6000_regno_regclass[r] = FLOAT_REGS;
2040
2041   for (r = 64; r < FIRST_PSEUDO_REGISTER; ++r)
2042     rs6000_regno_regclass[r] = NO_REGS;
2043
2044   for (r = FIRST_ALTIVEC_REGNO; r <= LAST_ALTIVEC_REGNO; ++r)
2045     rs6000_regno_regclass[r] = ALTIVEC_REGS;
2046
2047   rs6000_regno_regclass[CR0_REGNO] = CR0_REGS;
2048   for (r = CR1_REGNO; r <= CR7_REGNO; ++r)
2049     rs6000_regno_regclass[r] = CR_REGS;
2050
2051   rs6000_regno_regclass[MQ_REGNO] = MQ_REGS;
2052   rs6000_regno_regclass[LR_REGNO] = LINK_REGS;
2053   rs6000_regno_regclass[CTR_REGNO] = CTR_REGS;
2054   rs6000_regno_regclass[CA_REGNO] = CA_REGS;
2055   rs6000_regno_regclass[VRSAVE_REGNO] = VRSAVE_REGS;
2056   rs6000_regno_regclass[VSCR_REGNO] = VRSAVE_REGS;
2057   rs6000_regno_regclass[SPE_ACC_REGNO] = SPE_ACC_REGS;
2058   rs6000_regno_regclass[SPEFSCR_REGNO] = SPEFSCR_REGS;
2059   rs6000_regno_regclass[ARG_POINTER_REGNUM] = BASE_REGS;
2060   rs6000_regno_regclass[FRAME_POINTER_REGNUM] = BASE_REGS;
2061
2062   /* Precalculate vector information, this must be set up before the
2063      rs6000_hard_regno_nregs_internal below.  */
2064   for (m = 0; m < NUM_MACHINE_MODES; ++m)
2065     {
2066       rs6000_vector_unit[m] = rs6000_vector_mem[m] = VECTOR_NONE;
2067       rs6000_vector_reload[m][0] = CODE_FOR_nothing;
2068       rs6000_vector_reload[m][1] = CODE_FOR_nothing;
2069     }
2070
2071   for (c = 0; c < (int)(int)RS6000_CONSTRAINT_MAX; c++)
2072     rs6000_constraints[c] = NO_REGS;
2073
2074   /* The VSX hardware allows native alignment for vectors, but control whether the compiler
2075      believes it can use native alignment or still uses 128-bit alignment.  */
2076   if (TARGET_VSX && !TARGET_VSX_ALIGN_128)
2077     {
2078       align64 = 64;
2079       align32 = 32;
2080     }
2081   else
2082     {
2083       align64 = 128;
2084       align32 = 128;
2085     }
2086
2087   /* V2DF mode, VSX only.  */
2088   if (TARGET_VSX)
2089     {
2090       rs6000_vector_unit[V2DFmode] = VECTOR_VSX;
2091       rs6000_vector_mem[V2DFmode] = VECTOR_VSX;
2092       rs6000_vector_align[V2DFmode] = align64;
2093     }
2094
2095   /* V4SF mode, either VSX or Altivec.  */
2096   if (TARGET_VSX)
2097     {
2098       rs6000_vector_unit[V4SFmode] = VECTOR_VSX;
2099       rs6000_vector_mem[V4SFmode] = VECTOR_VSX;
2100       rs6000_vector_align[V4SFmode] = align32;
2101     }
2102   else if (TARGET_ALTIVEC)
2103     {
2104       rs6000_vector_unit[V4SFmode] = VECTOR_ALTIVEC;
2105       rs6000_vector_mem[V4SFmode] = VECTOR_ALTIVEC;
2106       rs6000_vector_align[V4SFmode] = align32;
2107     }
2108
2109   /* V16QImode, V8HImode, V4SImode are Altivec only, but possibly do VSX loads
2110      and stores. */
2111   if (TARGET_ALTIVEC)
2112     {
2113       rs6000_vector_unit[V4SImode] = VECTOR_ALTIVEC;
2114       rs6000_vector_unit[V8HImode] = VECTOR_ALTIVEC;
2115       rs6000_vector_unit[V16QImode] = VECTOR_ALTIVEC;
2116       rs6000_vector_align[V4SImode] = align32;
2117       rs6000_vector_align[V8HImode] = align32;
2118       rs6000_vector_align[V16QImode] = align32;
2119
2120       if (TARGET_VSX)
2121         {
2122           rs6000_vector_mem[V4SImode] = VECTOR_VSX;
2123           rs6000_vector_mem[V8HImode] = VECTOR_VSX;
2124           rs6000_vector_mem[V16QImode] = VECTOR_VSX;
2125         }
2126       else
2127         {
2128           rs6000_vector_mem[V4SImode] = VECTOR_ALTIVEC;
2129           rs6000_vector_mem[V8HImode] = VECTOR_ALTIVEC;
2130           rs6000_vector_mem[V16QImode] = VECTOR_ALTIVEC;
2131         }
2132     }
2133
2134   /* V2DImode, only allow under VSX, which can do V2DI insert/splat/extract.
2135      Altivec doesn't have 64-bit support.  */
2136   if (TARGET_VSX)
2137     {
2138       rs6000_vector_mem[V2DImode] = VECTOR_VSX;
2139       rs6000_vector_unit[V2DImode] = VECTOR_NONE;
2140       rs6000_vector_align[V2DImode] = align64;
2141     }
2142
2143   /* DFmode, see if we want to use the VSX unit.  */
2144   if (TARGET_VSX && TARGET_VSX_SCALAR_DOUBLE)
2145     {
2146       rs6000_vector_unit[DFmode] = VECTOR_VSX;
2147       rs6000_vector_mem[DFmode]
2148         = (TARGET_VSX_SCALAR_MEMORY ? VECTOR_VSX : VECTOR_NONE);
2149       rs6000_vector_align[DFmode] = align64;
2150     }
2151
2152   /* TODO add SPE and paired floating point vector support.  */
2153
2154   /* Register class constaints for the constraints that depend on compile
2155      switches.  */
2156   if (TARGET_HARD_FLOAT && TARGET_FPRS)
2157     rs6000_constraints[RS6000_CONSTRAINT_f] = FLOAT_REGS;
2158
2159   if (TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT)
2160     rs6000_constraints[RS6000_CONSTRAINT_d] = FLOAT_REGS;
2161
2162   if (TARGET_VSX)
2163     {
2164       /* At present, we just use VSX_REGS, but we have different constraints
2165          based on the use, in case we want to fine tune the default register
2166          class used.  wa = any VSX register, wf = register class to use for
2167          V4SF, wd = register class to use for V2DF, and ws = register classs to
2168          use for DF scalars.  */
2169       rs6000_constraints[RS6000_CONSTRAINT_wa] = VSX_REGS;
2170       rs6000_constraints[RS6000_CONSTRAINT_wf] = VSX_REGS;
2171       rs6000_constraints[RS6000_CONSTRAINT_wd] = VSX_REGS;
2172       rs6000_constraints[RS6000_CONSTRAINT_ws] = (TARGET_VSX_SCALAR_MEMORY
2173                                                   ? VSX_REGS
2174                                                   : FLOAT_REGS);
2175     }
2176
2177   if (TARGET_ALTIVEC)
2178     rs6000_constraints[RS6000_CONSTRAINT_v] = ALTIVEC_REGS;
2179
2180   /* Set up the reload helper functions.  */
2181   if (TARGET_VSX || TARGET_ALTIVEC)
2182     {
2183       if (TARGET_64BIT)
2184         {
2185           rs6000_vector_reload[V16QImode][0] = CODE_FOR_reload_v16qi_di_store;
2186           rs6000_vector_reload[V16QImode][1] = CODE_FOR_reload_v16qi_di_load;
2187           rs6000_vector_reload[V8HImode][0]  = CODE_FOR_reload_v8hi_di_store;
2188           rs6000_vector_reload[V8HImode][1]  = CODE_FOR_reload_v8hi_di_load;
2189           rs6000_vector_reload[V4SImode][0]  = CODE_FOR_reload_v4si_di_store;
2190           rs6000_vector_reload[V4SImode][1]  = CODE_FOR_reload_v4si_di_load;
2191           rs6000_vector_reload[V2DImode][0]  = CODE_FOR_reload_v2di_di_store;
2192           rs6000_vector_reload[V2DImode][1]  = CODE_FOR_reload_v2di_di_load;
2193           rs6000_vector_reload[V4SFmode][0]  = CODE_FOR_reload_v4sf_di_store;
2194           rs6000_vector_reload[V4SFmode][1]  = CODE_FOR_reload_v4sf_di_load;
2195           rs6000_vector_reload[V2DFmode][0]  = CODE_FOR_reload_v2df_di_store;
2196           rs6000_vector_reload[V2DFmode][1]  = CODE_FOR_reload_v2df_di_load;
2197         }
2198       else
2199         {
2200           rs6000_vector_reload[V16QImode][0] = CODE_FOR_reload_v16qi_si_store;
2201           rs6000_vector_reload[V16QImode][1] = CODE_FOR_reload_v16qi_si_load;
2202           rs6000_vector_reload[V8HImode][0]  = CODE_FOR_reload_v8hi_si_store;
2203           rs6000_vector_reload[V8HImode][1]  = CODE_FOR_reload_v8hi_si_load;
2204           rs6000_vector_reload[V4SImode][0]  = CODE_FOR_reload_v4si_si_store;
2205           rs6000_vector_reload[V4SImode][1]  = CODE_FOR_reload_v4si_si_load;
2206           rs6000_vector_reload[V2DImode][0]  = CODE_FOR_reload_v2di_si_store;
2207           rs6000_vector_reload[V2DImode][1]  = CODE_FOR_reload_v2di_si_load;
2208           rs6000_vector_reload[V4SFmode][0]  = CODE_FOR_reload_v4sf_si_store;
2209           rs6000_vector_reload[V4SFmode][1]  = CODE_FOR_reload_v4sf_si_load;
2210           rs6000_vector_reload[V2DFmode][0]  = CODE_FOR_reload_v2df_si_store;
2211           rs6000_vector_reload[V2DFmode][1]  = CODE_FOR_reload_v2df_si_load;
2212         }
2213     }
2214
2215   /* Precalculate HARD_REGNO_NREGS.  */
2216   for (r = 0; r < FIRST_PSEUDO_REGISTER; ++r)
2217     for (m = 0; m < NUM_MACHINE_MODES; ++m)
2218       rs6000_hard_regno_nregs[m][r]
2219         = rs6000_hard_regno_nregs_internal (r, (enum machine_mode)m);
2220
2221   /* Precalculate HARD_REGNO_MODE_OK.  */
2222   for (r = 0; r < FIRST_PSEUDO_REGISTER; ++r)
2223     for (m = 0; m < NUM_MACHINE_MODES; ++m)
2224       if (rs6000_hard_regno_mode_ok (r, (enum machine_mode)m))
2225         rs6000_hard_regno_mode_ok_p[m][r] = true;
2226
2227   /* Precalculate CLASS_MAX_NREGS sizes.  */
2228   for (c = 0; c < LIM_REG_CLASSES; ++c)
2229     {
2230       int reg_size;
2231
2232       if (TARGET_VSX && VSX_REG_CLASS_P (c))
2233         reg_size = UNITS_PER_VSX_WORD;
2234
2235       else if (c == ALTIVEC_REGS)
2236         reg_size = UNITS_PER_ALTIVEC_WORD;
2237
2238       else if (c == FLOAT_REGS)
2239         reg_size = UNITS_PER_FP_WORD;
2240
2241       else
2242         reg_size = UNITS_PER_WORD;
2243
2244       for (m = 0; m < NUM_MACHINE_MODES; ++m)
2245         rs6000_class_max_nregs[m][c]
2246           = (GET_MODE_SIZE (m) + reg_size - 1) / reg_size;
2247     }
2248
2249   if (TARGET_E500_DOUBLE)
2250     rs6000_class_max_nregs[DFmode][GENERAL_REGS] = 1;
2251
2252   /* Calculate which modes to automatically generate code to use a the
2253      reciprocal divide and square root instructions.  In the future, possibly
2254      automatically generate the instructions even if the user did not specify
2255      -mrecip.  The older machines double precision reciprocal sqrt estimate is
2256      not accurate enough.  */
2257   memset (rs6000_recip_bits, 0, sizeof (rs6000_recip_bits));
2258   if (TARGET_FRES)
2259     rs6000_recip_bits[SFmode] = RS6000_RECIP_MASK_HAVE_RE;
2260   if (TARGET_FRE)
2261     rs6000_recip_bits[DFmode] = RS6000_RECIP_MASK_HAVE_RE;
2262   if (VECTOR_UNIT_ALTIVEC_OR_VSX_P (V4SFmode))
2263     rs6000_recip_bits[V4SFmode] = RS6000_RECIP_MASK_HAVE_RE;
2264   if (VECTOR_UNIT_VSX_P (V2DFmode))
2265     rs6000_recip_bits[V2DFmode] = RS6000_RECIP_MASK_HAVE_RE;
2266
2267   if (TARGET_FRSQRTES)
2268     rs6000_recip_bits[SFmode] |= RS6000_RECIP_MASK_HAVE_RSQRTE;
2269   if (TARGET_FRSQRTE)
2270     rs6000_recip_bits[DFmode] |= RS6000_RECIP_MASK_HAVE_RSQRTE;
2271   if (VECTOR_UNIT_ALTIVEC_OR_VSX_P (V4SFmode))
2272     rs6000_recip_bits[V4SFmode] |= RS6000_RECIP_MASK_HAVE_RSQRTE;
2273   if (VECTOR_UNIT_VSX_P (V2DFmode))
2274     rs6000_recip_bits[V2DFmode] |= RS6000_RECIP_MASK_HAVE_RSQRTE;
2275
2276   if (rs6000_recip_control)
2277     {
2278       if (!TARGET_FUSED_MADD)
2279         warning (0, "-mrecip requires -mfused-madd");
2280       if (!flag_finite_math_only)
2281         warning (0, "-mrecip requires -ffinite-math or -ffast-math");
2282       if (flag_trapping_math)
2283         warning (0, "-mrecip requires -fno-trapping-math or -ffast-math");
2284       if (!flag_reciprocal_math)
2285         warning (0, "-mrecip requires -freciprocal-math or -ffast-math");
2286       if (TARGET_FUSED_MADD && flag_finite_math_only && !flag_trapping_math
2287           && flag_reciprocal_math)
2288         {
2289           if (RS6000_RECIP_HAVE_RE_P (SFmode)
2290               && (rs6000_recip_control & RECIP_SF_DIV) != 0)
2291             rs6000_recip_bits[SFmode] |= RS6000_RECIP_MASK_AUTO_RE;
2292
2293           if (RS6000_RECIP_HAVE_RE_P (DFmode)
2294               && (rs6000_recip_control & RECIP_DF_DIV) != 0)
2295             rs6000_recip_bits[DFmode] |= RS6000_RECIP_MASK_AUTO_RE;
2296
2297           if (RS6000_RECIP_HAVE_RE_P (V4SFmode)
2298               && (rs6000_recip_control & RECIP_V4SF_DIV) != 0)
2299             rs6000_recip_bits[V4SFmode] |= RS6000_RECIP_MASK_AUTO_RE;
2300
2301           if (RS6000_RECIP_HAVE_RE_P (V2DFmode)
2302               && (rs6000_recip_control & RECIP_V2DF_DIV) != 0)
2303             rs6000_recip_bits[V2DFmode] |= RS6000_RECIP_MASK_AUTO_RE;
2304
2305           if (RS6000_RECIP_HAVE_RSQRTE_P (SFmode)
2306               && (rs6000_recip_control & RECIP_SF_RSQRT) != 0)
2307             rs6000_recip_bits[SFmode] |= RS6000_RECIP_MASK_AUTO_RSQRTE;
2308
2309           if (RS6000_RECIP_HAVE_RSQRTE_P (DFmode)
2310               && (rs6000_recip_control & RECIP_DF_RSQRT) != 0)
2311             rs6000_recip_bits[DFmode] |= RS6000_RECIP_MASK_AUTO_RSQRTE;
2312
2313           if (RS6000_RECIP_HAVE_RSQRTE_P (V4SFmode)
2314               && (rs6000_recip_control & RECIP_V4SF_RSQRT) != 0)
2315             rs6000_recip_bits[V4SFmode] |= RS6000_RECIP_MASK_AUTO_RSQRTE;
2316
2317           if (RS6000_RECIP_HAVE_RSQRTE_P (V2DFmode)
2318               && (rs6000_recip_control & RECIP_V2DF_RSQRT) != 0)
2319             rs6000_recip_bits[V2DFmode] |= RS6000_RECIP_MASK_AUTO_RSQRTE;
2320         }
2321     }
2322
2323   if (TARGET_DEBUG_REG)
2324     rs6000_debug_reg_global ();
2325
2326   if (TARGET_DEBUG_COST || TARGET_DEBUG_REG)
2327     fprintf (stderr,
2328              "SImode variable mult cost       = %d\n"
2329              "SImode constant mult cost       = %d\n"
2330              "SImode short constant mult cost = %d\n"
2331              "DImode multipliciation cost     = %d\n"
2332              "SImode division cost            = %d\n"
2333              "DImode division cost            = %d\n"
2334              "Simple fp operation cost        = %d\n"
2335              "DFmode multiplication cost      = %d\n"
2336              "SFmode division cost            = %d\n"
2337              "DFmode division cost            = %d\n"
2338              "cache line size                 = %d\n"
2339              "l1 cache size                   = %d\n"
2340              "l2 cache size                   = %d\n"
2341              "simultaneous prefetches         = %d\n"
2342              "\n",
2343              rs6000_cost->mulsi,
2344              rs6000_cost->mulsi_const,
2345              rs6000_cost->mulsi_const9,
2346              rs6000_cost->muldi,
2347              rs6000_cost->divsi,
2348              rs6000_cost->divdi,
2349              rs6000_cost->fp,
2350              rs6000_cost->dmul,
2351              rs6000_cost->sdiv,
2352              rs6000_cost->ddiv,
2353              rs6000_cost->cache_line_size,
2354              rs6000_cost->l1_cache_size,
2355              rs6000_cost->l2_cache_size,
2356              rs6000_cost->simultaneous_prefetches);
2357 }
2358
2359 #if TARGET_MACHO
2360 /* The Darwin version of SUBTARGET_OVERRIDE_OPTIONS.  */
2361
2362 static void
2363 darwin_rs6000_override_options (void)
2364 {
2365   /* The Darwin ABI always includes AltiVec, can't be (validly) turned
2366      off.  */
2367   rs6000_altivec_abi = 1;
2368   TARGET_ALTIVEC_VRSAVE = 1;
2369   if (DEFAULT_ABI == ABI_DARWIN)
2370   {
2371     if (MACHO_DYNAMIC_NO_PIC_P)
2372       {
2373         if (flag_pic)
2374             warning (0, "-mdynamic-no-pic overrides -fpic or -fPIC");
2375         flag_pic = 0;
2376       }
2377     else if (flag_pic == 1)
2378       {
2379         flag_pic = 2;
2380       }
2381     if (TARGET_64BIT)
2382       darwin_one_byte_bool = 1;
2383   }
2384   if (TARGET_64BIT && ! TARGET_POWERPC64)
2385     {
2386       target_flags |= MASK_POWERPC64;
2387       warning (0, "-m64 requires PowerPC64 architecture, enabling");
2388     }
2389   if (flag_mkernel)
2390     {
2391       rs6000_default_long_calls = 1;
2392       target_flags |= MASK_SOFT_FLOAT;
2393     }
2394
2395   /* Make -m64 imply -maltivec.  Darwin's 64-bit ABI includes
2396      Altivec.  */
2397   if (!flag_mkernel && !flag_apple_kext
2398       && TARGET_64BIT
2399       && ! (target_flags_explicit & MASK_ALTIVEC))
2400     target_flags |= MASK_ALTIVEC;
2401
2402   /* Unless the user (not the configurer) has explicitly overridden
2403      it with -mcpu=G3 or -mno-altivec, then 10.5+ targets default to
2404      G4 unless targetting the kernel.  */
2405   if (!flag_mkernel
2406       && !flag_apple_kext
2407       && strverscmp (darwin_macosx_version_min, "10.5") >= 0
2408       && ! (target_flags_explicit & MASK_ALTIVEC)
2409       && ! rs6000_select[1].string)
2410     {
2411       target_flags |= MASK_ALTIVEC;
2412     }
2413 }
2414 #endif
2415
2416 /* If not otherwise specified by a target, make 'long double' equivalent to
2417    'double'.  */
2418
2419 #ifndef RS6000_DEFAULT_LONG_DOUBLE_SIZE
2420 #define RS6000_DEFAULT_LONG_DOUBLE_SIZE 64
2421 #endif
2422
2423 /* Override command line options.  Mostly we process the processor
2424    type and sometimes adjust other TARGET_ options.  */
2425
2426 static void
2427 rs6000_option_override_internal (const char *default_cpu)
2428 {
2429   size_t i, j;
2430   struct rs6000_cpu_select *ptr;
2431   int set_masks;
2432
2433   /* Simplifications for entries below.  */
2434
2435   enum {
2436     POWERPC_BASE_MASK = MASK_POWERPC | MASK_NEW_MNEMONICS,
2437     POWERPC_7400_MASK = POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_ALTIVEC
2438   };
2439
2440   /* This table occasionally claims that a processor does not support
2441      a particular feature even though it does, but the feature is slower
2442      than the alternative.  Thus, it shouldn't be relied on as a
2443      complete description of the processor's support.
2444
2445      Please keep this list in order, and don't forget to update the
2446      documentation in invoke.texi when adding a new processor or
2447      flag.  */
2448   static struct ptt
2449     {
2450       const char *const name;           /* Canonical processor name.  */
2451       const enum processor_type processor; /* Processor type enum value.  */
2452       const int target_enable;  /* Target flags to enable.  */
2453     } const processor_target_table[]
2454       = {{"401", PROCESSOR_PPC403, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
2455          {"403", PROCESSOR_PPC403,
2456           POWERPC_BASE_MASK | MASK_SOFT_FLOAT | MASK_STRICT_ALIGN},
2457          {"405", PROCESSOR_PPC405,
2458           POWERPC_BASE_MASK | MASK_SOFT_FLOAT | MASK_MULHW | MASK_DLMZB},
2459          {"405fp", PROCESSOR_PPC405,
2460           POWERPC_BASE_MASK | MASK_MULHW | MASK_DLMZB},
2461          {"440", PROCESSOR_PPC440,
2462           POWERPC_BASE_MASK | MASK_SOFT_FLOAT | MASK_MULHW | MASK_DLMZB},
2463          {"440fp", PROCESSOR_PPC440,
2464           POWERPC_BASE_MASK | MASK_MULHW | MASK_DLMZB},
2465          {"464", PROCESSOR_PPC440,
2466           POWERPC_BASE_MASK | MASK_SOFT_FLOAT | MASK_MULHW | MASK_DLMZB},
2467          {"464fp", PROCESSOR_PPC440,
2468           POWERPC_BASE_MASK | MASK_MULHW | MASK_DLMZB},
2469          {"476", PROCESSOR_PPC476,
2470           POWERPC_BASE_MASK | MASK_SOFT_FLOAT | MASK_PPC_GFXOPT | MASK_MFCRF
2471           | MASK_POPCNTB | MASK_FPRND | MASK_CMPB | MASK_MULHW | MASK_DLMZB},
2472          {"476fp", PROCESSOR_PPC476,
2473           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_MFCRF | MASK_POPCNTB
2474           | MASK_FPRND | MASK_CMPB | MASK_MULHW | MASK_DLMZB},
2475          {"505", PROCESSOR_MPCCORE, POWERPC_BASE_MASK},
2476          {"601", PROCESSOR_PPC601,
2477           MASK_POWER | POWERPC_BASE_MASK | MASK_MULTIPLE | MASK_STRING},
2478          {"602", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
2479          {"603", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
2480          {"603e", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
2481          {"604", PROCESSOR_PPC604, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
2482          {"604e", PROCESSOR_PPC604e, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
2483          {"620", PROCESSOR_PPC620,
2484           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
2485          {"630", PROCESSOR_PPC630,
2486           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
2487          {"740", PROCESSOR_PPC750, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
2488          {"7400", PROCESSOR_PPC7400, POWERPC_7400_MASK},
2489          {"7450", PROCESSOR_PPC7450, POWERPC_7400_MASK},
2490          {"750", PROCESSOR_PPC750, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
2491          {"801", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
2492          {"821", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
2493          {"823", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
2494          {"8540", PROCESSOR_PPC8540, POWERPC_BASE_MASK | MASK_STRICT_ALIGN
2495           | MASK_ISEL},
2496          /* 8548 has a dummy entry for now.  */
2497          {"8548", PROCESSOR_PPC8540, POWERPC_BASE_MASK | MASK_STRICT_ALIGN
2498           | MASK_ISEL},
2499          {"a2", PROCESSOR_PPCA2,
2500           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64 | MASK_POPCNTB
2501           | MASK_CMPB | MASK_NO_UPDATE },
2502          {"e300c2", PROCESSOR_PPCE300C2, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
2503          {"e300c3", PROCESSOR_PPCE300C3, POWERPC_BASE_MASK},
2504          {"e500mc", PROCESSOR_PPCE500MC, POWERPC_BASE_MASK | MASK_PPC_GFXOPT
2505           | MASK_ISEL},
2506          {"e500mc64", PROCESSOR_PPCE500MC64, POWERPC_BASE_MASK | MASK_POWERPC64
2507           | MASK_PPC_GFXOPT | MASK_ISEL},
2508          {"860", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
2509          {"970", PROCESSOR_POWER4,
2510           POWERPC_7400_MASK | MASK_PPC_GPOPT | MASK_MFCRF | MASK_POWERPC64},
2511          {"cell", PROCESSOR_CELL,
2512           POWERPC_7400_MASK  | MASK_PPC_GPOPT | MASK_MFCRF | MASK_POWERPC64},
2513          {"common", PROCESSOR_COMMON, MASK_NEW_MNEMONICS},
2514          {"ec603e", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
2515          {"G3", PROCESSOR_PPC750, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
2516          {"G4",  PROCESSOR_PPC7450, POWERPC_7400_MASK},
2517          {"G5", PROCESSOR_POWER4,
2518           POWERPC_7400_MASK | MASK_PPC_GPOPT | MASK_MFCRF | MASK_POWERPC64},
2519          {"titan", PROCESSOR_TITAN,
2520           POWERPC_BASE_MASK | MASK_MULHW | MASK_DLMZB},
2521          {"power", PROCESSOR_POWER, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
2522          {"power2", PROCESSOR_POWER,
2523           MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING},
2524          {"power3", PROCESSOR_PPC630,
2525           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
2526          {"power4", PROCESSOR_POWER4,
2527           POWERPC_BASE_MASK | MASK_POWERPC64 | MASK_PPC_GPOPT | MASK_PPC_GFXOPT
2528           | MASK_MFCRF},
2529          {"power5", PROCESSOR_POWER5,
2530           POWERPC_BASE_MASK | MASK_POWERPC64 | MASK_PPC_GPOPT | MASK_PPC_GFXOPT
2531           | MASK_MFCRF | MASK_POPCNTB},
2532          {"power5+", PROCESSOR_POWER5,
2533           POWERPC_BASE_MASK | MASK_POWERPC64 | MASK_PPC_GPOPT | MASK_PPC_GFXOPT
2534           | MASK_MFCRF | MASK_POPCNTB | MASK_FPRND},
2535          {"power6", PROCESSOR_POWER6,
2536           POWERPC_BASE_MASK | MASK_POWERPC64 | MASK_PPC_GPOPT | MASK_PPC_GFXOPT
2537           | MASK_MFCRF | MASK_POPCNTB | MASK_FPRND | MASK_CMPB | MASK_DFP
2538           | MASK_RECIP_PRECISION},
2539          {"power6x", PROCESSOR_POWER6,
2540           POWERPC_BASE_MASK | MASK_POWERPC64 | MASK_PPC_GPOPT | MASK_PPC_GFXOPT
2541           | MASK_MFCRF | MASK_POPCNTB | MASK_FPRND | MASK_CMPB | MASK_DFP
2542           | MASK_MFPGPR | MASK_RECIP_PRECISION},
2543          {"power7", PROCESSOR_POWER7,   /* Don't add MASK_ISEL by default */
2544           POWERPC_7400_MASK | MASK_POWERPC64 | MASK_PPC_GPOPT | MASK_MFCRF
2545           | MASK_POPCNTB | MASK_FPRND | MASK_CMPB | MASK_DFP | MASK_POPCNTD
2546           | MASK_VSX | MASK_RECIP_PRECISION},
2547          {"powerpc", PROCESSOR_POWERPC, POWERPC_BASE_MASK},
2548          {"powerpc64", PROCESSOR_POWERPC64,
2549           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
2550          {"rios", PROCESSOR_RIOS1, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
2551          {"rios1", PROCESSOR_RIOS1, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
2552          {"rios2", PROCESSOR_RIOS2,
2553           MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING},
2554          {"rsc", PROCESSOR_PPC601, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
2555          {"rsc1", PROCESSOR_PPC601, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
2556          {"rs64", PROCESSOR_RS64A,
2557           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64}
2558       };
2559
2560   const size_t ptt_size = ARRAY_SIZE (processor_target_table);
2561
2562   /* Some OSs don't support saving the high part of 64-bit registers on
2563      context switch.  Other OSs don't support saving Altivec registers.
2564      On those OSs, we don't touch the MASK_POWERPC64 or MASK_ALTIVEC
2565      settings; if the user wants either, the user must explicitly specify
2566      them and we won't interfere with the user's specification.  */
2567
2568   enum {
2569     POWER_MASKS = MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING,
2570     POWERPC_MASKS = (POWERPC_BASE_MASK | MASK_PPC_GPOPT | MASK_STRICT_ALIGN
2571                      | MASK_PPC_GFXOPT | MASK_POWERPC64 | MASK_ALTIVEC
2572                      | MASK_MFCRF | MASK_POPCNTB | MASK_FPRND | MASK_MULHW
2573                      | MASK_DLMZB | MASK_CMPB | MASK_MFPGPR | MASK_DFP
2574                      | MASK_POPCNTD | MASK_VSX | MASK_ISEL | MASK_NO_UPDATE
2575                      | MASK_RECIP_PRECISION)
2576   };
2577
2578   /* Masks for instructions set at various powerpc ISAs.  */
2579   enum {
2580     ISA_2_1_MASKS = MASK_MFCRF,
2581     ISA_2_2_MASKS = (ISA_2_1_MASKS | MASK_POPCNTB | MASK_FPRND),
2582
2583     /* For ISA 2.05, do not add MFPGPR, since it isn't in ISA 2.06, and don't
2584        add ALTIVEC, since in general it isn't a win on power6.  In ISA 2.04,
2585        fsel, fre, fsqrt, etc. were no longer documented as optional.  Group
2586        masks by server and embedded. */
2587     ISA_2_5_MASKS_EMBEDDED = (ISA_2_2_MASKS | MASK_CMPB | MASK_RECIP_PRECISION
2588                               | MASK_PPC_GFXOPT | MASK_PPC_GPOPT),
2589     ISA_2_5_MASKS_SERVER = (ISA_2_5_MASKS_EMBEDDED | MASK_DFP),
2590
2591     /* For ISA 2.06, don't add ISEL, since in general it isn't a win, but
2592        altivec is a win so enable it.  */
2593     ISA_2_6_MASKS_EMBEDDED = (ISA_2_5_MASKS_EMBEDDED | MASK_POPCNTD),
2594     ISA_2_6_MASKS_SERVER = (ISA_2_5_MASKS_SERVER | MASK_POPCNTD | MASK_ALTIVEC
2595                             | MASK_VSX)
2596   };
2597
2598   /* Numerous experiment shows that IRA based loop pressure
2599      calculation works better for RTL loop invariant motion on targets
2600      with enough (>= 32) registers.  It is an expensive optimization.
2601      So it is on only for peak performance.  */
2602   if (optimize >= 3)
2603     flag_ira_loop_pressure = 1;
2604
2605   /* Set the pointer size.  */
2606   if (TARGET_64BIT)
2607     {
2608       rs6000_pmode = (int)DImode;
2609       rs6000_pointer_size = 64;
2610     }
2611   else
2612     {
2613       rs6000_pmode = (int)SImode;
2614       rs6000_pointer_size = 32;
2615     }
2616
2617   set_masks = POWER_MASKS | POWERPC_MASKS | MASK_SOFT_FLOAT;
2618 #ifdef OS_MISSING_POWERPC64
2619   if (OS_MISSING_POWERPC64)
2620     set_masks &= ~MASK_POWERPC64;
2621 #endif
2622 #ifdef OS_MISSING_ALTIVEC
2623   if (OS_MISSING_ALTIVEC)
2624     set_masks &= ~MASK_ALTIVEC;
2625 #endif
2626
2627   /* Don't override by the processor default if given explicitly.  */
2628   set_masks &= ~target_flags_explicit;
2629
2630   /* Identify the processor type.  */
2631   rs6000_select[0].string = default_cpu;
2632   rs6000_cpu = TARGET_POWERPC64 ? PROCESSOR_DEFAULT64 : PROCESSOR_DEFAULT;
2633
2634   for (i = 0; i < ARRAY_SIZE (rs6000_select); i++)
2635     {
2636       ptr = &rs6000_select[i];
2637       if (ptr->string != (char *)0 && ptr->string[0] != '\0')
2638         {
2639           for (j = 0; j < ptt_size; j++)
2640             if (! strcmp (ptr->string, processor_target_table[j].name))
2641               {
2642                 if (ptr->set_tune_p)
2643                   rs6000_cpu = processor_target_table[j].processor;
2644
2645                 if (ptr->set_arch_p)
2646                   {
2647                     target_flags &= ~set_masks;
2648                     target_flags |= (processor_target_table[j].target_enable
2649                                      & set_masks);
2650                   }
2651                 break;
2652               }
2653
2654           if (j == ptt_size)
2655             error ("bad value (%s) for %s switch", ptr->string, ptr->name);
2656         }
2657     }
2658
2659   if (rs6000_cpu == PROCESSOR_PPCE300C2 || rs6000_cpu == PROCESSOR_PPCE300C3
2660       || rs6000_cpu == PROCESSOR_PPCE500MC || rs6000_cpu == PROCESSOR_PPCE500MC64)
2661     {
2662       if (TARGET_ALTIVEC)
2663         error ("AltiVec not supported in this target");
2664       if (TARGET_SPE)
2665         error ("Spe not supported in this target");
2666     }
2667
2668   /* Disable Cell microcode if we are optimizing for the Cell
2669      and not optimizing for size.  */
2670   if (rs6000_gen_cell_microcode == -1)
2671     rs6000_gen_cell_microcode = !(rs6000_cpu == PROCESSOR_CELL
2672                                   && !optimize_size);
2673
2674   /* If we are optimizing big endian systems for space and it's OK to
2675      use instructions that would be microcoded on the Cell, use the
2676      load/store multiple and string instructions.  */
2677   if (BYTES_BIG_ENDIAN && optimize_size && rs6000_gen_cell_microcode)
2678     target_flags |= ~target_flags_explicit & (MASK_MULTIPLE | MASK_STRING);
2679
2680   /* Don't allow -mmultiple or -mstring on little endian systems
2681      unless the cpu is a 750, because the hardware doesn't support the
2682      instructions used in little endian mode, and causes an alignment
2683      trap.  The 750 does not cause an alignment trap (except when the
2684      target is unaligned).  */
2685
2686   if (!BYTES_BIG_ENDIAN && rs6000_cpu != PROCESSOR_PPC750)
2687     {
2688       if (TARGET_MULTIPLE)
2689         {
2690           target_flags &= ~MASK_MULTIPLE;
2691           if ((target_flags_explicit & MASK_MULTIPLE) != 0)
2692             warning (0, "-mmultiple is not supported on little endian systems");
2693         }
2694
2695       if (TARGET_STRING)
2696         {
2697           target_flags &= ~MASK_STRING;
2698           if ((target_flags_explicit & MASK_STRING) != 0)
2699             warning (0, "-mstring is not supported on little endian systems");
2700         }
2701     }
2702
2703   /* Add some warnings for VSX.  */
2704   if (TARGET_VSX)
2705     {
2706       const char *msg = NULL;
2707       if (!TARGET_HARD_FLOAT || !TARGET_FPRS
2708           || !TARGET_SINGLE_FLOAT || !TARGET_DOUBLE_FLOAT)
2709         {
2710           if (target_flags_explicit & MASK_VSX)
2711             msg = N_("-mvsx requires hardware floating point");
2712           else
2713             target_flags &= ~ MASK_VSX;
2714         }
2715       else if (TARGET_PAIRED_FLOAT)
2716         msg = N_("-mvsx and -mpaired are incompatible");
2717       /* The hardware will allow VSX and little endian, but until we make sure
2718          things like vector select, etc. work don't allow VSX on little endian
2719          systems at this point.  */
2720       else if (!BYTES_BIG_ENDIAN)
2721         msg = N_("-mvsx used with little endian code");
2722       else if (TARGET_AVOID_XFORM > 0)
2723         msg = N_("-mvsx needs indexed addressing");
2724       else if (!TARGET_ALTIVEC && (target_flags_explicit & MASK_ALTIVEC))
2725         {
2726           if (target_flags_explicit & MASK_VSX)
2727             msg = N_("-mvsx and -mno-altivec are incompatible");
2728           else
2729             msg = N_("-mno-altivec disables vsx");
2730         }
2731
2732       if (msg)
2733         {
2734           warning (0, msg);
2735           target_flags &= ~ MASK_VSX;
2736           target_flags_explicit |= MASK_VSX;
2737         }
2738     }
2739
2740   /* For the newer switches (vsx, dfp, etc.) set some of the older options,
2741      unless the user explicitly used the -mno-<option> to disable the code.  */
2742   if (TARGET_VSX)
2743     target_flags |= (ISA_2_6_MASKS_SERVER & ~target_flags_explicit);
2744   else if (TARGET_POPCNTD)
2745     target_flags |= (ISA_2_6_MASKS_EMBEDDED & ~target_flags_explicit);
2746   else if (TARGET_DFP)
2747     target_flags |= (ISA_2_5_MASKS_SERVER & ~target_flags_explicit);
2748   else if (TARGET_CMPB)
2749     target_flags |= (ISA_2_5_MASKS_EMBEDDED & ~target_flags_explicit);
2750   else if (TARGET_POPCNTB || TARGET_FPRND)
2751     target_flags |= (ISA_2_2_MASKS & ~target_flags_explicit);
2752   else if (TARGET_ALTIVEC)
2753     target_flags |= (MASK_PPC_GFXOPT & ~target_flags_explicit);
2754
2755   /* E500mc does "better" if we inline more aggressively.  Respect the
2756      user's opinion, though.  */
2757   if (rs6000_block_move_inline_limit == 0
2758       && (rs6000_cpu == PROCESSOR_PPCE500MC
2759           || rs6000_cpu == PROCESSOR_PPCE500MC64))
2760     rs6000_block_move_inline_limit = 128;
2761
2762   /* store_one_arg depends on expand_block_move to handle at least the
2763      size of reg_parm_stack_space.  */
2764   if (rs6000_block_move_inline_limit < (TARGET_POWERPC64 ? 64 : 32))
2765     rs6000_block_move_inline_limit = (TARGET_POWERPC64 ? 64 : 32);
2766
2767   /* Set debug flags */
2768   if (rs6000_debug_name)
2769     {
2770       if (! strcmp (rs6000_debug_name, "all"))
2771         rs6000_debug_stack = rs6000_debug_arg = rs6000_debug_reg
2772           = rs6000_debug_addr = rs6000_debug_cost = 1;
2773       else if (! strcmp (rs6000_debug_name, "stack"))
2774         rs6000_debug_stack = 1;
2775       else if (! strcmp (rs6000_debug_name, "arg"))
2776         rs6000_debug_arg = 1;
2777       else if (! strcmp (rs6000_debug_name, "reg"))
2778         rs6000_debug_reg = 1;
2779       else if (! strcmp (rs6000_debug_name, "addr"))
2780         rs6000_debug_addr = 1;
2781       else if (! strcmp (rs6000_debug_name, "cost"))
2782         rs6000_debug_cost = 1;
2783       else
2784         error ("unknown -mdebug-%s switch", rs6000_debug_name);
2785
2786       /* If the appropriate debug option is enabled, replace the target hooks
2787          with debug versions that call the real version and then prints
2788          debugging information.  */
2789       if (TARGET_DEBUG_COST)
2790         {
2791           targetm.rtx_costs = rs6000_debug_rtx_costs;
2792           targetm.address_cost = rs6000_debug_address_cost;
2793           targetm.sched.adjust_cost = rs6000_debug_adjust_cost;
2794         }
2795
2796       if (TARGET_DEBUG_ADDR)
2797         {
2798           targetm.legitimate_address_p = rs6000_debug_legitimate_address_p;
2799           targetm.legitimize_address = rs6000_debug_legitimize_address;
2800           rs6000_secondary_reload_class_ptr
2801             = rs6000_debug_secondary_reload_class;
2802           rs6000_secondary_memory_needed_ptr
2803             = rs6000_debug_secondary_memory_needed;
2804           rs6000_cannot_change_mode_class_ptr
2805             = rs6000_debug_cannot_change_mode_class;
2806           rs6000_preferred_reload_class_ptr
2807             = rs6000_debug_preferred_reload_class;
2808           rs6000_legitimize_reload_address_ptr
2809             = rs6000_debug_legitimize_reload_address;
2810           rs6000_mode_dependent_address_ptr
2811             = rs6000_debug_mode_dependent_address;
2812         }
2813     }
2814
2815   if (rs6000_traceback_name)
2816     {
2817       if (! strncmp (rs6000_traceback_name, "full", 4))
2818         rs6000_traceback = traceback_full;
2819       else if (! strncmp (rs6000_traceback_name, "part", 4))
2820         rs6000_traceback = traceback_part;
2821       else if (! strncmp (rs6000_traceback_name, "no", 2))
2822         rs6000_traceback = traceback_none;
2823       else
2824         error ("unknown -mtraceback arg %qs; expecting %<full%>, %<partial%> or %<none%>",
2825                rs6000_traceback_name);
2826     }
2827
2828   if (rs6000_veclibabi_name)
2829     {
2830       if (strcmp (rs6000_veclibabi_name, "mass") == 0)
2831         rs6000_veclib_handler = rs6000_builtin_vectorized_libmass;
2832       else
2833         error ("unknown vectorization library ABI type (%s) for "
2834                "-mveclibabi= switch", rs6000_veclibabi_name);
2835     }
2836
2837   if (!rs6000_explicit_options.long_double)
2838     rs6000_long_double_type_size = RS6000_DEFAULT_LONG_DOUBLE_SIZE;
2839
2840 #ifndef POWERPC_LINUX
2841   if (!rs6000_explicit_options.ieee)
2842     rs6000_ieeequad = 1;
2843 #endif
2844
2845   /* Enable Altivec ABI for AIX -maltivec.  */
2846   if (TARGET_XCOFF && (TARGET_ALTIVEC || TARGET_VSX))
2847     rs6000_altivec_abi = 1;
2848
2849   /* The AltiVec ABI is the default for PowerPC-64 GNU/Linux.  For
2850      PowerPC-32 GNU/Linux, -maltivec implies the AltiVec ABI.  It can
2851      be explicitly overridden in either case.  */
2852   if (TARGET_ELF)
2853     {
2854       if (!rs6000_explicit_options.altivec_abi
2855           && (TARGET_64BIT || TARGET_ALTIVEC || TARGET_VSX))
2856         rs6000_altivec_abi = 1;
2857
2858       /* Enable VRSAVE for AltiVec ABI, unless explicitly overridden.  */
2859       if (!rs6000_explicit_options.vrsave)
2860         TARGET_ALTIVEC_VRSAVE = rs6000_altivec_abi;
2861     }
2862
2863   /* Set the Darwin64 ABI as default for 64-bit Darwin.  
2864      So far, the only darwin64 targets are also MACH-O.  */
2865   if (TARGET_MACHO
2866       && DEFAULT_ABI == ABI_DARWIN 
2867       && TARGET_64BIT)
2868     {
2869       rs6000_darwin64_abi = 1;
2870       /* Default to natural alignment, for better performance.  */
2871       rs6000_alignment_flags = MASK_ALIGN_NATURAL;
2872     }
2873
2874   /* Place FP constants in the constant pool instead of TOC
2875      if section anchors enabled.  */
2876   if (flag_section_anchors)
2877     TARGET_NO_FP_IN_TOC = 1;
2878
2879   /* Handle -mtls-size option.  */
2880   rs6000_parse_tls_size_option ();
2881
2882 #ifdef SUBTARGET_OVERRIDE_OPTIONS
2883   SUBTARGET_OVERRIDE_OPTIONS;
2884 #endif
2885 #ifdef SUBSUBTARGET_OVERRIDE_OPTIONS
2886   SUBSUBTARGET_OVERRIDE_OPTIONS;
2887 #endif
2888 #ifdef SUB3TARGET_OVERRIDE_OPTIONS
2889   SUB3TARGET_OVERRIDE_OPTIONS;
2890 #endif
2891
2892   if (TARGET_E500 || rs6000_cpu == PROCESSOR_PPCE500MC
2893       || rs6000_cpu == PROCESSOR_PPCE500MC64)
2894     {
2895       /* The e500 and e500mc do not have string instructions, and we set
2896          MASK_STRING above when optimizing for size.  */
2897       if ((target_flags & MASK_STRING) != 0)
2898         target_flags = target_flags & ~MASK_STRING;
2899     }
2900   else if (rs6000_select[1].string != NULL)
2901     {
2902       /* For the powerpc-eabispe configuration, we set all these by
2903          default, so let's unset them if we manually set another
2904          CPU that is not the E500.  */
2905       if (!rs6000_explicit_options.spe_abi)
2906         rs6000_spe_abi = 0;
2907       if (!rs6000_explicit_options.spe)
2908         rs6000_spe = 0;
2909       if (!rs6000_explicit_options.float_gprs)
2910         rs6000_float_gprs = 0;
2911       if (!(target_flags_explicit & MASK_ISEL))
2912         target_flags &= ~MASK_ISEL;
2913     }
2914
2915   /* Detect invalid option combinations with E500.  */
2916   CHECK_E500_OPTIONS;
2917
2918   rs6000_always_hint = (rs6000_cpu != PROCESSOR_POWER4
2919                         && rs6000_cpu != PROCESSOR_POWER5
2920                         && rs6000_cpu != PROCESSOR_POWER6
2921                         && rs6000_cpu != PROCESSOR_POWER7
2922                         && rs6000_cpu != PROCESSOR_PPCA2
2923                         && rs6000_cpu != PROCESSOR_CELL);
2924   rs6000_sched_groups = (rs6000_cpu == PROCESSOR_POWER4
2925                          || rs6000_cpu == PROCESSOR_POWER5
2926                          || rs6000_cpu == PROCESSOR_POWER7);
2927   rs6000_align_branch_targets = (rs6000_cpu == PROCESSOR_POWER4
2928                                  || rs6000_cpu == PROCESSOR_POWER5
2929                                  || rs6000_cpu == PROCESSOR_POWER6
2930                                  || rs6000_cpu == PROCESSOR_POWER7
2931                                  || rs6000_cpu == PROCESSOR_PPCE500MC
2932                                  || rs6000_cpu == PROCESSOR_PPCE500MC64);
2933
2934   /* Allow debug switches to override the above settings.  */
2935   if (TARGET_ALWAYS_HINT > 0)
2936     rs6000_always_hint = TARGET_ALWAYS_HINT;
2937
2938   if (TARGET_SCHED_GROUPS > 0)
2939     rs6000_sched_groups = TARGET_SCHED_GROUPS;
2940
2941   if (TARGET_ALIGN_BRANCH_TARGETS > 0)
2942     rs6000_align_branch_targets = TARGET_ALIGN_BRANCH_TARGETS;
2943
2944   rs6000_sched_restricted_insns_priority
2945     = (rs6000_sched_groups ? 1 : 0);
2946
2947   /* Handle -msched-costly-dep option.  */
2948   rs6000_sched_costly_dep
2949     = (rs6000_sched_groups ? store_to_load_dep_costly : no_dep_costly);
2950
2951   if (rs6000_sched_costly_dep_str)
2952     {
2953       if (! strcmp (rs6000_sched_costly_dep_str, "no"))
2954         rs6000_sched_costly_dep = no_dep_costly;
2955       else if (! strcmp (rs6000_sched_costly_dep_str, "all"))
2956         rs6000_sched_costly_dep = all_deps_costly;
2957       else if (! strcmp (rs6000_sched_costly_dep_str, "true_store_to_load"))
2958         rs6000_sched_costly_dep = true_store_to_load_dep_costly;
2959       else if (! strcmp (rs6000_sched_costly_dep_str, "store_to_load"))
2960         rs6000_sched_costly_dep = store_to_load_dep_costly;
2961       else
2962         rs6000_sched_costly_dep = ((enum rs6000_dependence_cost)
2963                                    atoi (rs6000_sched_costly_dep_str));
2964     }
2965
2966   /* Handle -minsert-sched-nops option.  */
2967   rs6000_sched_insert_nops
2968     = (rs6000_sched_groups ? sched_finish_regroup_exact : sched_finish_none);
2969
2970   if (rs6000_sched_insert_nops_str)
2971     {
2972       if (! strcmp (rs6000_sched_insert_nops_str, "no"))
2973         rs6000_sched_insert_nops = sched_finish_none;
2974       else if (! strcmp (rs6000_sched_insert_nops_str, "pad"))
2975         rs6000_sched_insert_nops = sched_finish_pad_groups;
2976       else if (! strcmp (rs6000_sched_insert_nops_str, "regroup_exact"))
2977         rs6000_sched_insert_nops = sched_finish_regroup_exact;
2978       else
2979         rs6000_sched_insert_nops = ((enum rs6000_nop_insertion)
2980                                     atoi (rs6000_sched_insert_nops_str));
2981     }
2982
2983 #ifdef TARGET_REGNAMES
2984   /* If the user desires alternate register names, copy in the
2985      alternate names now.  */
2986   if (TARGET_REGNAMES)
2987     memcpy (rs6000_reg_names, alt_reg_names, sizeof (rs6000_reg_names));
2988 #endif
2989
2990   /* Set aix_struct_return last, after the ABI is determined.
2991      If -maix-struct-return or -msvr4-struct-return was explicitly
2992      used, don't override with the ABI default.  */
2993   if (!rs6000_explicit_options.aix_struct_ret)
2994     aix_struct_return = (DEFAULT_ABI != ABI_V4 || DRAFT_V4_STRUCT_RET);
2995
2996 #if 0
2997   /* IBM XL compiler defaults to unsigned bitfields.  */
2998   if (TARGET_XL_COMPAT)
2999     flag_signed_bitfields = 0;
3000 #endif
3001
3002   if (TARGET_LONG_DOUBLE_128 && !TARGET_IEEEQUAD)
3003     REAL_MODE_FORMAT (TFmode) = &ibm_extended_format;
3004
3005   if (TARGET_TOC)
3006     ASM_GENERATE_INTERNAL_LABEL (toc_label_name, "LCTOC", 1);
3007
3008   /* We can only guarantee the availability of DI pseudo-ops when
3009      assembling for 64-bit targets.  */
3010   if (!TARGET_64BIT)
3011     {
3012       targetm.asm_out.aligned_op.di = NULL;
3013       targetm.asm_out.unaligned_op.di = NULL;
3014     }
3015
3016   /* Set branch target alignment, if not optimizing for size.  */
3017   if (!optimize_size)
3018     {
3019       /* Cell wants to be aligned 8byte for dual issue.  Titan wants to be
3020          aligned 8byte to avoid misprediction by the branch predictor.  */
3021       if (rs6000_cpu == PROCESSOR_TITAN
3022           || rs6000_cpu == PROCESSOR_CELL)
3023         {
3024           if (align_functions <= 0)
3025             align_functions = 8;
3026           if (align_jumps <= 0)
3027             align_jumps = 8;
3028           if (align_loops <= 0)
3029             align_loops = 8;
3030         }
3031       if (rs6000_align_branch_targets)
3032         {
3033           if (align_functions <= 0)
3034             align_functions = 16;
3035           if (align_jumps <= 0)
3036             align_jumps = 16;
3037           if (align_loops <= 0)
3038             align_loops = 16;
3039         }
3040       if (align_jumps_max_skip <= 0)
3041         align_jumps_max_skip = 15;
3042       if (align_loops_max_skip <= 0)
3043         align_loops_max_skip = 15;
3044     }
3045
3046   /* Arrange to save and restore machine status around nested functions.  */
3047   init_machine_status = rs6000_init_machine_status;
3048
3049   /* We should always be splitting complex arguments, but we can't break
3050      Linux and Darwin ABIs at the moment.  For now, only AIX is fixed.  */
3051   if (DEFAULT_ABI != ABI_AIX)
3052     targetm.calls.split_complex_arg = NULL;
3053
3054   /* Initialize rs6000_cost with the appropriate target costs.  */
3055   if (optimize_size)
3056     rs6000_cost = TARGET_POWERPC64 ? &size64_cost : &size32_cost;
3057   else
3058     switch (rs6000_cpu)
3059       {
3060       case PROCESSOR_RIOS1:
3061         rs6000_cost = &rios1_cost;
3062         break;
3063
3064       case PROCESSOR_RIOS2:
3065         rs6000_cost = &rios2_cost;
3066         break;
3067
3068       case PROCESSOR_RS64A:
3069         rs6000_cost = &rs64a_cost;
3070         break;
3071
3072       case PROCESSOR_MPCCORE:
3073         rs6000_cost = &mpccore_cost;
3074         break;
3075
3076       case PROCESSOR_PPC403:
3077         rs6000_cost = &ppc403_cost;
3078         break;
3079
3080       case PROCESSOR_PPC405:
3081         rs6000_cost = &ppc405_cost;
3082         break;
3083
3084       case PROCESSOR_PPC440:
3085         rs6000_cost = &ppc440_cost;
3086         break;
3087
3088       case PROCESSOR_PPC476:
3089         rs6000_cost = &ppc476_cost;
3090         break;
3091
3092       case PROCESSOR_PPC601:
3093         rs6000_cost = &ppc601_cost;
3094         break;
3095
3096       case PROCESSOR_PPC603:
3097         rs6000_cost = &ppc603_cost;
3098         break;
3099
3100       case PROCESSOR_PPC604:
3101         rs6000_cost = &ppc604_cost;
3102         break;
3103
3104       case PROCESSOR_PPC604e:
3105         rs6000_cost = &ppc604e_cost;
3106         break;
3107
3108       case PROCESSOR_PPC620:
3109         rs6000_cost = &ppc620_cost;
3110         break;
3111
3112       case PROCESSOR_PPC630:
3113         rs6000_cost = &ppc630_cost;
3114         break;
3115
3116       case PROCESSOR_CELL:
3117         rs6000_cost = &ppccell_cost;
3118         break;
3119
3120       case PROCESSOR_PPC750:
3121       case PROCESSOR_PPC7400:
3122         rs6000_cost = &ppc750_cost;
3123         break;
3124
3125       case PROCESSOR_PPC7450:
3126         rs6000_cost = &ppc7450_cost;
3127         break;
3128
3129       case PROCESSOR_PPC8540:
3130         rs6000_cost = &ppc8540_cost;
3131         break;
3132
3133       case PROCESSOR_PPCE300C2:
3134       case PROCESSOR_PPCE300C3:
3135         rs6000_cost = &ppce300c2c3_cost;
3136         break;
3137
3138       case PROCESSOR_PPCE500MC:
3139         rs6000_cost = &ppce500mc_cost;
3140         break;
3141
3142       case PROCESSOR_PPCE500MC64:
3143         rs6000_cost = &ppce500mc64_cost;
3144         break;
3145
3146       case PROCESSOR_TITAN:
3147         rs6000_cost = &titan_cost;
3148         break;
3149
3150       case PROCESSOR_POWER4:
3151       case PROCESSOR_POWER5:
3152         rs6000_cost = &power4_cost;
3153         break;
3154
3155       case PROCESSOR_POWER6:
3156         rs6000_cost = &power6_cost;
3157         break;
3158
3159       case PROCESSOR_POWER7:
3160         rs6000_cost = &power7_cost;
3161         break;
3162
3163       case PROCESSOR_PPCA2:
3164         rs6000_cost = &ppca2_cost;
3165         break;
3166
3167       default:
3168         gcc_unreachable ();
3169       }
3170
3171   maybe_set_param_value (PARAM_SIMULTANEOUS_PREFETCHES,
3172                          rs6000_cost->simultaneous_prefetches,
3173                          global_options.x_param_values,
3174                          global_options_set.x_param_values);
3175   maybe_set_param_value (PARAM_L1_CACHE_SIZE, rs6000_cost->l1_cache_size,
3176                          global_options.x_param_values,
3177                          global_options_set.x_param_values);
3178   maybe_set_param_value (PARAM_L1_CACHE_LINE_SIZE,
3179                          rs6000_cost->cache_line_size,
3180                          global_options.x_param_values,
3181                          global_options_set.x_param_values);
3182   maybe_set_param_value (PARAM_L2_CACHE_SIZE, rs6000_cost->l2_cache_size,
3183                          global_options.x_param_values,
3184                          global_options_set.x_param_values);
3185
3186   /* If using typedef char *va_list, signal that __builtin_va_start (&ap, 0)
3187      can be optimized to ap = __builtin_next_arg (0).  */
3188   if (DEFAULT_ABI != ABI_V4)
3189     targetm.expand_builtin_va_start = NULL;
3190
3191   /* Set up single/double float flags.  
3192      If TARGET_HARD_FLOAT is set, but neither single or double is set, 
3193      then set both flags. */
3194   if (TARGET_HARD_FLOAT && TARGET_FPRS 
3195       && rs6000_single_float == 0 && rs6000_double_float == 0)
3196     rs6000_single_float = rs6000_double_float = 1;
3197
3198   /* Reset single and double FP flags if target is E500. */
3199   if (TARGET_E500) 
3200   {
3201     rs6000_single_float = rs6000_double_float = 0;
3202     if (TARGET_E500_SINGLE)
3203       rs6000_single_float = 1; 
3204     if (TARGET_E500_DOUBLE)
3205       rs6000_single_float = rs6000_double_float = 1;
3206   }
3207
3208   /* If not explicitly specified via option, decide whether to generate indexed
3209      load/store instructions.  */
3210   if (TARGET_AVOID_XFORM == -1)
3211     /* Avoid indexed addressing when targeting Power6 in order to avoid
3212      the DERAT mispredict penalty.  */
3213     TARGET_AVOID_XFORM = (rs6000_cpu == PROCESSOR_POWER6 && TARGET_CMPB);
3214
3215   /* Set the -mrecip options.  */
3216   if (rs6000_recip_name)
3217     {
3218       char *p = ASTRDUP (rs6000_recip_name);
3219       char *q;
3220       unsigned int mask, i;
3221       bool invert;
3222
3223       while ((q = strtok (p, ",")) != NULL)
3224         {
3225           p = NULL;
3226           if (*q == '!')
3227             {
3228               invert = true;
3229               q++;
3230             }
3231           else
3232             invert = false;
3233
3234           if (!strcmp (q, "default"))
3235             mask = ((TARGET_RECIP_PRECISION)
3236                     ? RECIP_HIGH_PRECISION : RECIP_LOW_PRECISION);
3237           else
3238             {
3239               for (i = 0; i < ARRAY_SIZE (recip_options); i++)
3240                 if (!strcmp (q, recip_options[i].string))
3241                   {
3242                     mask = recip_options[i].mask;
3243                     break;
3244                   }
3245
3246               if (i == ARRAY_SIZE (recip_options))
3247                 {
3248                   error ("Unknown option for -mrecip=%s", q);
3249                   invert = false;
3250                   mask = 0;
3251                 }
3252             }
3253
3254           if (invert)
3255             rs6000_recip_control &= ~mask;
3256           else
3257             rs6000_recip_control |= mask;
3258         }
3259     }
3260
3261   rs6000_init_hard_regno_mode_ok ();
3262 }
3263
3264 /* Implement TARGET_OPTION_OVERRIDE.  On the RS/6000 this is used to
3265    define the target cpu type.  */
3266
3267 static void
3268 rs6000_option_override (void)
3269 {
3270   rs6000_option_override_internal (OPTION_TARGET_CPU_DEFAULT);
3271 }
3272
3273 /* Implement targetm.vectorize.builtin_mask_for_load.  */
3274 static tree
3275 rs6000_builtin_mask_for_load (void)
3276 {
3277   if (TARGET_ALTIVEC || TARGET_VSX)
3278     return altivec_builtin_mask_for_load;
3279   else
3280     return 0;
3281 }
3282
3283 /* Implement targetm.vectorize.builtin_conversion.
3284    Returns a decl of a function that implements conversion of an integer vector
3285    into a floating-point vector, or vice-versa.  DEST_TYPE is the
3286    destination type and SRC_TYPE the source type of the conversion.
3287    Return NULL_TREE if it is not available.  */
3288 static tree
3289 rs6000_builtin_conversion (unsigned int tcode, tree dest_type, tree src_type)
3290 {
3291   enum tree_code code = (enum tree_code) tcode;
3292
3293   switch (code)
3294     {
3295     case FIX_TRUNC_EXPR:
3296       switch (TYPE_MODE (dest_type))
3297         {
3298         case V2DImode:
3299           if (!VECTOR_UNIT_VSX_P (V2DFmode))
3300             return NULL_TREE;
3301
3302           return TYPE_UNSIGNED (dest_type)
3303             ? rs6000_builtin_decls[VSX_BUILTIN_XVCVDPUXDS_UNS]
3304             : rs6000_builtin_decls[VSX_BUILTIN_XVCVDPSXDS];
3305
3306         case V4SImode:
3307           if (VECTOR_UNIT_NONE_P (V4SImode) || VECTOR_UNIT_NONE_P (V4SFmode))
3308             return NULL_TREE;
3309
3310           return TYPE_UNSIGNED (dest_type)
3311             ? rs6000_builtin_decls[VECTOR_BUILTIN_FIXUNS_V4SF_V4SI]
3312             : rs6000_builtin_decls[VECTOR_BUILTIN_FIX_V4SF_V4SI];
3313
3314         default:
3315           return NULL_TREE;
3316         }
3317
3318     case FLOAT_EXPR:
3319       switch (TYPE_MODE (src_type))
3320         {
3321         case V2DImode:
3322           if (!VECTOR_UNIT_VSX_P (V2DFmode))
3323             return NULL_TREE;
3324
3325           return TYPE_UNSIGNED (src_type)
3326             ? rs6000_builtin_decls[VSX_BUILTIN_XVCVUXDDP]
3327             : rs6000_builtin_decls[VSX_BUILTIN_XVCVSXDDP];
3328
3329         case V4SImode:
3330           if (VECTOR_UNIT_NONE_P (V4SImode) || VECTOR_UNIT_NONE_P (V4SFmode))
3331             return NULL_TREE;
3332
3333           return TYPE_UNSIGNED (src_type)
3334             ? rs6000_builtin_decls[VECTOR_BUILTIN_UNSFLOAT_V4SI_V4SF]
3335             : rs6000_builtin_decls[VECTOR_BUILTIN_FLOAT_V4SI_V4SF];
3336
3337         default:
3338           return NULL_TREE;
3339         }
3340
3341     default:
3342       return NULL_TREE;
3343     }
3344 }
3345
3346 /* Implement targetm.vectorize.builtin_mul_widen_even.  */
3347 static tree
3348 rs6000_builtin_mul_widen_even (tree type)
3349 {
3350   if (!TARGET_ALTIVEC)
3351     return NULL_TREE;
3352
3353   switch (TYPE_MODE (type))
3354     {
3355     case V8HImode:
3356       return TYPE_UNSIGNED (type)
3357             ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULEUH_UNS]
3358             : rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULESH];
3359
3360     case V16QImode:
3361       return TYPE_UNSIGNED (type)
3362             ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULEUB_UNS]
3363             : rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULESB];
3364     default:
3365       return NULL_TREE;
3366     }
3367 }
3368
3369 /* Implement targetm.vectorize.builtin_mul_widen_odd.  */
3370 static tree
3371 rs6000_builtin_mul_widen_odd (tree type)
3372 {
3373   if (!TARGET_ALTIVEC)
3374     return NULL_TREE;
3375
3376   switch (TYPE_MODE (type))
3377     {
3378     case V8HImode:
3379       return TYPE_UNSIGNED (type)
3380             ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOUH_UNS]
3381             : rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOSH];
3382
3383     case V16QImode:
3384       return TYPE_UNSIGNED (type)
3385             ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOUB_UNS]
3386             : rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOSB];
3387     default:
3388       return NULL_TREE;
3389     }
3390 }
3391
3392
3393 /* Return true iff, data reference of TYPE can reach vector alignment (16)
3394    after applying N number of iterations.  This routine does not determine
3395    how may iterations are required to reach desired alignment.  */
3396
3397 static bool
3398 rs6000_vector_alignment_reachable (const_tree type ATTRIBUTE_UNUSED, bool is_packed)
3399 {
3400   if (is_packed)
3401     return false;
3402
3403   if (TARGET_32BIT)
3404     {
3405       if (rs6000_alignment_flags == MASK_ALIGN_NATURAL)
3406         return true;
3407
3408       if (rs6000_alignment_flags ==  MASK_ALIGN_POWER)
3409         return true;
3410
3411       return false;
3412     }
3413   else
3414     {
3415       if (TARGET_MACHO)
3416         return false;
3417
3418       /* Assuming that all other types are naturally aligned. CHECKME!  */
3419       return true;
3420     }
3421 }
3422
3423 /* Return true if the vector misalignment factor is supported by the
3424    target.  */ 
3425 bool
3426 rs6000_builtin_support_vector_misalignment (enum machine_mode mode,
3427                                             const_tree type,
3428                                             int misalignment,
3429                                             bool is_packed)
3430 {
3431   if (TARGET_VSX)
3432     {
3433       /* Return if movmisalign pattern is not supported for this mode.  */
3434       if (optab_handler (movmisalign_optab, mode) == CODE_FOR_nothing)
3435         return false;
3436
3437       if (misalignment == -1)
3438         {
3439           /* Misalignment factor is unknown at compile time but we know
3440              it's word aligned.  */
3441           if (rs6000_vector_alignment_reachable (type, is_packed))
3442             {
3443               int element_size = TREE_INT_CST_LOW (TYPE_SIZE (type));
3444
3445               if (element_size == 64 || element_size == 32)
3446                return true;
3447             }
3448
3449           return false;
3450         }
3451
3452       /* VSX supports word-aligned vector.  */
3453       if (misalignment % 4 == 0)
3454         return true;
3455     }
3456   return false;
3457 }
3458
3459 /* Implement targetm.vectorize.builtin_vec_perm.  */
3460 tree
3461 rs6000_builtin_vec_perm (tree type, tree *mask_element_type)
3462 {
3463   tree inner_type = TREE_TYPE (type);
3464   bool uns_p = TYPE_UNSIGNED (inner_type);
3465   tree d;
3466
3467   *mask_element_type = unsigned_char_type_node;
3468
3469   switch (TYPE_MODE (type))
3470     {
3471     case V16QImode:
3472       d = (uns_p
3473            ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_16QI_UNS]
3474            : rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_16QI]);
3475       break;
3476
3477     case V8HImode:
3478       d = (uns_p
3479            ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_8HI_UNS]
3480            : rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_8HI]);
3481       break;
3482
3483     case V4SImode:
3484       d = (uns_p
3485            ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_4SI_UNS]
3486            : rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_4SI]);
3487       break;
3488
3489     case V4SFmode:
3490       d = rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_4SF];
3491       break;
3492
3493     case V2DFmode:
3494       if (!TARGET_ALLOW_DF_PERMUTE)
3495         return NULL_TREE;
3496
3497       d = rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_2DF];
3498       break;
3499
3500     case V2DImode:
3501       if (!TARGET_ALLOW_DF_PERMUTE)
3502         return NULL_TREE;
3503
3504       d = (uns_p
3505            ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_2DI_UNS]
3506            : rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_2DI]);
3507       break;
3508
3509     default:
3510       return NULL_TREE;
3511     }
3512
3513   gcc_assert (d);
3514   return d;
3515 }
3516
3517
3518 /* Implement targetm.vectorize.builtin_vectorization_cost.  */
3519 static int
3520 rs6000_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost,
3521                                    tree vectype, int misalign)
3522 {
3523   unsigned elements;
3524
3525   switch (type_of_cost)
3526     {
3527       case scalar_stmt:
3528       case scalar_load:
3529       case scalar_store:
3530       case vector_stmt:
3531       case vector_load:
3532       case vector_store:
3533       case vec_to_scalar:
3534       case scalar_to_vec:
3535       case cond_branch_not_taken:
3536       case vec_perm:
3537         return 1;
3538
3539       case cond_branch_taken:
3540         return 3;
3541
3542       case unaligned_load:
3543         if (TARGET_VSX && TARGET_ALLOW_MOVMISALIGN)
3544           {
3545             elements = TYPE_VECTOR_SUBPARTS (vectype);
3546             if (elements == 2)
3547               /* Double word aligned.  */
3548               return 2;
3549
3550             if (elements == 4)
3551               {
3552                 switch (misalign)
3553                   {
3554                     case 8:
3555                       /* Double word aligned.  */
3556                       return 2;
3557
3558                     case -1:
3559                       /* Unknown misalignment.  */
3560                     case 4:
3561                     case 12:
3562                       /* Word aligned.  */
3563                       return 22;
3564
3565                     default:
3566                       gcc_unreachable ();
3567                   }
3568               }
3569           }
3570
3571         if (TARGET_ALTIVEC)
3572           /* Misaligned loads are not supported.  */
3573           gcc_unreachable ();
3574
3575         return 2;
3576
3577       case unaligned_store:
3578         if (TARGET_VSX && TARGET_ALLOW_MOVMISALIGN)
3579           {
3580             elements = TYPE_VECTOR_SUBPARTS (vectype);
3581             if (elements == 2)
3582               /* Double word aligned.  */
3583               return 2;
3584
3585             if (elements == 4)
3586               {
3587                 switch (misalign)
3588                   {
3589                     case 8:
3590                       /* Double word aligned.  */
3591                       return 2;
3592
3593                     case -1:
3594                       /* Unknown misalignment.  */
3595                     case 4:
3596                     case 12:
3597                       /* Word aligned.  */
3598                       return 23;
3599
3600                     default:
3601                       gcc_unreachable ();
3602                   }
3603               }
3604           }
3605
3606         if (TARGET_ALTIVEC)
3607           /* Misaligned stores are not supported.  */
3608           gcc_unreachable ();
3609
3610         return 2;
3611
3612       default:
3613         gcc_unreachable ();
3614     }
3615 }
3616
3617 /* Implement targetm.vectorize.preferred_simd_mode.  */
3618
3619 static enum machine_mode
3620 rs6000_preferred_simd_mode (enum machine_mode mode)
3621 {
3622   if (TARGET_VSX)
3623     switch (mode)
3624       {
3625       case DFmode:
3626         return V2DFmode;
3627       default:;
3628       }
3629   if (TARGET_ALTIVEC || TARGET_VSX)
3630     switch (mode)
3631       {
3632       case SFmode:
3633         return V4SFmode;
3634       case DImode:
3635         return V2DImode;
3636       case SImode:
3637         return V4SImode;
3638       case HImode:
3639         return V8HImode;
3640       case QImode:
3641         return V16QImode;
3642       default:;
3643       }
3644   if (TARGET_SPE)
3645     switch (mode)
3646       {
3647       case SFmode:
3648         return V2SFmode;
3649       case SImode:
3650         return V2SImode;
3651       default:;
3652       }
3653   if (TARGET_PAIRED_FLOAT
3654       && mode == SFmode)
3655     return V2SFmode;
3656   return word_mode;
3657 }
3658
3659 /* Handle generic options of the form -mfoo=yes/no.
3660    NAME is the option name.
3661    VALUE is the option value.
3662    FLAG is the pointer to the flag where to store a 1 or 0, depending on
3663    whether the option value is 'yes' or 'no' respectively.  */
3664 static void
3665 rs6000_parse_yes_no_option (const char *name, const char *value, int *flag)
3666 {
3667   if (value == 0)
3668     return;
3669   else if (!strcmp (value, "yes"))
3670     *flag = 1;
3671   else if (!strcmp (value, "no"))
3672     *flag = 0;
3673   else
3674     error ("unknown -m%s= option specified: '%s'", name, value);
3675 }
3676
3677 /* Validate and record the size specified with the -mtls-size option.  */
3678
3679 static void
3680 rs6000_parse_tls_size_option (void)
3681 {
3682   if (rs6000_tls_size_string == 0)
3683     return;
3684   else if (strcmp (rs6000_tls_size_string, "16") == 0)
3685     rs6000_tls_size = 16;
3686   else if (strcmp (rs6000_tls_size_string, "32") == 0)
3687     rs6000_tls_size = 32;
3688   else if (strcmp (rs6000_tls_size_string, "64") == 0)
3689     rs6000_tls_size = 64;
3690   else
3691     error ("bad value %qs for -mtls-size switch", rs6000_tls_size_string);
3692 }
3693
3694 /* Implement TARGET_OPTION_INIT_STRUCT.  */
3695
3696 static void
3697 rs6000_option_init_struct (struct gcc_options *opts)
3698 {
3699   if (DEFAULT_ABI == ABI_DARWIN)
3700     /* The Darwin libraries never set errno, so we might as well
3701        avoid calling them when that's the only reason we would.  */
3702     opts->x_flag_errno_math = 0;
3703
3704   /* Enable section anchors by default.  */
3705   if (!TARGET_MACHO)
3706     opts->x_flag_section_anchors = 1;
3707 }
3708
3709 /* Implement TARGET_OPTION_DEFAULT_PARAMS.  */
3710
3711 static void
3712 rs6000_option_default_params (void)
3713 {
3714   /* Double growth factor to counter reduced min jump length.  */
3715   set_default_param_value (PARAM_MAX_GROW_COPY_BB_INSNS, 16);
3716 }
3717
3718 static enum fpu_type_t
3719 rs6000_parse_fpu_option (const char *option)
3720 {
3721   if (!strcmp("none", option)) return FPU_NONE;
3722   if (!strcmp("sp_lite", option)) return FPU_SF_LITE;
3723   if (!strcmp("dp_lite", option)) return FPU_DF_LITE;
3724   if (!strcmp("sp_full", option)) return FPU_SF_FULL;
3725   if (!strcmp("dp_full", option)) return FPU_DF_FULL;
3726   error("unknown value %s for -mfpu", option);
3727   return FPU_NONE;
3728 }
3729
3730
3731 /* Handler for the Mathematical Acceleration Subsystem (mass) interface to a
3732    library with vectorized intrinsics.  */
3733
3734 static tree
3735 rs6000_builtin_vectorized_libmass (tree fndecl, tree type_out, tree type_in)
3736 {
3737   char name[32];
3738   const char *suffix = NULL;
3739   tree fntype, new_fndecl, bdecl = NULL_TREE;
3740   int n_args = 1;
3741   const char *bname;
3742   enum machine_mode el_mode, in_mode;
3743   int n, in_n;
3744
3745   /* Libmass is suitable for unsafe math only as it does not correctly support
3746      parts of IEEE with the required precision such as denormals.  Only support
3747      it if we have VSX to use the simd d2 or f4 functions.
3748      XXX: Add variable length support.  */
3749   if (!flag_unsafe_math_optimizations || !TARGET_VSX)
3750     return NULL_TREE;
3751
3752   el_mode = TYPE_MODE (TREE_TYPE (type_out));
3753   n = TYPE_VECTOR_SUBPARTS (type_out);
3754   in_mode = TYPE_MODE (TREE_TYPE (type_in));
3755   in_n = TYPE_VECTOR_SUBPARTS (type_in);
3756   if (el_mode != in_mode
3757       || n != in_n)
3758     return NULL_TREE;
3759
3760   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
3761     {
3762       enum built_in_function fn = DECL_FUNCTION_CODE (fndecl);
3763       switch (fn)
3764         {
3765         case BUILT_IN_ATAN2:
3766         case BUILT_IN_HYPOT:
3767         case BUILT_IN_POW:
3768           n_args = 2;
3769           /* fall through */
3770
3771         case BUILT_IN_ACOS:
3772         case BUILT_IN_ACOSH:
3773         case BUILT_IN_ASIN:
3774         case BUILT_IN_ASINH:
3775         case BUILT_IN_ATAN:
3776         case BUILT_IN_ATANH:
3777         case BUILT_IN_CBRT:
3778         case BUILT_IN_COS:
3779         case BUILT_IN_COSH:
3780         case BUILT_IN_ERF:
3781         case BUILT_IN_ERFC:
3782         case BUILT_IN_EXP2:
3783         case BUILT_IN_EXP:
3784         case BUILT_IN_EXPM1:
3785         case BUILT_IN_LGAMMA:
3786         case BUILT_IN_LOG10:
3787         case BUILT_IN_LOG1P:
3788         case BUILT_IN_LOG2:
3789         case BUILT_IN_LOG:
3790         case BUILT_IN_SIN:
3791         case BUILT_IN_SINH:
3792         case BUILT_IN_SQRT:
3793         case BUILT_IN_TAN:
3794         case BUILT_IN_TANH:
3795           bdecl = implicit_built_in_decls[fn];
3796           suffix = "d2";                                /* pow -> powd2 */
3797           if (el_mode != DFmode
3798               || n != 2)
3799             return NULL_TREE;
3800           break;
3801
3802         case BUILT_IN_ATAN2F:
3803         case BUILT_IN_HYPOTF:
3804         case BUILT_IN_POWF:
3805           n_args = 2;
3806           /* fall through */
3807
3808         case BUILT_IN_ACOSF:
3809         case BUILT_IN_ACOSHF:
3810         case BUILT_IN_ASINF:
3811         case BUILT_IN_ASINHF:
3812         case BUILT_IN_ATANF:
3813         case BUILT_IN_ATANHF:
3814         case BUILT_IN_CBRTF:
3815         case BUILT_IN_COSF:
3816         case BUILT_IN_COSHF:
3817         case BUILT_IN_ERFF:
3818         case BUILT_IN_ERFCF:
3819         case BUILT_IN_EXP2F:
3820         case BUILT_IN_EXPF:
3821         case BUILT_IN_EXPM1F:
3822         case BUILT_IN_LGAMMAF:
3823         case BUILT_IN_LOG10F:
3824         case BUILT_IN_LOG1PF:
3825         case BUILT_IN_LOG2F:
3826         case BUILT_IN_LOGF:
3827         case BUILT_IN_SINF:
3828         case BUILT_IN_SINHF:
3829         case BUILT_IN_SQRTF:
3830         case BUILT_IN_TANF:
3831         case BUILT_IN_TANHF:
3832           bdecl = implicit_built_in_decls[fn];
3833           suffix = "4";                                 /* powf -> powf4 */
3834           if (el_mode != SFmode
3835               || n != 4)
3836             return NULL_TREE;
3837           break;
3838
3839         default:
3840           return NULL_TREE;
3841         }
3842     }
3843   else
3844     return NULL_TREE;
3845
3846   gcc_assert (suffix != NULL);
3847   bname = IDENTIFIER_POINTER (DECL_NAME (bdecl));
3848   strcpy (name, bname + sizeof ("__builtin_") - 1);
3849   strcat (name, suffix);
3850
3851   if (n_args == 1)
3852     fntype = build_function_type_list (type_out, type_in, NULL);
3853   else if (n_args == 2)
3854     fntype = build_function_type_list (type_out, type_in, type_in, NULL);
3855   else
3856     gcc_unreachable ();
3857
3858   /* Build a function declaration for the vectorized function.  */
3859   new_fndecl = build_decl (BUILTINS_LOCATION,
3860                            FUNCTION_DECL, get_identifier (name), fntype);
3861   TREE_PUBLIC (new_fndecl) = 1;
3862   DECL_EXTERNAL (new_fndecl) = 1;
3863   DECL_IS_NOVOPS (new_fndecl) = 1;
3864   TREE_READONLY (new_fndecl) = 1;
3865
3866   return new_fndecl;
3867 }
3868
3869 /* Returns a function decl for a vectorized version of the builtin function
3870    with builtin function code FN and the result vector type TYPE, or NULL_TREE
3871    if it is not available.  */
3872
3873 static tree
3874 rs6000_builtin_vectorized_function (tree fndecl, tree type_out,
3875                                     tree type_in)
3876 {
3877   enum machine_mode in_mode, out_mode;
3878   int in_n, out_n;
3879
3880   if (TREE_CODE (type_out) != VECTOR_TYPE
3881       || TREE_CODE (type_in) != VECTOR_TYPE
3882       || !TARGET_VECTORIZE_BUILTINS)
3883     return NULL_TREE;
3884
3885   out_mode = TYPE_MODE (TREE_TYPE (type_out));
3886   out_n = TYPE_VECTOR_SUBPARTS (type_out);
3887   in_mode = TYPE_MODE (TREE_TYPE (type_in));
3888   in_n = TYPE_VECTOR_SUBPARTS (type_in);
3889
3890   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
3891     {
3892       enum built_in_function fn = DECL_FUNCTION_CODE (fndecl);
3893       switch (fn)
3894         {
3895         case BUILT_IN_COPYSIGN:
3896           if (VECTOR_UNIT_VSX_P (V2DFmode)
3897               && out_mode == DFmode && out_n == 2
3898               && in_mode == DFmode && in_n == 2)
3899             return rs6000_builtin_decls[VSX_BUILTIN_CPSGNDP];
3900           break;
3901         case BUILT_IN_COPYSIGNF:
3902           if (out_mode != SFmode || out_n != 4
3903               || in_mode != SFmode || in_n != 4)
3904             break;
3905           if (VECTOR_UNIT_VSX_P (V4SFmode))
3906             return rs6000_builtin_decls[VSX_BUILTIN_CPSGNSP];
3907           if (VECTOR_UNIT_ALTIVEC_P (V4SFmode))
3908             return rs6000_builtin_decls[ALTIVEC_BUILTIN_COPYSIGN_V4SF];
3909           break;
3910         case BUILT_IN_SQRT:
3911           if (VECTOR_UNIT_VSX_P (V2DFmode)
3912               && out_mode == DFmode && out_n == 2
3913               && in_mode == DFmode && in_n == 2)
3914             return rs6000_builtin_decls[VSX_BUILTIN_XVSQRTDP];
3915           break;
3916         case BUILT_IN_SQRTF:
3917           if (VECTOR_UNIT_VSX_P (V4SFmode)
3918               && out_mode == SFmode && out_n == 4
3919               && in_mode == SFmode && in_n == 4)
3920             return rs6000_builtin_decls[VSX_BUILTIN_XVSQRTSP];
3921           break;
3922         case BUILT_IN_CEIL:
3923           if (VECTOR_UNIT_VSX_P (V2DFmode)
3924               && out_mode == DFmode && out_n == 2
3925               && in_mode == DFmode && in_n == 2)
3926             return rs6000_builtin_decls[VSX_BUILTIN_XVRDPIP];
3927           break;
3928         case BUILT_IN_CEILF:
3929           if (out_mode != SFmode || out_n != 4
3930               || in_mode != SFmode || in_n != 4)
3931             break;
3932           if (VECTOR_UNIT_VSX_P (V4SFmode))
3933             return rs6000_builtin_decls[VSX_BUILTIN_XVRSPIP];
3934           if (VECTOR_UNIT_ALTIVEC_P (V4SFmode))
3935             return rs6000_builtin_decls[ALTIVEC_BUILTIN_VRFIP];
3936           break;
3937         case BUILT_IN_FLOOR:
3938           if (VECTOR_UNIT_VSX_P (V2DFmode)
3939               && out_mode == DFmode && out_n == 2
3940               && in_mode == DFmode && in_n == 2)
3941             return rs6000_builtin_decls[VSX_BUILTIN_XVRDPIM];
3942           break;
3943         case BUILT_IN_FLOORF:
3944           if (out_mode != SFmode || out_n != 4
3945               || in_mode != SFmode || in_n != 4)