OSDN Git Service

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