OSDN Git Service

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