OSDN Git Service

2009-10-09 Richard Guenther <rguenther@suse.de>
[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 PPC601 processors.  */
515 static const
516 struct processor_costs ppc601_cost = {
517   COSTS_N_INSNS (5),    /* mulsi */
518   COSTS_N_INSNS (5),    /* mulsi_const */
519   COSTS_N_INSNS (5),    /* mulsi_const9 */
520   COSTS_N_INSNS (5),    /* muldi */
521   COSTS_N_INSNS (36),   /* divsi */
522   COSTS_N_INSNS (36),   /* divdi */
523   COSTS_N_INSNS (4),    /* fp */
524   COSTS_N_INSNS (5),    /* dmul */
525   COSTS_N_INSNS (17),   /* sdiv */
526   COSTS_N_INSNS (31),   /* ddiv */
527   32,                   /* cache line size */
528   32,                   /* l1 cache */
529   256,                  /* l2 cache */
530   1,                    /* streams */
531 };
532
533 /* Instruction costs on PPC603 processors.  */
534 static const
535 struct processor_costs ppc603_cost = {
536   COSTS_N_INSNS (5),    /* mulsi */
537   COSTS_N_INSNS (3),    /* mulsi_const */
538   COSTS_N_INSNS (2),    /* mulsi_const9 */
539   COSTS_N_INSNS (5),    /* muldi */
540   COSTS_N_INSNS (37),   /* divsi */
541   COSTS_N_INSNS (37),   /* divdi */
542   COSTS_N_INSNS (3),    /* fp */
543   COSTS_N_INSNS (4),    /* dmul */
544   COSTS_N_INSNS (18),   /* sdiv */
545   COSTS_N_INSNS (33),   /* ddiv */
546   32,                   /* cache line size */
547   8,                    /* l1 cache */
548   64,                   /* l2 cache */
549   1,                    /* streams */
550 };
551
552 /* Instruction costs on PPC604 processors.  */
553 static const
554 struct processor_costs ppc604_cost = {
555   COSTS_N_INSNS (4),    /* mulsi */
556   COSTS_N_INSNS (4),    /* mulsi_const */
557   COSTS_N_INSNS (4),    /* mulsi_const9 */
558   COSTS_N_INSNS (4),    /* muldi */
559   COSTS_N_INSNS (20),   /* divsi */
560   COSTS_N_INSNS (20),   /* divdi */
561   COSTS_N_INSNS (3),    /* fp */
562   COSTS_N_INSNS (3),    /* dmul */
563   COSTS_N_INSNS (18),   /* sdiv */
564   COSTS_N_INSNS (32),   /* ddiv */
565   32,                   /* cache line size */
566   16,                   /* l1 cache */
567   512,                  /* l2 cache */
568   1,                    /* streams */
569 };
570
571 /* Instruction costs on PPC604e processors.  */
572 static const
573 struct processor_costs ppc604e_cost = {
574   COSTS_N_INSNS (2),    /* mulsi */
575   COSTS_N_INSNS (2),    /* mulsi_const */
576   COSTS_N_INSNS (2),    /* mulsi_const9 */
577   COSTS_N_INSNS (2),    /* 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   32,                   /* l1 cache */
586   1024,                 /* l2 cache */
587   1,                    /* streams */
588 };
589
590 /* Instruction costs on PPC620 processors.  */
591 static const
592 struct processor_costs ppc620_cost = {
593   COSTS_N_INSNS (5),    /* mulsi */
594   COSTS_N_INSNS (4),    /* mulsi_const */
595   COSTS_N_INSNS (3),    /* mulsi_const9 */
596   COSTS_N_INSNS (7),    /* muldi */
597   COSTS_N_INSNS (21),   /* divsi */
598   COSTS_N_INSNS (37),   /* 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   128,                  /* cache line size */
604   32,                   /* l1 cache */
605   1024,                 /* l2 cache */
606   1,                    /* streams */
607 };
608
609 /* Instruction costs on PPC630 processors.  */
610 static const
611 struct processor_costs ppc630_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 (17),   /* sdiv */
621   COSTS_N_INSNS (21),   /* ddiv */
622   128,                  /* cache line size */
623   64,                   /* l1 cache */
624   1024,                 /* l2 cache */
625   1,                    /* streams */
626 };
627
628 /* Instruction costs on Cell processor.  */
629 /* COSTS_N_INSNS (1) ~ one add.  */
630 static const
631 struct processor_costs ppccell_cost = {
632   COSTS_N_INSNS (9/2)+2,    /* mulsi */
633   COSTS_N_INSNS (6/2),    /* mulsi_const */
634   COSTS_N_INSNS (6/2),    /* mulsi_const9 */
635   COSTS_N_INSNS (15/2)+2,   /* muldi */
636   COSTS_N_INSNS (38/2),   /* divsi */
637   COSTS_N_INSNS (70/2),   /* divdi */
638   COSTS_N_INSNS (10/2),   /* fp */
639   COSTS_N_INSNS (10/2),   /* dmul */
640   COSTS_N_INSNS (74/2),   /* sdiv */
641   COSTS_N_INSNS (74/2),   /* ddiv */
642   128,                  /* cache line size */
643   32,                   /* l1 cache */
644   512,                  /* l2 cache */
645   6,                    /* streams */
646 };
647
648 /* Instruction costs on PPC750 and PPC7400 processors.  */
649 static const
650 struct processor_costs ppc750_cost = {
651   COSTS_N_INSNS (5),    /* mulsi */
652   COSTS_N_INSNS (3),    /* mulsi_const */
653   COSTS_N_INSNS (2),    /* mulsi_const9 */
654   COSTS_N_INSNS (5),    /* muldi */
655   COSTS_N_INSNS (17),   /* divsi */
656   COSTS_N_INSNS (17),   /* divdi */
657   COSTS_N_INSNS (3),    /* fp */
658   COSTS_N_INSNS (3),    /* dmul */
659   COSTS_N_INSNS (17),   /* sdiv */
660   COSTS_N_INSNS (31),   /* ddiv */
661   32,                   /* cache line size */
662   32,                   /* l1 cache */
663   512,                  /* l2 cache */
664   1,                    /* streams */
665 };
666
667 /* Instruction costs on PPC7450 processors.  */
668 static const
669 struct processor_costs ppc7450_cost = {
670   COSTS_N_INSNS (4),    /* mulsi */
671   COSTS_N_INSNS (3),    /* mulsi_const */
672   COSTS_N_INSNS (3),    /* mulsi_const9 */
673   COSTS_N_INSNS (4),    /* muldi */
674   COSTS_N_INSNS (23),   /* divsi */
675   COSTS_N_INSNS (23),   /* divdi */
676   COSTS_N_INSNS (5),    /* fp */
677   COSTS_N_INSNS (5),    /* dmul */
678   COSTS_N_INSNS (21),   /* sdiv */
679   COSTS_N_INSNS (35),   /* ddiv */
680   32,                   /* cache line size */
681   32,                   /* l1 cache */
682   1024,                 /* l2 cache */
683   1,                    /* streams */
684 };
685
686 /* Instruction costs on PPC8540 processors.  */
687 static const
688 struct processor_costs ppc8540_cost = {
689   COSTS_N_INSNS (4),    /* mulsi */
690   COSTS_N_INSNS (4),    /* mulsi_const */
691   COSTS_N_INSNS (4),    /* mulsi_const9 */
692   COSTS_N_INSNS (4),    /* muldi */
693   COSTS_N_INSNS (19),   /* divsi */
694   COSTS_N_INSNS (19),   /* divdi */
695   COSTS_N_INSNS (4),    /* fp */
696   COSTS_N_INSNS (4),    /* dmul */
697   COSTS_N_INSNS (29),   /* sdiv */
698   COSTS_N_INSNS (29),   /* ddiv */
699   32,                   /* cache line size */
700   32,                   /* l1 cache */
701   256,                  /* l2 cache */
702   1,                    /* prefetch streams /*/
703 };
704
705 /* Instruction costs on E300C2 and E300C3 cores.  */
706 static const
707 struct processor_costs ppce300c2c3_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 (3),    /* fp */
715   COSTS_N_INSNS (4),    /* dmul */
716   COSTS_N_INSNS (18),   /* sdiv */
717   COSTS_N_INSNS (33),   /* ddiv */
718   32,
719   16,                   /* l1 cache */
720   16,                   /* l2 cache */
721   1,                    /* prefetch streams /*/
722 };
723
724 /* Instruction costs on PPCE500MC processors.  */
725 static const
726 struct processor_costs ppce500mc_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 (14),   /* divsi */
732   COSTS_N_INSNS (14),   /* divdi */
733   COSTS_N_INSNS (8),    /* fp */
734   COSTS_N_INSNS (10),   /* dmul */
735   COSTS_N_INSNS (36),   /* sdiv */
736   COSTS_N_INSNS (66),   /* ddiv */
737   64,                   /* cache line size */
738   32,                   /* l1 cache */
739   128,                  /* l2 cache */
740   1,                    /* prefetch streams /*/
741 };
742
743 /* Instruction costs on POWER4 and POWER5 processors.  */
744 static const
745 struct processor_costs power4_cost = {
746   COSTS_N_INSNS (3),    /* mulsi */
747   COSTS_N_INSNS (2),    /* mulsi_const */
748   COSTS_N_INSNS (2),    /* mulsi_const9 */
749   COSTS_N_INSNS (4),    /* muldi */
750   COSTS_N_INSNS (18),   /* divsi */
751   COSTS_N_INSNS (34),   /* divdi */
752   COSTS_N_INSNS (3),    /* fp */
753   COSTS_N_INSNS (3),    /* dmul */
754   COSTS_N_INSNS (17),   /* sdiv */
755   COSTS_N_INSNS (17),   /* ddiv */
756   128,                  /* cache line size */
757   32,                   /* l1 cache */
758   1024,                 /* l2 cache */
759   8,                    /* prefetch streams /*/
760 };
761
762 /* Instruction costs on POWER6 processors.  */
763 static const
764 struct processor_costs power6_cost = {
765   COSTS_N_INSNS (8),    /* mulsi */
766   COSTS_N_INSNS (8),    /* mulsi_const */
767   COSTS_N_INSNS (8),    /* mulsi_const9 */
768   COSTS_N_INSNS (8),    /* muldi */
769   COSTS_N_INSNS (22),   /* divsi */
770   COSTS_N_INSNS (28),   /* divdi */
771   COSTS_N_INSNS (3),    /* fp */
772   COSTS_N_INSNS (3),    /* dmul */
773   COSTS_N_INSNS (13),   /* sdiv */
774   COSTS_N_INSNS (16),   /* ddiv */
775   128,                  /* cache line size */
776   64,                   /* l1 cache */
777   2048,                 /* l2 cache */
778   16,                   /* prefetch streams */
779 };
780
781 /* Instruction costs on POWER7 processors.  */
782 static const
783 struct processor_costs power7_cost = {
784   COSTS_N_INSNS (2),    /* mulsi */
785   COSTS_N_INSNS (2),    /* mulsi_const */
786   COSTS_N_INSNS (2),    /* mulsi_const9 */
787   COSTS_N_INSNS (2),    /* 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 (13),   /* sdiv */
793   COSTS_N_INSNS (16),   /* ddiv */
794   128,                  /* cache line size */
795   32,                   /* l1 cache */
796   256,                  /* l2 cache */
797   12,                   /* prefetch streams */
798 };
799
800 /* Instruction costs on POWER A2 processors.  */
801 static const
802 struct processor_costs ppca2_cost = {
803   COSTS_N_INSNS (16),    /* mulsi */
804   COSTS_N_INSNS (16),    /* mulsi_const */
805   COSTS_N_INSNS (16),    /* mulsi_const9 */
806   COSTS_N_INSNS (16),   /* 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 (59),   /* sdiv */
812   COSTS_N_INSNS (72),   /* ddiv */
813   64,
814   16,                   /* l1 cache */
815   2048,                 /* l2 cache */
816   16,                   /* prefetch streams */
817 };
818
819 \f
820 static bool rs6000_function_ok_for_sibcall (tree, tree);
821 static const char *rs6000_invalid_within_doloop (const_rtx);
822 static bool rs6000_legitimate_address_p (enum machine_mode, rtx, bool);
823 static bool rs6000_debug_legitimate_address_p (enum machine_mode, rtx, bool);
824 static rtx rs6000_generate_compare (rtx, enum machine_mode);
825 static void rs6000_emit_stack_tie (void);
826 static void rs6000_frame_related (rtx, rtx, HOST_WIDE_INT, rtx, rtx);
827 static bool spe_func_has_64bit_regs_p (void);
828 static void emit_frame_save (rtx, rtx, enum machine_mode, unsigned int,
829                              int, HOST_WIDE_INT);
830 static rtx gen_frame_mem_offset (enum machine_mode, rtx, int);
831 static void rs6000_emit_allocate_stack (HOST_WIDE_INT, int, int);
832 static unsigned rs6000_hash_constant (rtx);
833 static unsigned toc_hash_function (const void *);
834 static int toc_hash_eq (const void *, const void *);
835 static bool reg_offset_addressing_ok_p (enum machine_mode);
836 static bool virtual_stack_registers_memory_p (rtx);
837 static bool constant_pool_expr_p (rtx);
838 static bool legitimate_small_data_p (enum machine_mode, rtx);
839 static bool legitimate_lo_sum_address_p (enum machine_mode, rtx, int);
840 static struct machine_function * rs6000_init_machine_status (void);
841 static bool rs6000_assemble_integer (rtx, unsigned int, int);
842 static bool no_global_regs_above (int, bool);
843 #ifdef HAVE_GAS_HIDDEN
844 static void rs6000_assemble_visibility (tree, int);
845 #endif
846 static int rs6000_ra_ever_killed (void);
847 static tree rs6000_handle_longcall_attribute (tree *, tree, tree, int, bool *);
848 static tree rs6000_handle_altivec_attribute (tree *, tree, tree, int, bool *);
849 static bool rs6000_ms_bitfield_layout_p (const_tree);
850 static tree rs6000_handle_struct_attribute (tree *, tree, tree, int, bool *);
851 static void rs6000_eliminate_indexed_memrefs (rtx operands[2]);
852 static const char *rs6000_mangle_type (const_tree);
853 static void rs6000_set_default_type_attributes (tree);
854 static rtx rs6000_savres_routine_sym (rs6000_stack_t *, bool, bool, bool);
855 static rtx rs6000_emit_stack_reset (rs6000_stack_t *, rtx, rtx, int, bool);
856 static rtx rs6000_make_savres_rtx (rs6000_stack_t *, rtx, int,
857                                    enum machine_mode, bool, bool, bool);
858 static bool rs6000_reg_live_or_pic_offset_p (int);
859 static tree rs6000_builtin_vectorized_function (unsigned int, tree, tree);
860 static int rs6000_savres_strategy (rs6000_stack_t *, bool, int, int);
861 static void rs6000_restore_saved_cr (rtx, int);
862 static void rs6000_output_function_prologue (FILE *, HOST_WIDE_INT);
863 static void rs6000_output_function_epilogue (FILE *, HOST_WIDE_INT);
864 static void rs6000_output_mi_thunk (FILE *, tree, HOST_WIDE_INT, HOST_WIDE_INT,
865                                     tree);
866 static rtx rs6000_emit_set_long_const (rtx, HOST_WIDE_INT, HOST_WIDE_INT);
867 static bool rs6000_return_in_memory (const_tree, const_tree);
868 static rtx rs6000_function_value (const_tree, const_tree, bool);
869 static void rs6000_file_start (void);
870 #if TARGET_ELF
871 static int rs6000_elf_reloc_rw_mask (void);
872 static void rs6000_elf_asm_out_constructor (rtx, int);
873 static void rs6000_elf_asm_out_destructor (rtx, int);
874 static void rs6000_elf_end_indicate_exec_stack (void) ATTRIBUTE_UNUSED;
875 static void rs6000_elf_asm_init_sections (void);
876 static section *rs6000_elf_select_rtx_section (enum machine_mode, rtx,
877                                                unsigned HOST_WIDE_INT);
878 static void rs6000_elf_encode_section_info (tree, rtx, int)
879      ATTRIBUTE_UNUSED;
880 #endif
881 static bool rs6000_use_blocks_for_constant_p (enum machine_mode, const_rtx);
882 static void rs6000_alloc_sdmode_stack_slot (void);
883 static void rs6000_instantiate_decls (void);
884 #if TARGET_XCOFF
885 static void rs6000_xcoff_asm_output_anchor (rtx);
886 static void rs6000_xcoff_asm_globalize_label (FILE *, const char *);
887 static void rs6000_xcoff_asm_init_sections (void);
888 static int rs6000_xcoff_reloc_rw_mask (void);
889 static void rs6000_xcoff_asm_named_section (const char *, unsigned int, tree);
890 static section *rs6000_xcoff_select_section (tree, int,
891                                              unsigned HOST_WIDE_INT);
892 static void rs6000_xcoff_unique_section (tree, int);
893 static section *rs6000_xcoff_select_rtx_section
894   (enum machine_mode, rtx, unsigned HOST_WIDE_INT);
895 static const char * rs6000_xcoff_strip_name_encoding (const char *);
896 static unsigned int rs6000_xcoff_section_type_flags (tree, const char *, int);
897 static void rs6000_xcoff_file_start (void);
898 static void rs6000_xcoff_file_end (void);
899 #endif
900 static int rs6000_variable_issue (FILE *, int, rtx, int);
901 static bool rs6000_rtx_costs (rtx, int, int, int *, bool);
902 static bool rs6000_debug_rtx_costs (rtx, int, int, int *, bool);
903 static int rs6000_debug_address_cost (rtx, bool);
904 static int rs6000_adjust_cost (rtx, rtx, rtx, int);
905 static int rs6000_debug_adjust_cost (rtx, rtx, rtx, int);
906 static void rs6000_sched_init (FILE *, int, int);
907 static bool is_microcoded_insn (rtx);
908 static bool is_nonpipeline_insn (rtx);
909 static bool is_cracked_insn (rtx);
910 static bool is_branch_slot_insn (rtx);
911 static bool is_load_insn (rtx);
912 static rtx get_store_dest (rtx pat);
913 static bool is_store_insn (rtx);
914 static bool set_to_load_agen (rtx,rtx);
915 static bool adjacent_mem_locations (rtx,rtx);
916 static int rs6000_adjust_priority (rtx, int);
917 static int rs6000_issue_rate (void);
918 static bool rs6000_is_costly_dependence (dep_t, int, int);
919 static rtx get_next_active_insn (rtx, rtx);
920 static bool insn_terminates_group_p (rtx , enum group_termination);
921 static bool insn_must_be_first_in_group (rtx);
922 static bool insn_must_be_last_in_group (rtx);
923 static bool is_costly_group (rtx *, rtx);
924 static int force_new_group (int, FILE *, rtx *, rtx, bool *, int, int *);
925 static int redefine_groups (FILE *, int, rtx, rtx);
926 static int pad_groups (FILE *, int, rtx, rtx);
927 static void rs6000_sched_finish (FILE *, int);
928 static int rs6000_sched_reorder (FILE *, int, rtx *, int *, int);
929 static int rs6000_sched_reorder2 (FILE *, int, rtx *, int *, int);
930 static int rs6000_use_sched_lookahead (void);
931 static int rs6000_use_sched_lookahead_guard (rtx);
932 static void * rs6000_alloc_sched_context (void);
933 static void rs6000_init_sched_context (void *, bool);
934 static void rs6000_set_sched_context (void *);
935 static void rs6000_free_sched_context (void *);
936 static tree rs6000_builtin_reciprocal (unsigned int, bool, bool);
937 static tree rs6000_builtin_mask_for_load (void);
938 static tree rs6000_builtin_mul_widen_even (tree);
939 static tree rs6000_builtin_mul_widen_odd (tree);
940 static tree rs6000_builtin_conversion (unsigned int, tree);
941 static tree rs6000_builtin_vec_perm (tree, tree *);
942 static bool rs6000_builtin_support_vector_misalignment (enum
943                                                         machine_mode,
944                                                         const_tree,
945                                                         int, bool);
946
947 static void def_builtin (int, const char *, tree, int);
948 static bool rs6000_vector_alignment_reachable (const_tree, bool);
949 static void rs6000_init_builtins (void);
950 static tree rs6000_builtin_decl (unsigned, bool);
951
952 static rtx rs6000_expand_unop_builtin (enum insn_code, tree, rtx);
953 static rtx rs6000_expand_binop_builtin (enum insn_code, tree, rtx);
954 static rtx rs6000_expand_ternop_builtin (enum insn_code, tree, rtx);
955 static rtx rs6000_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
956 static void altivec_init_builtins (void);
957 static unsigned builtin_hash_function (const void *);
958 static int builtin_hash_eq (const void *, const void *);
959 static tree builtin_function_type (enum machine_mode, enum machine_mode,
960                                    enum machine_mode, enum machine_mode,
961                                    enum rs6000_builtins, const char *name);
962 static void rs6000_common_init_builtins (void);
963 static void rs6000_init_libfuncs (void);
964
965 static void paired_init_builtins (void);
966 static rtx paired_expand_builtin (tree, rtx, bool *);
967 static rtx paired_expand_lv_builtin (enum insn_code, tree, rtx);
968 static rtx paired_expand_stv_builtin (enum insn_code, tree);
969 static rtx paired_expand_predicate_builtin (enum insn_code, tree, rtx);
970
971 static void enable_mask_for_builtins (struct builtin_description *, int,
972                                       enum rs6000_builtins,
973                                       enum rs6000_builtins);
974 static void spe_init_builtins (void);
975 static rtx spe_expand_builtin (tree, rtx, bool *);
976 static rtx spe_expand_stv_builtin (enum insn_code, tree);
977 static rtx spe_expand_predicate_builtin (enum insn_code, tree, rtx);
978 static rtx spe_expand_evsel_builtin (enum insn_code, tree, rtx);
979 static int rs6000_emit_int_cmove (rtx, rtx, rtx, rtx);
980 static rs6000_stack_t *rs6000_stack_info (void);
981 static void debug_stack_info (rs6000_stack_t *);
982
983 static rtx altivec_expand_builtin (tree, rtx, bool *);
984 static rtx altivec_expand_ld_builtin (tree, rtx, bool *);
985 static rtx altivec_expand_st_builtin (tree, rtx, bool *);
986 static rtx altivec_expand_dst_builtin (tree, rtx, bool *);
987 static rtx altivec_expand_abs_builtin (enum insn_code, tree, rtx);
988 static rtx altivec_expand_predicate_builtin (enum insn_code, tree, rtx);
989 static rtx altivec_expand_stv_builtin (enum insn_code, tree);
990 static rtx altivec_expand_vec_init_builtin (tree, tree, rtx);
991 static rtx altivec_expand_vec_set_builtin (tree);
992 static rtx altivec_expand_vec_ext_builtin (tree, rtx);
993 static int get_element_number (tree, tree);
994 static bool rs6000_handle_option (size_t, const char *, int);
995 static void rs6000_parse_tls_size_option (void);
996 static void rs6000_parse_yes_no_option (const char *, const char *, int *);
997 static int first_altivec_reg_to_save (void);
998 static unsigned int compute_vrsave_mask (void);
999 static void compute_save_world_info (rs6000_stack_t *info_ptr);
1000 static void is_altivec_return_reg (rtx, void *);
1001 static rtx generate_set_vrsave (rtx, rs6000_stack_t *, int);
1002 int easy_vector_constant (rtx, enum machine_mode);
1003 static rtx rs6000_dwarf_register_span (rtx);
1004 static void rs6000_init_dwarf_reg_sizes_extra (tree);
1005 static rtx rs6000_legitimize_address (rtx, rtx, enum machine_mode);
1006 static rtx rs6000_debug_legitimize_address (rtx, rtx, enum machine_mode);
1007 static rtx rs6000_legitimize_tls_address (rtx, enum tls_model);
1008 static void rs6000_output_dwarf_dtprel (FILE *, int, rtx) ATTRIBUTE_UNUSED;
1009 static rtx rs6000_tls_get_addr (void);
1010 static rtx rs6000_got_sym (void);
1011 static int rs6000_tls_symbol_ref_1 (rtx *, void *);
1012 static const char *rs6000_get_some_local_dynamic_name (void);
1013 static int rs6000_get_some_local_dynamic_name_1 (rtx *, void *);
1014 static rtx rs6000_complex_function_value (enum machine_mode);
1015 static rtx rs6000_spe_function_arg (CUMULATIVE_ARGS *,
1016                                     enum machine_mode, tree);
1017 static void rs6000_darwin64_record_arg_advance_flush (CUMULATIVE_ARGS *,
1018                                                       HOST_WIDE_INT);
1019 static void rs6000_darwin64_record_arg_advance_recurse (CUMULATIVE_ARGS *,
1020                                                         tree, HOST_WIDE_INT);
1021 static void rs6000_darwin64_record_arg_flush (CUMULATIVE_ARGS *,
1022                                               HOST_WIDE_INT,
1023                                               rtx[], int *);
1024 static void rs6000_darwin64_record_arg_recurse (CUMULATIVE_ARGS *,
1025                                                 const_tree, HOST_WIDE_INT,
1026                                                 rtx[], int *);
1027 static rtx rs6000_darwin64_record_arg (CUMULATIVE_ARGS *, const_tree, int, bool);
1028 static rtx rs6000_mixed_function_arg (enum machine_mode, tree, int);
1029 static void rs6000_move_block_from_reg (int regno, rtx x, int nregs);
1030 static void setup_incoming_varargs (CUMULATIVE_ARGS *,
1031                                     enum machine_mode, tree,
1032                                     int *, int);
1033 static bool rs6000_pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode,
1034                                       const_tree, bool);
1035 static int rs6000_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode,
1036                                      tree, bool);
1037 static const char *invalid_arg_for_unprototyped_fn (const_tree, const_tree, const_tree);
1038 #if TARGET_MACHO
1039 static void macho_branch_islands (void);
1040 static int no_previous_def (tree function_name);
1041 static tree get_prev_label (tree function_name);
1042 static void rs6000_darwin_file_start (void);
1043 #endif
1044
1045 static tree rs6000_build_builtin_va_list (void);
1046 static void rs6000_va_start (tree, rtx);
1047 static tree rs6000_gimplify_va_arg (tree, tree, gimple_seq *, gimple_seq *);
1048 static bool rs6000_must_pass_in_stack (enum machine_mode, const_tree);
1049 static bool rs6000_scalar_mode_supported_p (enum machine_mode);
1050 static bool rs6000_vector_mode_supported_p (enum machine_mode);
1051 static rtx rs6000_emit_vector_compare_inner (enum rtx_code, rtx, rtx);
1052 static rtx rs6000_emit_vector_compare (enum rtx_code, rtx, rtx,
1053                                        enum machine_mode);
1054 static tree rs6000_stack_protect_fail (void);
1055
1056 static rtx rs6000_legitimize_reload_address (rtx, enum machine_mode, int, int,
1057                                              int, int *);
1058
1059 static rtx rs6000_debug_legitimize_reload_address (rtx, enum machine_mode, int,
1060                                                    int, int, int *);
1061
1062 rtx (*rs6000_legitimize_reload_address_ptr) (rtx, enum machine_mode, int, int,
1063                                              int, int *)
1064   = rs6000_legitimize_reload_address;
1065
1066 static bool rs6000_mode_dependent_address (rtx);
1067 static bool rs6000_debug_mode_dependent_address (rtx);
1068 bool (*rs6000_mode_dependent_address_ptr) (rtx)
1069   = rs6000_mode_dependent_address;
1070
1071 static enum reg_class rs6000_secondary_reload_class (enum reg_class,
1072                                                      enum machine_mode, rtx);
1073 static enum reg_class rs6000_debug_secondary_reload_class (enum reg_class,
1074                                                            enum machine_mode,
1075                                                            rtx);
1076 enum reg_class (*rs6000_secondary_reload_class_ptr) (enum reg_class,
1077                                                      enum machine_mode, rtx)
1078   = rs6000_secondary_reload_class;
1079
1080 static enum reg_class rs6000_preferred_reload_class (rtx, enum reg_class);
1081 static enum reg_class rs6000_debug_preferred_reload_class (rtx,
1082                                                            enum reg_class);
1083 enum reg_class (*rs6000_preferred_reload_class_ptr) (rtx, enum reg_class)
1084   = rs6000_preferred_reload_class;
1085
1086 static bool rs6000_secondary_memory_needed (enum reg_class, enum reg_class,
1087                                             enum machine_mode);
1088
1089 static bool rs6000_debug_secondary_memory_needed (enum reg_class,
1090                                                   enum reg_class,
1091                                                   enum machine_mode);
1092
1093 bool (*rs6000_secondary_memory_needed_ptr) (enum reg_class, enum reg_class,
1094                                             enum machine_mode)
1095   = rs6000_secondary_memory_needed;
1096
1097 static bool rs6000_cannot_change_mode_class (enum machine_mode,
1098                                              enum machine_mode,
1099                                              enum reg_class);
1100 static bool rs6000_debug_cannot_change_mode_class (enum machine_mode,
1101                                                    enum machine_mode,
1102                                                    enum reg_class);
1103
1104 bool (*rs6000_cannot_change_mode_class_ptr) (enum machine_mode,
1105                                              enum machine_mode,
1106                                              enum reg_class)
1107   = rs6000_cannot_change_mode_class;
1108
1109 static enum reg_class rs6000_secondary_reload (bool, rtx, enum reg_class,
1110                                                enum machine_mode,
1111                                                struct secondary_reload_info *);
1112
1113 static const enum reg_class *rs6000_ira_cover_classes (void);
1114
1115 const int INSN_NOT_AVAILABLE = -1;
1116 static enum machine_mode rs6000_eh_return_filter_mode (void);
1117 static bool rs6000_can_eliminate (const int, const int);
1118 static void rs6000_trampoline_init (rtx, tree, rtx);
1119
1120 /* Hash table stuff for keeping track of TOC entries.  */
1121
1122 struct GTY(()) toc_hash_struct
1123 {
1124   /* `key' will satisfy CONSTANT_P; in fact, it will satisfy
1125      ASM_OUTPUT_SPECIAL_POOL_ENTRY_P.  */
1126   rtx key;
1127   enum machine_mode key_mode;
1128   int labelno;
1129 };
1130
1131 static GTY ((param_is (struct toc_hash_struct))) htab_t toc_hash_table;
1132
1133 /* Hash table to keep track of the argument types for builtin functions.  */
1134
1135 struct GTY(()) builtin_hash_struct
1136 {
1137   tree type;
1138   enum machine_mode mode[4];    /* return value + 3 arguments.  */
1139   unsigned char uns_p[4];       /* and whether the types are unsigned.  */
1140 };
1141
1142 static GTY ((param_is (struct builtin_hash_struct))) htab_t builtin_hash_table;
1143 \f
1144 /* Default register names.  */
1145 char rs6000_reg_names[][8] =
1146 {
1147       "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",
1148       "8",  "9", "10", "11", "12", "13", "14", "15",
1149      "16", "17", "18", "19", "20", "21", "22", "23",
1150      "24", "25", "26", "27", "28", "29", "30", "31",
1151       "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",
1152       "8",  "9", "10", "11", "12", "13", "14", "15",
1153      "16", "17", "18", "19", "20", "21", "22", "23",
1154      "24", "25", "26", "27", "28", "29", "30", "31",
1155      "mq", "lr", "ctr","ap",
1156       "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",
1157       "xer",
1158       /* AltiVec registers.  */
1159       "0",  "1",  "2",  "3",  "4",  "5",  "6", "7",
1160       "8",  "9",  "10", "11", "12", "13", "14", "15",
1161       "16", "17", "18", "19", "20", "21", "22", "23",
1162       "24", "25", "26", "27", "28", "29", "30", "31",
1163       "vrsave", "vscr",
1164       /* SPE registers.  */
1165       "spe_acc", "spefscr",
1166       /* Soft frame pointer.  */
1167       "sfp"
1168 };
1169
1170 #ifdef TARGET_REGNAMES
1171 static const char alt_reg_names[][8] =
1172 {
1173    "%r0",   "%r1",  "%r2",  "%r3",  "%r4",  "%r5",  "%r6",  "%r7",
1174    "%r8",   "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15",
1175   "%r16",  "%r17", "%r18", "%r19", "%r20", "%r21", "%r22", "%r23",
1176   "%r24",  "%r25", "%r26", "%r27", "%r28", "%r29", "%r30", "%r31",
1177    "%f0",   "%f1",  "%f2",  "%f3",  "%f4",  "%f5",  "%f6",  "%f7",
1178    "%f8",   "%f9", "%f10", "%f11", "%f12", "%f13", "%f14", "%f15",
1179   "%f16",  "%f17", "%f18", "%f19", "%f20", "%f21", "%f22", "%f23",
1180   "%f24",  "%f25", "%f26", "%f27", "%f28", "%f29", "%f30", "%f31",
1181     "mq",    "lr",  "ctr",   "ap",
1182   "%cr0",  "%cr1", "%cr2", "%cr3", "%cr4", "%cr5", "%cr6", "%cr7",
1183    "xer",
1184   /* AltiVec registers.  */
1185    "%v0",  "%v1",  "%v2",  "%v3",  "%v4",  "%v5",  "%v6", "%v7",
1186    "%v8",  "%v9", "%v10", "%v11", "%v12", "%v13", "%v14", "%v15",
1187   "%v16", "%v17", "%v18", "%v19", "%v20", "%v21", "%v22", "%v23",
1188   "%v24", "%v25", "%v26", "%v27", "%v28", "%v29", "%v30", "%v31",
1189   "vrsave", "vscr",
1190   /* SPE registers.  */
1191   "spe_acc", "spefscr",
1192   /* Soft frame pointer.  */
1193   "sfp"
1194 };
1195 #endif
1196
1197 /* Table of valid machine attributes.  */
1198
1199 static const struct attribute_spec rs6000_attribute_table[] =
1200 {
1201   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
1202   { "altivec",   1, 1, false, true,  false, rs6000_handle_altivec_attribute },
1203   { "longcall",  0, 0, false, true,  true,  rs6000_handle_longcall_attribute },
1204   { "shortcall", 0, 0, false, true,  true,  rs6000_handle_longcall_attribute },
1205   { "ms_struct", 0, 0, false, false, false, rs6000_handle_struct_attribute },
1206   { "gcc_struct", 0, 0, false, false, false, rs6000_handle_struct_attribute },
1207 #ifdef SUBTARGET_ATTRIBUTE_TABLE
1208   SUBTARGET_ATTRIBUTE_TABLE,
1209 #endif
1210   { NULL,        0, 0, false, false, false, NULL }
1211 };
1212 \f
1213 #ifndef MASK_STRICT_ALIGN
1214 #define MASK_STRICT_ALIGN 0
1215 #endif
1216 #ifndef TARGET_PROFILE_KERNEL
1217 #define TARGET_PROFILE_KERNEL 0
1218 #define SET_PROFILE_KERNEL(N)
1219 #else
1220 #define SET_PROFILE_KERNEL(N) TARGET_PROFILE_KERNEL = (N)
1221 #endif
1222
1223 /* The VRSAVE bitmask puts bit %v0 as the most significant bit.  */
1224 #define ALTIVEC_REG_BIT(REGNO) (0x80000000 >> ((REGNO) - FIRST_ALTIVEC_REGNO))
1225 \f
1226 /* Initialize the GCC target structure.  */
1227 #undef TARGET_ATTRIBUTE_TABLE
1228 #define TARGET_ATTRIBUTE_TABLE rs6000_attribute_table
1229 #undef TARGET_SET_DEFAULT_TYPE_ATTRIBUTES
1230 #define TARGET_SET_DEFAULT_TYPE_ATTRIBUTES rs6000_set_default_type_attributes
1231
1232 #undef TARGET_ASM_ALIGNED_DI_OP
1233 #define TARGET_ASM_ALIGNED_DI_OP DOUBLE_INT_ASM_OP
1234
1235 /* Default unaligned ops are only provided for ELF.  Find the ops needed
1236    for non-ELF systems.  */
1237 #ifndef OBJECT_FORMAT_ELF
1238 #if TARGET_XCOFF
1239 /* For XCOFF.  rs6000_assemble_integer will handle unaligned DIs on
1240    64-bit targets.  */
1241 #undef TARGET_ASM_UNALIGNED_HI_OP
1242 #define TARGET_ASM_UNALIGNED_HI_OP "\t.vbyte\t2,"
1243 #undef TARGET_ASM_UNALIGNED_SI_OP
1244 #define TARGET_ASM_UNALIGNED_SI_OP "\t.vbyte\t4,"
1245 #undef TARGET_ASM_UNALIGNED_DI_OP
1246 #define TARGET_ASM_UNALIGNED_DI_OP "\t.vbyte\t8,"
1247 #else
1248 /* For Darwin.  */
1249 #undef TARGET_ASM_UNALIGNED_HI_OP
1250 #define TARGET_ASM_UNALIGNED_HI_OP "\t.short\t"
1251 #undef TARGET_ASM_UNALIGNED_SI_OP
1252 #define TARGET_ASM_UNALIGNED_SI_OP "\t.long\t"
1253 #undef TARGET_ASM_UNALIGNED_DI_OP
1254 #define TARGET_ASM_UNALIGNED_DI_OP "\t.quad\t"
1255 #undef TARGET_ASM_ALIGNED_DI_OP
1256 #define TARGET_ASM_ALIGNED_DI_OP "\t.quad\t"
1257 #endif
1258 #endif
1259
1260 /* This hook deals with fixups for relocatable code and DI-mode objects
1261    in 64-bit code.  */
1262 #undef TARGET_ASM_INTEGER
1263 #define TARGET_ASM_INTEGER rs6000_assemble_integer
1264
1265 #ifdef HAVE_GAS_HIDDEN
1266 #undef TARGET_ASM_ASSEMBLE_VISIBILITY
1267 #define TARGET_ASM_ASSEMBLE_VISIBILITY rs6000_assemble_visibility
1268 #endif
1269
1270 #undef TARGET_HAVE_TLS
1271 #define TARGET_HAVE_TLS HAVE_AS_TLS
1272
1273 #undef TARGET_CANNOT_FORCE_CONST_MEM
1274 #define TARGET_CANNOT_FORCE_CONST_MEM rs6000_tls_referenced_p
1275
1276 #undef TARGET_ASM_FUNCTION_PROLOGUE
1277 #define TARGET_ASM_FUNCTION_PROLOGUE rs6000_output_function_prologue
1278 #undef TARGET_ASM_FUNCTION_EPILOGUE
1279 #define TARGET_ASM_FUNCTION_EPILOGUE rs6000_output_function_epilogue
1280
1281 #undef TARGET_LEGITIMIZE_ADDRESS
1282 #define TARGET_LEGITIMIZE_ADDRESS rs6000_legitimize_address
1283
1284 #undef  TARGET_SCHED_VARIABLE_ISSUE
1285 #define TARGET_SCHED_VARIABLE_ISSUE rs6000_variable_issue
1286
1287 #undef TARGET_SCHED_ISSUE_RATE
1288 #define TARGET_SCHED_ISSUE_RATE rs6000_issue_rate
1289 #undef TARGET_SCHED_ADJUST_COST
1290 #define TARGET_SCHED_ADJUST_COST rs6000_adjust_cost
1291 #undef TARGET_SCHED_ADJUST_PRIORITY
1292 #define TARGET_SCHED_ADJUST_PRIORITY rs6000_adjust_priority
1293 #undef TARGET_SCHED_IS_COSTLY_DEPENDENCE
1294 #define TARGET_SCHED_IS_COSTLY_DEPENDENCE rs6000_is_costly_dependence
1295 #undef TARGET_SCHED_INIT
1296 #define TARGET_SCHED_INIT rs6000_sched_init
1297 #undef TARGET_SCHED_FINISH
1298 #define TARGET_SCHED_FINISH rs6000_sched_finish
1299 #undef TARGET_SCHED_REORDER
1300 #define TARGET_SCHED_REORDER rs6000_sched_reorder
1301 #undef TARGET_SCHED_REORDER2
1302 #define TARGET_SCHED_REORDER2 rs6000_sched_reorder2
1303
1304 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
1305 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD rs6000_use_sched_lookahead
1306
1307 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD
1308 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD rs6000_use_sched_lookahead_guard
1309
1310 #undef TARGET_SCHED_ALLOC_SCHED_CONTEXT
1311 #define TARGET_SCHED_ALLOC_SCHED_CONTEXT rs6000_alloc_sched_context
1312 #undef TARGET_SCHED_INIT_SCHED_CONTEXT
1313 #define TARGET_SCHED_INIT_SCHED_CONTEXT rs6000_init_sched_context
1314 #undef TARGET_SCHED_SET_SCHED_CONTEXT
1315 #define TARGET_SCHED_SET_SCHED_CONTEXT rs6000_set_sched_context
1316 #undef TARGET_SCHED_FREE_SCHED_CONTEXT
1317 #define TARGET_SCHED_FREE_SCHED_CONTEXT rs6000_free_sched_context
1318
1319 #undef TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD
1320 #define TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD rs6000_builtin_mask_for_load
1321 #undef TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_EVEN
1322 #define TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_EVEN rs6000_builtin_mul_widen_even
1323 #undef TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_ODD
1324 #define TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_ODD rs6000_builtin_mul_widen_odd
1325 #undef TARGET_VECTORIZE_BUILTIN_CONVERSION
1326 #define TARGET_VECTORIZE_BUILTIN_CONVERSION rs6000_builtin_conversion
1327 #undef TARGET_VECTORIZE_BUILTIN_VEC_PERM
1328 #define TARGET_VECTORIZE_BUILTIN_VEC_PERM rs6000_builtin_vec_perm
1329 #undef TARGET_SUPPORT_VECTOR_MISALIGNMENT
1330 #define TARGET_SUPPORT_VECTOR_MISALIGNMENT              \
1331   rs6000_builtin_support_vector_misalignment
1332 #undef TARGET_VECTOR_ALIGNMENT_REACHABLE
1333 #define TARGET_VECTOR_ALIGNMENT_REACHABLE rs6000_vector_alignment_reachable
1334
1335 #undef TARGET_INIT_BUILTINS
1336 #define TARGET_INIT_BUILTINS rs6000_init_builtins
1337 #undef TARGET_BUILTIN_DECL
1338 #define TARGET_BUILTIN_DECL rs6000_builtin_decl
1339
1340 #undef TARGET_EXPAND_BUILTIN
1341 #define TARGET_EXPAND_BUILTIN rs6000_expand_builtin
1342
1343 #undef TARGET_MANGLE_TYPE
1344 #define TARGET_MANGLE_TYPE rs6000_mangle_type
1345
1346 #undef TARGET_INIT_LIBFUNCS
1347 #define TARGET_INIT_LIBFUNCS rs6000_init_libfuncs
1348
1349 #if TARGET_MACHO
1350 #undef TARGET_BINDS_LOCAL_P
1351 #define TARGET_BINDS_LOCAL_P darwin_binds_local_p
1352 #endif
1353
1354 #undef TARGET_MS_BITFIELD_LAYOUT_P
1355 #define TARGET_MS_BITFIELD_LAYOUT_P rs6000_ms_bitfield_layout_p
1356
1357 #undef TARGET_ASM_OUTPUT_MI_THUNK
1358 #define TARGET_ASM_OUTPUT_MI_THUNK rs6000_output_mi_thunk
1359
1360 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
1361 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK hook_bool_const_tree_hwi_hwi_const_tree_true
1362
1363 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
1364 #define TARGET_FUNCTION_OK_FOR_SIBCALL rs6000_function_ok_for_sibcall
1365
1366 #undef TARGET_INVALID_WITHIN_DOLOOP
1367 #define TARGET_INVALID_WITHIN_DOLOOP rs6000_invalid_within_doloop
1368
1369 #undef TARGET_RTX_COSTS
1370 #define TARGET_RTX_COSTS rs6000_rtx_costs
1371 #undef TARGET_ADDRESS_COST
1372 #define TARGET_ADDRESS_COST hook_int_rtx_bool_0
1373
1374 #undef TARGET_DWARF_REGISTER_SPAN
1375 #define TARGET_DWARF_REGISTER_SPAN rs6000_dwarf_register_span
1376
1377 #undef TARGET_INIT_DWARF_REG_SIZES_EXTRA
1378 #define TARGET_INIT_DWARF_REG_SIZES_EXTRA rs6000_init_dwarf_reg_sizes_extra
1379
1380 /* On rs6000, function arguments are promoted, as are function return
1381    values.  */
1382 #undef TARGET_PROMOTE_FUNCTION_MODE
1383 #define TARGET_PROMOTE_FUNCTION_MODE default_promote_function_mode_always_promote
1384
1385 #undef TARGET_RETURN_IN_MEMORY
1386 #define TARGET_RETURN_IN_MEMORY rs6000_return_in_memory
1387
1388 #undef TARGET_SETUP_INCOMING_VARARGS
1389 #define TARGET_SETUP_INCOMING_VARARGS setup_incoming_varargs
1390
1391 /* Always strict argument naming on rs6000.  */
1392 #undef TARGET_STRICT_ARGUMENT_NAMING
1393 #define TARGET_STRICT_ARGUMENT_NAMING hook_bool_CUMULATIVE_ARGS_true
1394 #undef TARGET_PRETEND_OUTGOING_VARARGS_NAMED
1395 #define TARGET_PRETEND_OUTGOING_VARARGS_NAMED hook_bool_CUMULATIVE_ARGS_true
1396 #undef TARGET_SPLIT_COMPLEX_ARG
1397 #define TARGET_SPLIT_COMPLEX_ARG hook_bool_const_tree_true
1398 #undef TARGET_MUST_PASS_IN_STACK
1399 #define TARGET_MUST_PASS_IN_STACK rs6000_must_pass_in_stack
1400 #undef TARGET_PASS_BY_REFERENCE
1401 #define TARGET_PASS_BY_REFERENCE rs6000_pass_by_reference
1402 #undef TARGET_ARG_PARTIAL_BYTES
1403 #define TARGET_ARG_PARTIAL_BYTES rs6000_arg_partial_bytes
1404
1405 #undef TARGET_BUILD_BUILTIN_VA_LIST
1406 #define TARGET_BUILD_BUILTIN_VA_LIST rs6000_build_builtin_va_list
1407
1408 #undef TARGET_EXPAND_BUILTIN_VA_START
1409 #define TARGET_EXPAND_BUILTIN_VA_START rs6000_va_start
1410
1411 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
1412 #define TARGET_GIMPLIFY_VA_ARG_EXPR rs6000_gimplify_va_arg
1413
1414 #undef TARGET_EH_RETURN_FILTER_MODE
1415 #define TARGET_EH_RETURN_FILTER_MODE rs6000_eh_return_filter_mode
1416
1417 #undef TARGET_SCALAR_MODE_SUPPORTED_P
1418 #define TARGET_SCALAR_MODE_SUPPORTED_P rs6000_scalar_mode_supported_p
1419
1420 #undef TARGET_VECTOR_MODE_SUPPORTED_P
1421 #define TARGET_VECTOR_MODE_SUPPORTED_P rs6000_vector_mode_supported_p
1422
1423 #undef TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN
1424 #define TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN invalid_arg_for_unprototyped_fn
1425
1426 #undef TARGET_HANDLE_OPTION
1427 #define TARGET_HANDLE_OPTION rs6000_handle_option
1428
1429 #undef TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION
1430 #define TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION \
1431   rs6000_builtin_vectorized_function
1432
1433 #undef TARGET_DEFAULT_TARGET_FLAGS
1434 #define TARGET_DEFAULT_TARGET_FLAGS \
1435   (TARGET_DEFAULT)
1436
1437 #undef TARGET_STACK_PROTECT_FAIL
1438 #define TARGET_STACK_PROTECT_FAIL rs6000_stack_protect_fail
1439
1440 /* MPC604EUM 3.5.2 Weak Consistency between Multiple Processors
1441    The PowerPC architecture requires only weak consistency among
1442    processors--that is, memory accesses between processors need not be
1443    sequentially consistent and memory accesses among processors can occur
1444    in any order. The ability to order memory accesses weakly provides
1445    opportunities for more efficient use of the system bus. Unless a
1446    dependency exists, the 604e allows read operations to precede store
1447    operations.  */
1448 #undef TARGET_RELAXED_ORDERING
1449 #define TARGET_RELAXED_ORDERING true
1450
1451 #ifdef HAVE_AS_TLS
1452 #undef TARGET_ASM_OUTPUT_DWARF_DTPREL
1453 #define TARGET_ASM_OUTPUT_DWARF_DTPREL rs6000_output_dwarf_dtprel
1454 #endif
1455
1456 /* Use a 32-bit anchor range.  This leads to sequences like:
1457
1458         addis   tmp,anchor,high
1459         add     dest,tmp,low
1460
1461    where tmp itself acts as an anchor, and can be shared between
1462    accesses to the same 64k page.  */
1463 #undef TARGET_MIN_ANCHOR_OFFSET
1464 #define TARGET_MIN_ANCHOR_OFFSET -0x7fffffff - 1
1465 #undef TARGET_MAX_ANCHOR_OFFSET
1466 #define TARGET_MAX_ANCHOR_OFFSET 0x7fffffff
1467 #undef TARGET_USE_BLOCKS_FOR_CONSTANT_P
1468 #define TARGET_USE_BLOCKS_FOR_CONSTANT_P rs6000_use_blocks_for_constant_p
1469
1470 #undef TARGET_BUILTIN_RECIPROCAL
1471 #define TARGET_BUILTIN_RECIPROCAL rs6000_builtin_reciprocal
1472
1473 #undef TARGET_EXPAND_TO_RTL_HOOK
1474 #define TARGET_EXPAND_TO_RTL_HOOK rs6000_alloc_sdmode_stack_slot
1475
1476 #undef TARGET_INSTANTIATE_DECLS
1477 #define TARGET_INSTANTIATE_DECLS rs6000_instantiate_decls
1478
1479 #undef TARGET_SECONDARY_RELOAD
1480 #define TARGET_SECONDARY_RELOAD rs6000_secondary_reload
1481
1482 #undef TARGET_IRA_COVER_CLASSES
1483 #define TARGET_IRA_COVER_CLASSES rs6000_ira_cover_classes
1484
1485 #undef TARGET_LEGITIMATE_ADDRESS_P
1486 #define TARGET_LEGITIMATE_ADDRESS_P rs6000_legitimate_address_p
1487
1488 #undef TARGET_CAN_ELIMINATE
1489 #define TARGET_CAN_ELIMINATE rs6000_can_eliminate
1490
1491 #undef TARGET_TRAMPOLINE_INIT
1492 #define TARGET_TRAMPOLINE_INIT rs6000_trampoline_init
1493
1494 #undef TARGET_FUNCTION_VALUE
1495 #define TARGET_FUNCTION_VALUE rs6000_function_value
1496
1497 struct gcc_target targetm = TARGET_INITIALIZER;
1498 \f
1499 /* Return number of consecutive hard regs needed starting at reg REGNO
1500    to hold something of mode MODE.
1501    This is ordinarily the length in words of a value of mode MODE
1502    but can be less for certain modes in special long registers.
1503
1504    For the SPE, GPRs are 64 bits but only 32 bits are visible in
1505    scalar instructions.  The upper 32 bits are only available to the
1506    SIMD instructions.
1507
1508    POWER and PowerPC GPRs hold 32 bits worth;
1509    PowerPC64 GPRs and FPRs point register holds 64 bits worth.  */
1510
1511 static int
1512 rs6000_hard_regno_nregs_internal (int regno, enum machine_mode mode)
1513 {
1514   unsigned HOST_WIDE_INT reg_size;
1515
1516   if (FP_REGNO_P (regno))
1517     reg_size = (VECTOR_MEM_VSX_P (mode)
1518                 ? UNITS_PER_VSX_WORD
1519                 : UNITS_PER_FP_WORD);
1520
1521   else if (SPE_SIMD_REGNO_P (regno) && TARGET_SPE && SPE_VECTOR_MODE (mode))
1522     reg_size = UNITS_PER_SPE_WORD;
1523
1524   else if (ALTIVEC_REGNO_P (regno))
1525     reg_size = UNITS_PER_ALTIVEC_WORD;
1526
1527   /* The value returned for SCmode in the E500 double case is 2 for
1528      ABI compatibility; storing an SCmode value in a single register
1529      would require function_arg and rs6000_spe_function_arg to handle
1530      SCmode so as to pass the value correctly in a pair of
1531      registers.  */
1532   else if (TARGET_E500_DOUBLE && FLOAT_MODE_P (mode) && mode != SCmode
1533            && !DECIMAL_FLOAT_MODE_P (mode))
1534     reg_size = UNITS_PER_FP_WORD;
1535
1536   else
1537     reg_size = UNITS_PER_WORD;
1538
1539   return (GET_MODE_SIZE (mode) + reg_size - 1) / reg_size;
1540 }
1541
1542 /* Value is 1 if hard register REGNO can hold a value of machine-mode
1543    MODE.  */
1544 static int
1545 rs6000_hard_regno_mode_ok (int regno, enum machine_mode mode)
1546 {
1547   int last_regno = regno + rs6000_hard_regno_nregs[mode][regno] - 1;
1548
1549   /* VSX registers that overlap the FPR registers are larger than for non-VSX
1550      implementations.  Don't allow an item to be split between a FP register
1551      and an Altivec register.  */
1552   if (VECTOR_MEM_VSX_P (mode))
1553     {
1554       if (FP_REGNO_P (regno))
1555         return FP_REGNO_P (last_regno);
1556
1557       if (ALTIVEC_REGNO_P (regno))
1558         return ALTIVEC_REGNO_P (last_regno);
1559     }
1560
1561   /* The GPRs can hold any mode, but values bigger than one register
1562      cannot go past R31.  */
1563   if (INT_REGNO_P (regno))
1564     return INT_REGNO_P (last_regno);
1565
1566   /* The float registers (except for VSX vector modes) can only hold floating
1567      modes and DImode.  This excludes the 32-bit decimal float mode for
1568      now.  */
1569   if (FP_REGNO_P (regno))
1570     {
1571       if (SCALAR_FLOAT_MODE_P (mode)
1572           && (mode != TDmode || (regno % 2) == 0)
1573           && FP_REGNO_P (last_regno))
1574         return 1;
1575
1576       if (GET_MODE_CLASS (mode) == MODE_INT
1577           && GET_MODE_SIZE (mode) == UNITS_PER_FP_WORD)
1578         return 1;
1579
1580       if (PAIRED_SIMD_REGNO_P (regno) && TARGET_PAIRED_FLOAT
1581           && PAIRED_VECTOR_MODE (mode))
1582         return 1;
1583
1584       return 0;
1585     }
1586
1587   /* The CR register can only hold CC modes.  */
1588   if (CR_REGNO_P (regno))
1589     return GET_MODE_CLASS (mode) == MODE_CC;
1590
1591   if (XER_REGNO_P (regno))
1592     return mode == PSImode;
1593
1594   /* AltiVec only in AldyVec registers.  */
1595   if (ALTIVEC_REGNO_P (regno))
1596     return VECTOR_MEM_ALTIVEC_OR_VSX_P (mode);
1597
1598   /* ...but GPRs can hold SIMD data on the SPE in one register.  */
1599   if (SPE_SIMD_REGNO_P (regno) && TARGET_SPE && SPE_VECTOR_MODE (mode))
1600     return 1;
1601
1602   /* We cannot put TImode anywhere except general register and it must be able
1603      to fit within the register set.  In the future, allow TImode in the
1604      Altivec or VSX registers.  */
1605
1606   return GET_MODE_SIZE (mode) <= UNITS_PER_WORD;
1607 }
1608
1609 /* Print interesting facts about registers.  */
1610 static void
1611 rs6000_debug_reg_print (int first_regno, int last_regno, const char *reg_name)
1612 {
1613   int r, m;
1614
1615   for (r = first_regno; r <= last_regno; ++r)
1616     {
1617       const char *comma = "";
1618       int len;
1619
1620       if (first_regno == last_regno)
1621         fprintf (stderr, "%s:\t", reg_name);
1622       else
1623         fprintf (stderr, "%s%d:\t", reg_name, r - first_regno);
1624
1625       len = 8;
1626       for (m = 0; m < NUM_MACHINE_MODES; ++m)
1627         if (rs6000_hard_regno_mode_ok_p[m][r] && rs6000_hard_regno_nregs[m][r])
1628           {
1629             if (len > 70)
1630               {
1631                 fprintf (stderr, ",\n\t");
1632                 len = 8;
1633                 comma = "";
1634               }
1635
1636             if (rs6000_hard_regno_nregs[m][r] > 1)
1637               len += fprintf (stderr, "%s%s/%d", comma, GET_MODE_NAME (m),
1638                              rs6000_hard_regno_nregs[m][r]);
1639             else
1640               len += fprintf (stderr, "%s%s", comma, GET_MODE_NAME (m));
1641
1642             comma = ", ";
1643           }
1644
1645       if (call_used_regs[r])
1646         {
1647           if (len > 70)
1648             {
1649               fprintf (stderr, ",\n\t");
1650               len = 8;
1651               comma = "";
1652             }
1653
1654           len += fprintf (stderr, "%s%s", comma, "call-used");
1655           comma = ", ";
1656         }
1657
1658       if (fixed_regs[r])
1659         {
1660           if (len > 70)
1661             {
1662               fprintf (stderr, ",\n\t");
1663               len = 8;
1664               comma = "";
1665             }
1666
1667           len += fprintf (stderr, "%s%s", comma, "fixed");
1668           comma = ", ";
1669         }
1670
1671       if (len > 70)
1672         {
1673           fprintf (stderr, ",\n\t");
1674           comma = "";
1675         }
1676
1677       fprintf (stderr, "%sregno = %d\n", comma, r);
1678     }
1679 }
1680
1681 /* Print various interesting information with -mdebug=reg.  */
1682 static void
1683 rs6000_debug_reg_global (void)
1684 {
1685   const char *nl = (const char *)0;
1686   int m;
1687   char costly_num[20];
1688   char nop_num[20];
1689   const char *costly_str;
1690   const char *nop_str;
1691
1692   /* Map enum rs6000_vector to string.  */
1693   static const char *rs6000_debug_vector_unit[] = {
1694     "none",
1695     "altivec",
1696     "vsx",
1697     "paired",
1698     "spe",
1699     "other"
1700   };
1701
1702   fprintf (stderr, "Register information: (last virtual reg = %d)\n",
1703            LAST_VIRTUAL_REGISTER);
1704   rs6000_debug_reg_print (0, 31, "gr");
1705   rs6000_debug_reg_print (32, 63, "fp");
1706   rs6000_debug_reg_print (FIRST_ALTIVEC_REGNO,
1707                           LAST_ALTIVEC_REGNO,
1708                           "vs");
1709   rs6000_debug_reg_print (LR_REGNO, LR_REGNO, "lr");
1710   rs6000_debug_reg_print (CTR_REGNO, CTR_REGNO, "ctr");
1711   rs6000_debug_reg_print (CR0_REGNO, CR7_REGNO, "cr");
1712   rs6000_debug_reg_print (MQ_REGNO, MQ_REGNO, "mq");
1713   rs6000_debug_reg_print (XER_REGNO, XER_REGNO, "xer");
1714   rs6000_debug_reg_print (VRSAVE_REGNO, VRSAVE_REGNO, "vrsave");
1715   rs6000_debug_reg_print (VSCR_REGNO, VSCR_REGNO, "vscr");
1716   rs6000_debug_reg_print (SPE_ACC_REGNO, SPE_ACC_REGNO, "spe_a");
1717   rs6000_debug_reg_print (SPEFSCR_REGNO, SPEFSCR_REGNO, "spe_f");
1718
1719   fprintf (stderr,
1720            "\n"
1721            "d  reg_class = %s\n"
1722            "f  reg_class = %s\n"
1723            "v  reg_class = %s\n"
1724            "wa reg_class = %s\n"
1725            "wd reg_class = %s\n"
1726            "wf reg_class = %s\n"
1727            "ws reg_class = %s\n\n",
1728            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_d]],
1729            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_f]],
1730            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_v]],
1731            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_wa]],
1732            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_wd]],
1733            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_wf]],
1734            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_ws]]);
1735
1736   for (m = 0; m < NUM_MACHINE_MODES; ++m)
1737     if (rs6000_vector_unit[m] || rs6000_vector_mem[m])
1738       {
1739         nl = "\n";
1740         fprintf (stderr, "Vector mode: %-5s arithmetic: %-8s move: %-8s\n",
1741                  GET_MODE_NAME (m),
1742                  rs6000_debug_vector_unit[ rs6000_vector_unit[m] ],
1743                  rs6000_debug_vector_unit[ rs6000_vector_mem[m] ]);
1744       }
1745
1746   if (nl)
1747     fputs (nl, stderr);
1748
1749   switch (rs6000_sched_costly_dep)
1750     {
1751     case max_dep_latency:
1752       costly_str = "max_dep_latency";
1753       break;
1754
1755     case no_dep_costly:
1756       costly_str = "no_dep_costly";
1757       break;
1758
1759     case all_deps_costly:
1760       costly_str = "all_deps_costly";
1761       break;
1762
1763     case true_store_to_load_dep_costly:
1764       costly_str = "true_store_to_load_dep_costly";
1765       break;
1766
1767     case store_to_load_dep_costly:
1768       costly_str = "store_to_load_dep_costly";
1769       break;
1770
1771     default:
1772       costly_str = costly_num;
1773       sprintf (costly_num, "%d", (int)rs6000_sched_costly_dep);
1774       break;
1775     }
1776
1777   switch (rs6000_sched_insert_nops)
1778     {
1779     case sched_finish_regroup_exact:
1780       nop_str = "sched_finish_regroup_exact";
1781       break;
1782
1783     case sched_finish_pad_groups:
1784       nop_str = "sched_finish_pad_groups";
1785       break;
1786
1787     case sched_finish_none:
1788       nop_str = "sched_finish_none";
1789       break;
1790
1791     default:
1792       nop_str = nop_num;
1793       sprintf (nop_num, "%d", (int)rs6000_sched_insert_nops);
1794       break;
1795     }
1796
1797   fprintf (stderr,
1798            "always_hint                     = %s\n"
1799            "align_branch_targets            = %s\n"
1800            "sched_restricted_insns_priority = %d\n"
1801            "sched_costly_dep                = %s\n"
1802            "sched_insert_nops               = %s\n\n",
1803            rs6000_always_hint ? "true" : "false",
1804            rs6000_align_branch_targets ? "true" : "false",
1805            (int)rs6000_sched_restricted_insns_priority,
1806            costly_str, nop_str);
1807 }
1808
1809 /* Initialize the various global tables that are based on register size.  */
1810 static void
1811 rs6000_init_hard_regno_mode_ok (void)
1812 {
1813   int r, m, c;
1814   int align64;
1815   int align32;
1816
1817   /* Precalculate REGNO_REG_CLASS.  */
1818   rs6000_regno_regclass[0] = GENERAL_REGS;
1819   for (r = 1; r < 32; ++r)
1820     rs6000_regno_regclass[r] = BASE_REGS;
1821
1822   for (r = 32; r < 64; ++r)
1823     rs6000_regno_regclass[r] = FLOAT_REGS;
1824
1825   for (r = 64; r < FIRST_PSEUDO_REGISTER; ++r)
1826     rs6000_regno_regclass[r] = NO_REGS;
1827
1828   for (r = FIRST_ALTIVEC_REGNO; r <= LAST_ALTIVEC_REGNO; ++r)
1829     rs6000_regno_regclass[r] = ALTIVEC_REGS;
1830
1831   rs6000_regno_regclass[CR0_REGNO] = CR0_REGS;
1832   for (r = CR1_REGNO; r <= CR7_REGNO; ++r)
1833     rs6000_regno_regclass[r] = CR_REGS;
1834
1835   rs6000_regno_regclass[MQ_REGNO] = MQ_REGS;
1836   rs6000_regno_regclass[LR_REGNO] = LINK_REGS;
1837   rs6000_regno_regclass[CTR_REGNO] = CTR_REGS;
1838   rs6000_regno_regclass[XER_REGNO] = XER_REGS;
1839   rs6000_regno_regclass[VRSAVE_REGNO] = VRSAVE_REGS;
1840   rs6000_regno_regclass[VSCR_REGNO] = VRSAVE_REGS;
1841   rs6000_regno_regclass[SPE_ACC_REGNO] = SPE_ACC_REGS;
1842   rs6000_regno_regclass[SPEFSCR_REGNO] = SPEFSCR_REGS;
1843   rs6000_regno_regclass[ARG_POINTER_REGNUM] = BASE_REGS;
1844   rs6000_regno_regclass[FRAME_POINTER_REGNUM] = BASE_REGS;
1845
1846   /* Precalculate vector information, this must be set up before the
1847      rs6000_hard_regno_nregs_internal below.  */
1848   for (m = 0; m < NUM_MACHINE_MODES; ++m)
1849     {
1850       rs6000_vector_unit[m] = rs6000_vector_mem[m] = VECTOR_NONE;
1851       rs6000_vector_reload[m][0] = CODE_FOR_nothing;
1852       rs6000_vector_reload[m][1] = CODE_FOR_nothing;
1853     }
1854
1855   for (c = 0; c < (int)(int)RS6000_CONSTRAINT_MAX; c++)
1856     rs6000_constraints[c] = NO_REGS;
1857
1858   /* The VSX hardware allows native alignment for vectors, but control whether the compiler
1859      believes it can use native alignment or still uses 128-bit alignment.  */
1860   if (TARGET_VSX && !TARGET_VSX_ALIGN_128)
1861     {
1862       align64 = 64;
1863       align32 = 32;
1864     }
1865   else
1866     {
1867       align64 = 128;
1868       align32 = 128;
1869     }
1870
1871   /* V2DF mode, VSX only.  */
1872   if (TARGET_VSX)
1873     {
1874       rs6000_vector_unit[V2DFmode] = VECTOR_VSX;
1875       rs6000_vector_mem[V2DFmode] = VECTOR_VSX;
1876       rs6000_vector_align[V2DFmode] = align64;
1877     }
1878
1879   /* V4SF mode, either VSX or Altivec.  */
1880   if (TARGET_VSX)
1881     {
1882       rs6000_vector_unit[V4SFmode] = VECTOR_VSX;
1883       rs6000_vector_mem[V4SFmode] = VECTOR_VSX;
1884       rs6000_vector_align[V4SFmode] = align32;
1885     }
1886   else if (TARGET_ALTIVEC)
1887     {
1888       rs6000_vector_unit[V4SFmode] = VECTOR_ALTIVEC;
1889       rs6000_vector_mem[V4SFmode] = VECTOR_ALTIVEC;
1890       rs6000_vector_align[V4SFmode] = align32;
1891     }
1892
1893   /* V16QImode, V8HImode, V4SImode are Altivec only, but possibly do VSX loads
1894      and stores. */
1895   if (TARGET_ALTIVEC)
1896     {
1897       rs6000_vector_unit[V4SImode] = VECTOR_ALTIVEC;
1898       rs6000_vector_unit[V8HImode] = VECTOR_ALTIVEC;
1899       rs6000_vector_unit[V16QImode] = VECTOR_ALTIVEC;
1900       rs6000_vector_align[V4SImode] = align32;
1901       rs6000_vector_align[V8HImode] = align32;
1902       rs6000_vector_align[V16QImode] = align32;
1903
1904       if (TARGET_VSX)
1905         {
1906           rs6000_vector_mem[V4SImode] = VECTOR_VSX;
1907           rs6000_vector_mem[V8HImode] = VECTOR_VSX;
1908           rs6000_vector_mem[V16QImode] = VECTOR_VSX;
1909         }
1910       else
1911         {
1912           rs6000_vector_mem[V4SImode] = VECTOR_ALTIVEC;
1913           rs6000_vector_mem[V8HImode] = VECTOR_ALTIVEC;
1914           rs6000_vector_mem[V16QImode] = VECTOR_ALTIVEC;
1915         }
1916     }
1917
1918   /* V2DImode, only allow under VSX, which can do V2DI insert/splat/extract.
1919      Altivec doesn't have 64-bit support.  */
1920   if (TARGET_VSX)
1921     {
1922       rs6000_vector_mem[V2DImode] = VECTOR_VSX;
1923       rs6000_vector_unit[V2DImode] = VECTOR_NONE;
1924       rs6000_vector_align[V2DImode] = align64;
1925     }
1926
1927   /* DFmode, see if we want to use the VSX unit.  */
1928   if (TARGET_VSX && TARGET_VSX_SCALAR_DOUBLE)
1929     {
1930       rs6000_vector_unit[DFmode] = VECTOR_VSX;
1931       rs6000_vector_mem[DFmode]
1932         = (TARGET_VSX_SCALAR_MEMORY ? VECTOR_VSX : VECTOR_NONE);
1933       rs6000_vector_align[DFmode] = align64;
1934     }
1935
1936   /* TODO add SPE and paired floating point vector support.  */
1937
1938   /* Register class constaints for the constraints that depend on compile
1939      switches.  */
1940   if (TARGET_HARD_FLOAT && TARGET_FPRS)
1941     rs6000_constraints[RS6000_CONSTRAINT_f] = FLOAT_REGS;
1942
1943   if (TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT)
1944     rs6000_constraints[RS6000_CONSTRAINT_d] = FLOAT_REGS;
1945
1946   if (TARGET_VSX)
1947     {
1948       /* At present, we just use VSX_REGS, but we have different constraints
1949          based on the use, in case we want to fine tune the default register
1950          class used.  wa = any VSX register, wf = register class to use for
1951          V4SF, wd = register class to use for V2DF, and ws = register classs to
1952          use for DF scalars.  */
1953       rs6000_constraints[RS6000_CONSTRAINT_wa] = VSX_REGS;
1954       rs6000_constraints[RS6000_CONSTRAINT_wf] = VSX_REGS;
1955       rs6000_constraints[RS6000_CONSTRAINT_wd] = VSX_REGS;
1956       if (TARGET_VSX_SCALAR_DOUBLE)
1957         rs6000_constraints[RS6000_CONSTRAINT_ws] = VSX_REGS;
1958     }
1959
1960   if (TARGET_ALTIVEC)
1961     rs6000_constraints[RS6000_CONSTRAINT_v] = ALTIVEC_REGS;
1962
1963   /* Set up the reload helper functions.  */
1964   if (TARGET_VSX || TARGET_ALTIVEC)
1965     {
1966       if (TARGET_64BIT)
1967         {
1968           rs6000_vector_reload[V16QImode][0] = CODE_FOR_reload_v16qi_di_store;
1969           rs6000_vector_reload[V16QImode][1] = CODE_FOR_reload_v16qi_di_load;
1970           rs6000_vector_reload[V8HImode][0]  = CODE_FOR_reload_v8hi_di_store;
1971           rs6000_vector_reload[V8HImode][1]  = CODE_FOR_reload_v8hi_di_load;
1972           rs6000_vector_reload[V4SImode][0]  = CODE_FOR_reload_v4si_di_store;
1973           rs6000_vector_reload[V4SImode][1]  = CODE_FOR_reload_v4si_di_load;
1974           rs6000_vector_reload[V2DImode][0]  = CODE_FOR_reload_v2di_di_store;
1975           rs6000_vector_reload[V2DImode][1]  = CODE_FOR_reload_v2di_di_load;
1976           rs6000_vector_reload[V4SFmode][0]  = CODE_FOR_reload_v4sf_di_store;
1977           rs6000_vector_reload[V4SFmode][1]  = CODE_FOR_reload_v4sf_di_load;
1978           rs6000_vector_reload[V2DFmode][0]  = CODE_FOR_reload_v2df_di_store;
1979           rs6000_vector_reload[V2DFmode][1]  = CODE_FOR_reload_v2df_di_load;
1980         }
1981       else
1982         {
1983           rs6000_vector_reload[V16QImode][0] = CODE_FOR_reload_v16qi_si_store;
1984           rs6000_vector_reload[V16QImode][1] = CODE_FOR_reload_v16qi_si_load;
1985           rs6000_vector_reload[V8HImode][0]  = CODE_FOR_reload_v8hi_si_store;
1986           rs6000_vector_reload[V8HImode][1]  = CODE_FOR_reload_v8hi_si_load;
1987           rs6000_vector_reload[V4SImode][0]  = CODE_FOR_reload_v4si_si_store;
1988           rs6000_vector_reload[V4SImode][1]  = CODE_FOR_reload_v4si_si_load;
1989           rs6000_vector_reload[V2DImode][0]  = CODE_FOR_reload_v2di_si_store;
1990           rs6000_vector_reload[V2DImode][1]  = CODE_FOR_reload_v2di_si_load;
1991           rs6000_vector_reload[V4SFmode][0]  = CODE_FOR_reload_v4sf_si_store;
1992           rs6000_vector_reload[V4SFmode][1]  = CODE_FOR_reload_v4sf_si_load;
1993           rs6000_vector_reload[V2DFmode][0]  = CODE_FOR_reload_v2df_si_store;
1994           rs6000_vector_reload[V2DFmode][1]  = CODE_FOR_reload_v2df_si_load;
1995         }
1996     }
1997
1998   /* Precalculate HARD_REGNO_NREGS.  */
1999   for (r = 0; r < FIRST_PSEUDO_REGISTER; ++r)
2000     for (m = 0; m < NUM_MACHINE_MODES; ++m)
2001       rs6000_hard_regno_nregs[m][r]
2002         = rs6000_hard_regno_nregs_internal (r, (enum machine_mode)m);
2003
2004   /* Precalculate HARD_REGNO_MODE_OK.  */
2005   for (r = 0; r < FIRST_PSEUDO_REGISTER; ++r)
2006     for (m = 0; m < NUM_MACHINE_MODES; ++m)
2007       if (rs6000_hard_regno_mode_ok (r, (enum machine_mode)m))
2008         rs6000_hard_regno_mode_ok_p[m][r] = true;
2009
2010   /* Precalculate CLASS_MAX_NREGS sizes.  */
2011   for (c = 0; c < LIM_REG_CLASSES; ++c)
2012     {
2013       int reg_size;
2014
2015       if (TARGET_VSX && VSX_REG_CLASS_P (c))
2016         reg_size = UNITS_PER_VSX_WORD;
2017
2018       else if (c == ALTIVEC_REGS)
2019         reg_size = UNITS_PER_ALTIVEC_WORD;
2020
2021       else if (c == FLOAT_REGS)
2022         reg_size = UNITS_PER_FP_WORD;
2023
2024       else
2025         reg_size = UNITS_PER_WORD;
2026
2027       for (m = 0; m < NUM_MACHINE_MODES; ++m)
2028         rs6000_class_max_nregs[m][c]
2029           = (GET_MODE_SIZE (m) + reg_size - 1) / reg_size;
2030     }
2031
2032   if (TARGET_E500_DOUBLE)
2033     rs6000_class_max_nregs[DFmode][GENERAL_REGS] = 1;
2034
2035   if (TARGET_DEBUG_REG)
2036     rs6000_debug_reg_global ();
2037 }
2038
2039 #if TARGET_MACHO
2040 /* The Darwin version of SUBTARGET_OVERRIDE_OPTIONS.  */
2041
2042 static void
2043 darwin_rs6000_override_options (void)
2044 {
2045   /* The Darwin ABI always includes AltiVec, can't be (validly) turned
2046      off.  */
2047   rs6000_altivec_abi = 1;
2048   TARGET_ALTIVEC_VRSAVE = 1;
2049   if (DEFAULT_ABI == ABI_DARWIN)
2050   {
2051     if (MACHO_DYNAMIC_NO_PIC_P)
2052       {
2053         if (flag_pic)
2054             warning (0, "-mdynamic-no-pic overrides -fpic or -fPIC");
2055         flag_pic = 0;
2056       }
2057     else if (flag_pic == 1)
2058       {
2059         flag_pic = 2;
2060       }
2061   }
2062   if (TARGET_64BIT && ! TARGET_POWERPC64)
2063     {
2064       target_flags |= MASK_POWERPC64;
2065       warning (0, "-m64 requires PowerPC64 architecture, enabling");
2066     }
2067   if (flag_mkernel)
2068     {
2069       rs6000_default_long_calls = 1;
2070       target_flags |= MASK_SOFT_FLOAT;
2071     }
2072
2073   /* Make -m64 imply -maltivec.  Darwin's 64-bit ABI includes
2074      Altivec.  */
2075   if (!flag_mkernel && !flag_apple_kext
2076       && TARGET_64BIT
2077       && ! (target_flags_explicit & MASK_ALTIVEC))
2078     target_flags |= MASK_ALTIVEC;
2079
2080   /* Unless the user (not the configurer) has explicitly overridden
2081      it with -mcpu=G3 or -mno-altivec, then 10.5+ targets default to
2082      G4 unless targetting the kernel.  */
2083   if (!flag_mkernel
2084       && !flag_apple_kext
2085       && strverscmp (darwin_macosx_version_min, "10.5") >= 0
2086       && ! (target_flags_explicit & MASK_ALTIVEC)
2087       && ! rs6000_select[1].string)
2088     {
2089       target_flags |= MASK_ALTIVEC;
2090     }
2091 }
2092 #endif
2093
2094 /* If not otherwise specified by a target, make 'long double' equivalent to
2095    'double'.  */
2096
2097 #ifndef RS6000_DEFAULT_LONG_DOUBLE_SIZE
2098 #define RS6000_DEFAULT_LONG_DOUBLE_SIZE 64
2099 #endif
2100
2101 /* Override command line options.  Mostly we process the processor
2102    type and sometimes adjust other TARGET_ options.  */
2103
2104 void
2105 rs6000_override_options (const char *default_cpu)
2106 {
2107   size_t i, j;
2108   struct rs6000_cpu_select *ptr;
2109   int set_masks;
2110
2111   /* Simplifications for entries below.  */
2112
2113   enum {
2114     POWERPC_BASE_MASK = MASK_POWERPC | MASK_NEW_MNEMONICS,
2115     POWERPC_7400_MASK = POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_ALTIVEC
2116   };
2117
2118   /* This table occasionally claims that a processor does not support
2119      a particular feature even though it does, but the feature is slower
2120      than the alternative.  Thus, it shouldn't be relied on as a
2121      complete description of the processor's support.
2122
2123      Please keep this list in order, and don't forget to update the
2124      documentation in invoke.texi when adding a new processor or
2125      flag.  */
2126   static struct ptt
2127     {
2128       const char *const name;           /* Canonical processor name.  */
2129       const enum processor_type processor; /* Processor type enum value.  */
2130       const int target_enable;  /* Target flags to enable.  */
2131     } const processor_target_table[]
2132       = {{"401", PROCESSOR_PPC403, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
2133          {"403", PROCESSOR_PPC403,
2134           POWERPC_BASE_MASK | MASK_SOFT_FLOAT | MASK_STRICT_ALIGN},
2135          {"405", PROCESSOR_PPC405,
2136           POWERPC_BASE_MASK | MASK_SOFT_FLOAT | MASK_MULHW | MASK_DLMZB},
2137          {"405fp", PROCESSOR_PPC405,
2138           POWERPC_BASE_MASK | MASK_MULHW | MASK_DLMZB},
2139          {"440", PROCESSOR_PPC440,
2140           POWERPC_BASE_MASK | MASK_SOFT_FLOAT | MASK_MULHW | MASK_DLMZB},
2141          {"440fp", PROCESSOR_PPC440,
2142           POWERPC_BASE_MASK | MASK_MULHW | MASK_DLMZB},
2143          {"464", PROCESSOR_PPC440,
2144           POWERPC_BASE_MASK | MASK_SOFT_FLOAT | MASK_MULHW | MASK_DLMZB},
2145          {"464fp", PROCESSOR_PPC440,
2146           POWERPC_BASE_MASK | MASK_MULHW | MASK_DLMZB},
2147          {"505", PROCESSOR_MPCCORE, POWERPC_BASE_MASK},
2148          {"601", PROCESSOR_PPC601,
2149           MASK_POWER | POWERPC_BASE_MASK | MASK_MULTIPLE | MASK_STRING},
2150          {"602", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
2151          {"603", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
2152          {"603e", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
2153          {"604", PROCESSOR_PPC604, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
2154          {"604e", PROCESSOR_PPC604e, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
2155          {"620", PROCESSOR_PPC620,
2156           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
2157          {"630", PROCESSOR_PPC630,
2158           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
2159          {"740", PROCESSOR_PPC750, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
2160          {"7400", PROCESSOR_PPC7400, POWERPC_7400_MASK},
2161          {"7450", PROCESSOR_PPC7450, POWERPC_7400_MASK},
2162          {"750", PROCESSOR_PPC750, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
2163          {"801", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
2164          {"821", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
2165          {"823", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
2166          {"8540", PROCESSOR_PPC8540, POWERPC_BASE_MASK | MASK_STRICT_ALIGN
2167           | MASK_ISEL},
2168          /* 8548 has a dummy entry for now.  */
2169          {"8548", PROCESSOR_PPC8540, POWERPC_BASE_MASK | MASK_STRICT_ALIGN
2170           | MASK_ISEL},
2171          {"a2", PROCESSOR_PPCA2,
2172           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64 | MASK_POPCNTB
2173           | MASK_CMPB | MASK_NO_UPDATE },
2174          {"e300c2", PROCESSOR_PPCE300C2, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
2175          {"e300c3", PROCESSOR_PPCE300C3, POWERPC_BASE_MASK},
2176          {"e500mc", PROCESSOR_PPCE500MC, POWERPC_BASE_MASK | MASK_PPC_GFXOPT
2177           | MASK_ISEL},
2178          {"860", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
2179          {"970", PROCESSOR_POWER4,
2180           POWERPC_7400_MASK | MASK_PPC_GPOPT | MASK_MFCRF | MASK_POWERPC64},
2181          {"cell", PROCESSOR_CELL,
2182           POWERPC_7400_MASK  | MASK_PPC_GPOPT | MASK_MFCRF | MASK_POWERPC64},
2183          {"common", PROCESSOR_COMMON, MASK_NEW_MNEMONICS},
2184          {"ec603e", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
2185          {"G3", PROCESSOR_PPC750, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
2186          {"G4",  PROCESSOR_PPC7450, POWERPC_7400_MASK},
2187          {"G5", PROCESSOR_POWER4,
2188           POWERPC_7400_MASK | MASK_PPC_GPOPT | MASK_MFCRF | MASK_POWERPC64},
2189          {"power", PROCESSOR_POWER, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
2190          {"power2", PROCESSOR_POWER,
2191           MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING},
2192          {"power3", PROCESSOR_PPC630,
2193           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
2194          {"power4", PROCESSOR_POWER4,
2195           POWERPC_BASE_MASK | MASK_POWERPC64 | MASK_PPC_GPOPT | MASK_PPC_GFXOPT
2196           | MASK_MFCRF},
2197          {"power5", PROCESSOR_POWER5,
2198           POWERPC_BASE_MASK | MASK_POWERPC64 | MASK_PPC_GPOPT | MASK_PPC_GFXOPT
2199           | MASK_MFCRF | MASK_POPCNTB},
2200          {"power5+", PROCESSOR_POWER5,
2201           POWERPC_BASE_MASK | MASK_POWERPC64 | MASK_PPC_GPOPT | MASK_PPC_GFXOPT
2202           | MASK_MFCRF | MASK_POPCNTB | MASK_FPRND},
2203          {"power6", PROCESSOR_POWER6,
2204           POWERPC_BASE_MASK | MASK_POWERPC64 | MASK_PPC_GPOPT | MASK_PPC_GFXOPT
2205           | MASK_MFCRF | MASK_POPCNTB | MASK_FPRND | MASK_CMPB | MASK_DFP},
2206          {"power6x", PROCESSOR_POWER6,
2207           POWERPC_BASE_MASK | MASK_POWERPC64 | MASK_PPC_GPOPT | MASK_PPC_GFXOPT
2208           | MASK_MFCRF | MASK_POPCNTB | MASK_FPRND | MASK_CMPB | MASK_DFP
2209           | MASK_MFPGPR},
2210          {"power7", PROCESSOR_POWER7,
2211           POWERPC_7400_MASK | MASK_POWERPC64 | MASK_PPC_GPOPT | MASK_MFCRF
2212           | MASK_POPCNTB | MASK_FPRND | MASK_CMPB | MASK_DFP | MASK_POPCNTD
2213           | MASK_VSX},          /* Don't add MASK_ISEL by default */
2214          {"powerpc", PROCESSOR_POWERPC, POWERPC_BASE_MASK},
2215          {"powerpc64", PROCESSOR_POWERPC64,
2216           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
2217          {"rios", PROCESSOR_RIOS1, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
2218          {"rios1", PROCESSOR_RIOS1, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
2219          {"rios2", PROCESSOR_RIOS2,
2220           MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING},
2221          {"rsc", PROCESSOR_PPC601, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
2222          {"rsc1", PROCESSOR_PPC601, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
2223          {"rs64", PROCESSOR_RS64A,
2224           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64}
2225       };
2226
2227   const size_t ptt_size = ARRAY_SIZE (processor_target_table);
2228
2229   /* Some OSs don't support saving the high part of 64-bit registers on
2230      context switch.  Other OSs don't support saving Altivec registers.
2231      On those OSs, we don't touch the MASK_POWERPC64 or MASK_ALTIVEC
2232      settings; if the user wants either, the user must explicitly specify
2233      them and we won't interfere with the user's specification.  */
2234
2235   enum {
2236     POWER_MASKS = MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING,
2237     POWERPC_MASKS = (POWERPC_BASE_MASK | MASK_PPC_GPOPT | MASK_STRICT_ALIGN
2238                      | MASK_PPC_GFXOPT | MASK_POWERPC64 | MASK_ALTIVEC
2239                      | MASK_MFCRF | MASK_POPCNTB | MASK_FPRND | MASK_MULHW
2240                      | MASK_DLMZB | MASK_CMPB | MASK_MFPGPR | MASK_DFP
2241                      | MASK_POPCNTD | MASK_VSX | MASK_ISEL | MASK_NO_UPDATE)
2242   };
2243
2244   /* Set the pointer size.  */
2245   if (TARGET_64BIT)
2246     {
2247       rs6000_pmode = (int)DImode;
2248       rs6000_pointer_size = 64;
2249     }
2250   else
2251     {
2252       rs6000_pmode = (int)SImode;
2253       rs6000_pointer_size = 32;
2254     }
2255
2256   set_masks = POWER_MASKS | POWERPC_MASKS | MASK_SOFT_FLOAT;
2257 #ifdef OS_MISSING_POWERPC64
2258   if (OS_MISSING_POWERPC64)
2259     set_masks &= ~MASK_POWERPC64;
2260 #endif
2261 #ifdef OS_MISSING_ALTIVEC
2262   if (OS_MISSING_ALTIVEC)
2263     set_masks &= ~MASK_ALTIVEC;
2264 #endif
2265
2266   /* Don't override by the processor default if given explicitly.  */
2267   set_masks &= ~target_flags_explicit;
2268
2269   /* Identify the processor type.  */
2270   rs6000_select[0].string = default_cpu;
2271   rs6000_cpu = TARGET_POWERPC64 ? PROCESSOR_DEFAULT64 : PROCESSOR_DEFAULT;
2272
2273   for (i = 0; i < ARRAY_SIZE (rs6000_select); i++)
2274     {
2275       ptr = &rs6000_select[i];
2276       if (ptr->string != (char *)0 && ptr->string[0] != '\0')
2277         {
2278           for (j = 0; j < ptt_size; j++)
2279             if (! strcmp (ptr->string, processor_target_table[j].name))
2280               {
2281                 if (ptr->set_tune_p)
2282                   rs6000_cpu = processor_target_table[j].processor;
2283
2284                 if (ptr->set_arch_p)
2285                   {
2286                     target_flags &= ~set_masks;
2287                     target_flags |= (processor_target_table[j].target_enable
2288                                      & set_masks);
2289                   }
2290                 break;
2291               }
2292
2293           if (j == ptt_size)
2294             error ("bad value (%s) for %s switch", ptr->string, ptr->name);
2295         }
2296     }
2297
2298   if (rs6000_cpu == PROCESSOR_PPCE300C2 || rs6000_cpu == PROCESSOR_PPCE300C3
2299       || rs6000_cpu == PROCESSOR_PPCE500MC)
2300     {
2301       if (TARGET_ALTIVEC)
2302         error ("AltiVec not supported in this target");
2303       if (TARGET_SPE)
2304         error ("Spe not supported in this target");
2305     }
2306
2307   /* Disable Cell microcode if we are optimizing for the Cell
2308      and not optimizing for size.  */
2309   if (rs6000_gen_cell_microcode == -1)
2310     rs6000_gen_cell_microcode = !(rs6000_cpu == PROCESSOR_CELL
2311                                   && !optimize_size);
2312
2313   /* If we are optimizing big endian systems for space, use the load/store
2314      multiple and string instructions unless we are not generating
2315      Cell microcode.  */
2316   if (BYTES_BIG_ENDIAN && optimize_size && !rs6000_gen_cell_microcode)
2317     target_flags |= ~target_flags_explicit & (MASK_MULTIPLE | MASK_STRING);
2318
2319   /* Don't allow -mmultiple or -mstring on little endian systems
2320      unless the cpu is a 750, because the hardware doesn't support the
2321      instructions used in little endian mode, and causes an alignment
2322      trap.  The 750 does not cause an alignment trap (except when the
2323      target is unaligned).  */
2324
2325   if (!BYTES_BIG_ENDIAN && rs6000_cpu != PROCESSOR_PPC750)
2326     {
2327       if (TARGET_MULTIPLE)
2328         {
2329           target_flags &= ~MASK_MULTIPLE;
2330           if ((target_flags_explicit & MASK_MULTIPLE) != 0)
2331             warning (0, "-mmultiple is not supported on little endian systems");
2332         }
2333
2334       if (TARGET_STRING)
2335         {
2336           target_flags &= ~MASK_STRING;
2337           if ((target_flags_explicit & MASK_STRING) != 0)
2338             warning (0, "-mstring is not supported on little endian systems");
2339         }
2340     }
2341
2342   /* Add some warnings for VSX.  Enable -maltivec unless the user explicitly
2343      used -mno-altivec  */
2344   if (TARGET_VSX)
2345     {
2346       const char *msg = NULL;
2347       if (!TARGET_HARD_FLOAT || !TARGET_FPRS
2348           || !TARGET_SINGLE_FLOAT || !TARGET_DOUBLE_FLOAT)
2349         {
2350           if (target_flags_explicit & MASK_VSX)
2351             msg = N_("-mvsx requires hardware floating point");
2352           else
2353             target_flags &= ~ MASK_VSX;
2354         }
2355       else if (TARGET_PAIRED_FLOAT)
2356         msg = N_("-mvsx and -mpaired are incompatible");
2357       /* The hardware will allow VSX and little endian, but until we make sure
2358          things like vector select, etc. work don't allow VSX on little endian
2359          systems at this point.  */
2360       else if (!BYTES_BIG_ENDIAN)
2361         msg = N_("-mvsx used with little endian code");
2362       else if (TARGET_AVOID_XFORM > 0)
2363         msg = N_("-mvsx needs indexed addressing");
2364
2365       if (msg)
2366         {
2367           warning (0, msg);
2368           target_flags &= ~ MASK_VSX;
2369         }
2370       else if (TARGET_VSX && !TARGET_ALTIVEC
2371                && (target_flags_explicit & MASK_ALTIVEC) == 0)
2372         target_flags |= MASK_ALTIVEC;
2373     }
2374
2375   /* Set debug flags */
2376   if (rs6000_debug_name)
2377     {
2378       if (! strcmp (rs6000_debug_name, "all"))
2379         rs6000_debug_stack = rs6000_debug_arg = rs6000_debug_reg
2380           = rs6000_debug_addr = rs6000_debug_cost = 1;
2381       else if (! strcmp (rs6000_debug_name, "stack"))
2382         rs6000_debug_stack = 1;
2383       else if (! strcmp (rs6000_debug_name, "arg"))
2384         rs6000_debug_arg = 1;
2385       else if (! strcmp (rs6000_debug_name, "reg"))
2386         rs6000_debug_reg = 1;
2387       else if (! strcmp (rs6000_debug_name, "addr"))
2388         rs6000_debug_addr = 1;
2389       else if (! strcmp (rs6000_debug_name, "cost"))
2390         rs6000_debug_cost = 1;
2391       else
2392         error ("unknown -mdebug-%s switch", rs6000_debug_name);
2393
2394       /* If the appropriate debug option is enabled, replace the target hooks
2395          with debug versions that call the real version and then prints
2396          debugging information.  */
2397       if (TARGET_DEBUG_COST)
2398         {
2399           targetm.rtx_costs = rs6000_debug_rtx_costs;
2400           targetm.address_cost = rs6000_debug_address_cost;
2401           targetm.sched.adjust_cost = rs6000_debug_adjust_cost;
2402         }
2403
2404       if (TARGET_DEBUG_ADDR)
2405         {
2406           targetm.legitimate_address_p = rs6000_debug_legitimate_address_p;
2407           targetm.legitimize_address = rs6000_debug_legitimize_address;
2408           rs6000_secondary_reload_class_ptr
2409             = rs6000_debug_secondary_reload_class;
2410           rs6000_secondary_memory_needed_ptr
2411             = rs6000_debug_secondary_memory_needed;
2412           rs6000_cannot_change_mode_class_ptr
2413             = rs6000_debug_cannot_change_mode_class;
2414           rs6000_preferred_reload_class_ptr
2415             = rs6000_debug_preferred_reload_class;
2416           rs6000_legitimize_reload_address_ptr
2417             = rs6000_debug_legitimize_reload_address;
2418           rs6000_mode_dependent_address_ptr
2419             = rs6000_debug_mode_dependent_address;
2420         }
2421     }
2422
2423   if (rs6000_traceback_name)
2424     {
2425       if (! strncmp (rs6000_traceback_name, "full", 4))
2426         rs6000_traceback = traceback_full;
2427       else if (! strncmp (rs6000_traceback_name, "part", 4))
2428         rs6000_traceback = traceback_part;
2429       else if (! strncmp (rs6000_traceback_name, "no", 2))
2430         rs6000_traceback = traceback_none;
2431       else
2432         error ("unknown -mtraceback arg %qs; expecting %<full%>, %<partial%> or %<none%>",
2433                rs6000_traceback_name);
2434     }
2435
2436   if (!rs6000_explicit_options.long_double)
2437     rs6000_long_double_type_size = RS6000_DEFAULT_LONG_DOUBLE_SIZE;
2438
2439 #ifndef POWERPC_LINUX
2440   if (!rs6000_explicit_options.ieee)
2441     rs6000_ieeequad = 1;
2442 #endif
2443
2444   /* Enable Altivec ABI for AIX -maltivec.  */
2445   if (TARGET_XCOFF && (TARGET_ALTIVEC || TARGET_VSX))
2446     rs6000_altivec_abi = 1;
2447
2448   /* The AltiVec ABI is the default for PowerPC-64 GNU/Linux.  For
2449      PowerPC-32 GNU/Linux, -maltivec implies the AltiVec ABI.  It can
2450      be explicitly overridden in either case.  */
2451   if (TARGET_ELF)
2452     {
2453       if (!rs6000_explicit_options.altivec_abi
2454           && (TARGET_64BIT || TARGET_ALTIVEC || TARGET_VSX))
2455         rs6000_altivec_abi = 1;
2456
2457       /* Enable VRSAVE for AltiVec ABI, unless explicitly overridden.  */
2458       if (!rs6000_explicit_options.vrsave)
2459         TARGET_ALTIVEC_VRSAVE = rs6000_altivec_abi;
2460     }
2461
2462   /* Set the Darwin64 ABI as default for 64-bit Darwin.  */
2463   if (DEFAULT_ABI == ABI_DARWIN && TARGET_64BIT)
2464     {
2465       rs6000_darwin64_abi = 1;
2466 #if TARGET_MACHO
2467       darwin_one_byte_bool = 1;
2468 #endif
2469       /* Default to natural alignment, for better performance.  */
2470       rs6000_alignment_flags = MASK_ALIGN_NATURAL;
2471     }
2472
2473   /* Place FP constants in the constant pool instead of TOC
2474      if section anchors enabled.  */
2475   if (flag_section_anchors)
2476     TARGET_NO_FP_IN_TOC = 1;
2477
2478   /* Handle -mtls-size option.  */
2479   rs6000_parse_tls_size_option ();
2480
2481 #ifdef SUBTARGET_OVERRIDE_OPTIONS
2482   SUBTARGET_OVERRIDE_OPTIONS;
2483 #endif
2484 #ifdef SUBSUBTARGET_OVERRIDE_OPTIONS
2485   SUBSUBTARGET_OVERRIDE_OPTIONS;
2486 #endif
2487 #ifdef SUB3TARGET_OVERRIDE_OPTIONS
2488   SUB3TARGET_OVERRIDE_OPTIONS;
2489 #endif
2490
2491   if (TARGET_E500 || rs6000_cpu == PROCESSOR_PPCE500MC)
2492     {
2493       /* The e500 and e500mc do not have string instructions, and we set
2494          MASK_STRING above when optimizing for size.  */
2495       if ((target_flags & MASK_STRING) != 0)
2496         target_flags = target_flags & ~MASK_STRING;
2497     }
2498   else if (rs6000_select[1].string != NULL)
2499     {
2500       /* For the powerpc-eabispe configuration, we set all these by
2501          default, so let's unset them if we manually set another
2502          CPU that is not the E500.  */
2503       if (!rs6000_explicit_options.spe_abi)
2504         rs6000_spe_abi = 0;
2505       if (!rs6000_explicit_options.spe)
2506         rs6000_spe = 0;
2507       if (!rs6000_explicit_options.float_gprs)
2508         rs6000_float_gprs = 0;
2509       if (!(target_flags_explicit & MASK_ISEL))
2510         target_flags &= ~MASK_ISEL;
2511     }
2512
2513   /* Detect invalid option combinations with E500.  */
2514   CHECK_E500_OPTIONS;
2515
2516   rs6000_always_hint = (rs6000_cpu != PROCESSOR_POWER4
2517                         && rs6000_cpu != PROCESSOR_POWER5
2518                         && rs6000_cpu != PROCESSOR_POWER6
2519                         && rs6000_cpu != PROCESSOR_POWER7
2520                         && rs6000_cpu != PROCESSOR_PPCA2
2521                         && rs6000_cpu != PROCESSOR_CELL);
2522   rs6000_sched_groups = (rs6000_cpu == PROCESSOR_POWER4
2523                          || rs6000_cpu == PROCESSOR_POWER5
2524                          || rs6000_cpu == PROCESSOR_POWER7);
2525   rs6000_align_branch_targets = (rs6000_cpu == PROCESSOR_POWER4
2526                                  || rs6000_cpu == PROCESSOR_POWER5
2527                                  || rs6000_cpu == PROCESSOR_POWER6
2528                                  || rs6000_cpu == PROCESSOR_POWER7);
2529
2530   /* Allow debug switches to override the above settings.  */
2531   if (TARGET_ALWAYS_HINT > 0)
2532     rs6000_always_hint = TARGET_ALWAYS_HINT;
2533
2534   if (TARGET_SCHED_GROUPS > 0)
2535     rs6000_sched_groups = TARGET_SCHED_GROUPS;
2536
2537   if (TARGET_ALIGN_BRANCH_TARGETS > 0)
2538     rs6000_align_branch_targets = TARGET_ALIGN_BRANCH_TARGETS;
2539
2540   rs6000_sched_restricted_insns_priority
2541     = (rs6000_sched_groups ? 1 : 0);
2542
2543   /* Handle -msched-costly-dep option.  */
2544   rs6000_sched_costly_dep
2545     = (rs6000_sched_groups ? store_to_load_dep_costly : no_dep_costly);
2546
2547   if (rs6000_sched_costly_dep_str)
2548     {
2549       if (! strcmp (rs6000_sched_costly_dep_str, "no"))
2550         rs6000_sched_costly_dep = no_dep_costly;
2551       else if (! strcmp (rs6000_sched_costly_dep_str, "all"))
2552         rs6000_sched_costly_dep = all_deps_costly;
2553       else if (! strcmp (rs6000_sched_costly_dep_str, "true_store_to_load"))
2554         rs6000_sched_costly_dep = true_store_to_load_dep_costly;
2555       else if (! strcmp (rs6000_sched_costly_dep_str, "store_to_load"))
2556         rs6000_sched_costly_dep = store_to_load_dep_costly;
2557       else
2558         rs6000_sched_costly_dep = ((enum rs6000_dependence_cost)
2559                                    atoi (rs6000_sched_costly_dep_str));
2560     }
2561
2562   /* Handle -minsert-sched-nops option.  */
2563   rs6000_sched_insert_nops
2564     = (rs6000_sched_groups ? sched_finish_regroup_exact : sched_finish_none);
2565
2566   if (rs6000_sched_insert_nops_str)
2567     {
2568       if (! strcmp (rs6000_sched_insert_nops_str, "no"))
2569         rs6000_sched_insert_nops = sched_finish_none;
2570       else if (! strcmp (rs6000_sched_insert_nops_str, "pad"))
2571         rs6000_sched_insert_nops = sched_finish_pad_groups;
2572       else if (! strcmp (rs6000_sched_insert_nops_str, "regroup_exact"))
2573         rs6000_sched_insert_nops = sched_finish_regroup_exact;
2574       else
2575         rs6000_sched_insert_nops = ((enum rs6000_nop_insertion)
2576                                     atoi (rs6000_sched_insert_nops_str));
2577     }
2578
2579 #ifdef TARGET_REGNAMES
2580   /* If the user desires alternate register names, copy in the
2581      alternate names now.  */
2582   if (TARGET_REGNAMES)
2583     memcpy (rs6000_reg_names, alt_reg_names, sizeof (rs6000_reg_names));
2584 #endif
2585
2586   /* Set aix_struct_return last, after the ABI is determined.
2587      If -maix-struct-return or -msvr4-struct-return was explicitly
2588      used, don't override with the ABI default.  */
2589   if (!rs6000_explicit_options.aix_struct_ret)
2590     aix_struct_return = (DEFAULT_ABI != ABI_V4 || DRAFT_V4_STRUCT_RET);
2591
2592   if (TARGET_LONG_DOUBLE_128 && !TARGET_IEEEQUAD)
2593     REAL_MODE_FORMAT (TFmode) = &ibm_extended_format;
2594
2595   if (TARGET_TOC)
2596     ASM_GENERATE_INTERNAL_LABEL (toc_label_name, "LCTOC", 1);
2597
2598   /* We can only guarantee the availability of DI pseudo-ops when
2599      assembling for 64-bit targets.  */
2600   if (!TARGET_64BIT)
2601     {
2602       targetm.asm_out.aligned_op.di = NULL;
2603       targetm.asm_out.unaligned_op.di = NULL;
2604     }
2605
2606   /* Set branch target alignment, if not optimizing for size.  */
2607   if (!optimize_size)
2608     {
2609       /* Cell wants to be aligned 8byte for dual issue. */
2610       if (rs6000_cpu == PROCESSOR_CELL)
2611         {
2612           if (align_functions <= 0)
2613             align_functions = 8;
2614           if (align_jumps <= 0)
2615             align_jumps = 8;
2616           if (align_loops <= 0)
2617             align_loops = 8;
2618         }
2619       if (rs6000_align_branch_targets)
2620         {
2621           if (align_functions <= 0)
2622             align_functions = 16;
2623           if (align_jumps <= 0)
2624             align_jumps = 16;
2625           if (align_loops <= 0)
2626             align_loops = 16;
2627         }
2628       if (align_jumps_max_skip <= 0)
2629         align_jumps_max_skip = 15;
2630       if (align_loops_max_skip <= 0)
2631         align_loops_max_skip = 15;
2632     }
2633
2634   /* Arrange to save and restore machine status around nested functions.  */
2635   init_machine_status = rs6000_init_machine_status;
2636
2637   /* We should always be splitting complex arguments, but we can't break
2638      Linux and Darwin ABIs at the moment.  For now, only AIX is fixed.  */
2639   if (DEFAULT_ABI != ABI_AIX)
2640     targetm.calls.split_complex_arg = NULL;
2641
2642   /* Initialize rs6000_cost with the appropriate target costs.  */
2643   if (optimize_size)
2644     rs6000_cost = TARGET_POWERPC64 ? &size64_cost : &size32_cost;
2645   else
2646     switch (rs6000_cpu)
2647       {
2648       case PROCESSOR_RIOS1:
2649         rs6000_cost = &rios1_cost;
2650         break;
2651
2652       case PROCESSOR_RIOS2:
2653         rs6000_cost = &rios2_cost;
2654         break;
2655
2656       case PROCESSOR_RS64A:
2657         rs6000_cost = &rs64a_cost;
2658         break;
2659
2660       case PROCESSOR_MPCCORE:
2661         rs6000_cost = &mpccore_cost;
2662         break;
2663
2664       case PROCESSOR_PPC403:
2665         rs6000_cost = &ppc403_cost;
2666         break;
2667
2668       case PROCESSOR_PPC405:
2669         rs6000_cost = &ppc405_cost;
2670         break;
2671
2672       case PROCESSOR_PPC440:
2673         rs6000_cost = &ppc440_cost;
2674         break;
2675
2676       case PROCESSOR_PPC601:
2677         rs6000_cost = &ppc601_cost;
2678         break;
2679
2680       case PROCESSOR_PPC603:
2681         rs6000_cost = &ppc603_cost;
2682         break;
2683
2684       case PROCESSOR_PPC604:
2685         rs6000_cost = &ppc604_cost;
2686         break;
2687
2688       case PROCESSOR_PPC604e:
2689         rs6000_cost = &ppc604e_cost;
2690         break;
2691
2692       case PROCESSOR_PPC620:
2693         rs6000_cost = &ppc620_cost;
2694         break;
2695
2696       case PROCESSOR_PPC630:
2697         rs6000_cost = &ppc630_cost;
2698         break;
2699
2700       case PROCESSOR_CELL:
2701         rs6000_cost = &ppccell_cost;
2702         break;
2703
2704       case PROCESSOR_PPC750:
2705       case PROCESSOR_PPC7400:
2706         rs6000_cost = &ppc750_cost;
2707         break;
2708
2709       case PROCESSOR_PPC7450:
2710         rs6000_cost = &ppc7450_cost;
2711         break;
2712
2713       case PROCESSOR_PPC8540:
2714         rs6000_cost = &ppc8540_cost;
2715         break;
2716
2717       case PROCESSOR_PPCE300C2:
2718       case PROCESSOR_PPCE300C3:
2719         rs6000_cost = &ppce300c2c3_cost;
2720         break;
2721
2722       case PROCESSOR_PPCE500MC:
2723         rs6000_cost = &ppce500mc_cost;
2724         break;
2725
2726       case PROCESSOR_POWER4:
2727       case PROCESSOR_POWER5:
2728         rs6000_cost = &power4_cost;
2729         break;
2730
2731       case PROCESSOR_POWER6:
2732         rs6000_cost = &power6_cost;
2733         break;
2734
2735       case PROCESSOR_POWER7:
2736         rs6000_cost = &power7_cost;
2737         break;
2738
2739       case PROCESSOR_PPCA2:
2740         rs6000_cost = &ppca2_cost;
2741         break;
2742
2743       default:
2744         gcc_unreachable ();
2745       }
2746
2747   if (!PARAM_SET_P (PARAM_SIMULTANEOUS_PREFETCHES))
2748     set_param_value ("simultaneous-prefetches",
2749                      rs6000_cost->simultaneous_prefetches);
2750   if (!PARAM_SET_P (PARAM_L1_CACHE_SIZE))
2751     set_param_value ("l1-cache-size", rs6000_cost->l1_cache_size);
2752   if (!PARAM_SET_P (PARAM_L1_CACHE_LINE_SIZE))
2753     set_param_value ("l1-cache-line-size", rs6000_cost->cache_line_size);
2754   if (!PARAM_SET_P (PARAM_L2_CACHE_SIZE))
2755     set_param_value ("l2-cache-size", rs6000_cost->l2_cache_size);
2756
2757   /* If using typedef char *va_list, signal that __builtin_va_start (&ap, 0)
2758      can be optimized to ap = __builtin_next_arg (0).  */
2759   if (DEFAULT_ABI != ABI_V4)
2760     targetm.expand_builtin_va_start = NULL;
2761
2762   /* Set up single/double float flags.  
2763      If TARGET_HARD_FLOAT is set, but neither single or double is set, 
2764      then set both flags. */
2765   if (TARGET_HARD_FLOAT && TARGET_FPRS 
2766       && rs6000_single_float == 0 && rs6000_double_float == 0)
2767     rs6000_single_float = rs6000_double_float = 1;
2768
2769   /* Reset single and double FP flags if target is E500. */
2770   if (TARGET_E500) 
2771   {
2772     rs6000_single_float = rs6000_double_float = 0;
2773     if (TARGET_E500_SINGLE)
2774       rs6000_single_float = 1; 
2775     if (TARGET_E500_DOUBLE)
2776       rs6000_single_float = rs6000_double_float = 1;
2777   }
2778
2779   /* If not explicitly specified via option, decide whether to generate indexed
2780      load/store instructions.  */
2781   if (TARGET_AVOID_XFORM == -1)
2782     /* Avoid indexed addressing when targeting Power6 in order to avoid
2783      the DERAT mispredict penalty.  */
2784     TARGET_AVOID_XFORM = (rs6000_cpu == PROCESSOR_POWER6 && TARGET_CMPB);
2785
2786   rs6000_init_hard_regno_mode_ok ();
2787 }
2788
2789 /* Implement targetm.vectorize.builtin_mask_for_load.  */
2790 static tree
2791 rs6000_builtin_mask_for_load (void)
2792 {
2793   if (TARGET_ALTIVEC || TARGET_VSX)
2794     return altivec_builtin_mask_for_load;
2795   else
2796     return 0;
2797 }
2798
2799 /* Implement targetm.vectorize.builtin_conversion.
2800    Returns a decl of a function that implements conversion of an integer vector
2801    into a floating-point vector, or vice-versa. TYPE is the type of the integer
2802    side of the conversion.
2803    Return NULL_TREE if it is not available.  */
2804 static tree
2805 rs6000_builtin_conversion (unsigned int tcode, tree type)
2806 {
2807   enum tree_code code = (enum tree_code) tcode;
2808
2809   switch (code)
2810     {
2811     case FIX_TRUNC_EXPR:
2812       switch (TYPE_MODE (type))
2813         {
2814         case V2DImode:
2815           if (!VECTOR_UNIT_VSX_P (V2DFmode))
2816             return NULL_TREE;
2817
2818           return TYPE_UNSIGNED (type)
2819             ? rs6000_builtin_decls[VSX_BUILTIN_XVCVDPUXDS_UNS]
2820             : rs6000_builtin_decls[VSX_BUILTIN_XVCVDPSXDS];
2821
2822         case V4SImode:
2823           if (VECTOR_UNIT_NONE_P (V4SImode) || VECTOR_UNIT_NONE_P (V4SFmode))
2824             return NULL_TREE;
2825
2826           return TYPE_UNSIGNED (type)
2827             ? rs6000_builtin_decls[VECTOR_BUILTIN_FIXUNS_V4SF_V4SI]
2828             : rs6000_builtin_decls[VECTOR_BUILTIN_FIX_V4SF_V4SI];
2829
2830         default:
2831           return NULL_TREE;
2832         }
2833
2834     case FLOAT_EXPR:
2835       switch (TYPE_MODE (type))
2836         {
2837         case V2DImode:
2838           if (!VECTOR_UNIT_VSX_P (V2DFmode))
2839             return NULL_TREE;
2840
2841           return TYPE_UNSIGNED (type)
2842             ? rs6000_builtin_decls[VSX_BUILTIN_XVCVUXDDP]
2843             : rs6000_builtin_decls[VSX_BUILTIN_XVCVSXDDP];
2844
2845         case V4SImode:
2846           if (VECTOR_UNIT_NONE_P (V4SImode) || VECTOR_UNIT_NONE_P (V4SFmode))
2847             return NULL_TREE;
2848
2849           return TYPE_UNSIGNED (type)
2850             ? rs6000_builtin_decls[VECTOR_BUILTIN_UNSFLOAT_V4SI_V4SF]
2851             : rs6000_builtin_decls[VECTOR_BUILTIN_FLOAT_V4SI_V4SF];
2852
2853         default:
2854           return NULL_TREE;
2855         }
2856
2857     default:
2858       return NULL_TREE;
2859     }
2860 }
2861
2862 /* Implement targetm.vectorize.builtin_mul_widen_even.  */
2863 static tree
2864 rs6000_builtin_mul_widen_even (tree type)
2865 {
2866   if (!TARGET_ALTIVEC)
2867     return NULL_TREE;
2868
2869   switch (TYPE_MODE (type))
2870     {
2871     case V8HImode:
2872       return TYPE_UNSIGNED (type)
2873             ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULEUH_UNS]
2874             : rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULESH];
2875
2876     case V16QImode:
2877       return TYPE_UNSIGNED (type)
2878             ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULEUB_UNS]
2879             : rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULESB];
2880     default:
2881       return NULL_TREE;
2882     }
2883 }
2884
2885 /* Implement targetm.vectorize.builtin_mul_widen_odd.  */
2886 static tree
2887 rs6000_builtin_mul_widen_odd (tree type)
2888 {
2889   if (!TARGET_ALTIVEC)
2890     return NULL_TREE;
2891
2892   switch (TYPE_MODE (type))
2893     {
2894     case V8HImode:
2895       return TYPE_UNSIGNED (type)
2896             ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOUH_UNS]
2897             : rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOSH];
2898
2899     case V16QImode:
2900       return TYPE_UNSIGNED (type)
2901             ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOUB_UNS]
2902             : rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOSB];
2903     default:
2904       return NULL_TREE;
2905     }
2906 }
2907
2908
2909 /* Return true iff, data reference of TYPE can reach vector alignment (16)
2910    after applying N number of iterations.  This routine does not determine
2911    how may iterations are required to reach desired alignment.  */
2912
2913 static bool
2914 rs6000_vector_alignment_reachable (const_tree type ATTRIBUTE_UNUSED, bool is_packed)
2915 {
2916   if (is_packed)
2917     return false;
2918
2919   if (TARGET_32BIT)
2920     {
2921       if (rs6000_alignment_flags == MASK_ALIGN_NATURAL)
2922         return true;
2923
2924       if (rs6000_alignment_flags ==  MASK_ALIGN_POWER)
2925         return true;
2926
2927       return false;
2928     }
2929   else
2930     {
2931       if (TARGET_MACHO)
2932         return false;
2933
2934       /* Assuming that all other types are naturally aligned. CHECKME!  */
2935       return true;
2936     }
2937 }
2938
2939 /* Return true if the vector misalignment factor is supported by the
2940    target.  */ 
2941 bool
2942 rs6000_builtin_support_vector_misalignment (enum machine_mode mode,
2943                                             const_tree type,
2944                                             int misalignment,
2945                                             bool is_packed)
2946 {
2947   if (TARGET_VSX)
2948     {
2949       /* Return if movmisalign pattern is not supported for this mode.  */
2950       if (optab_handler (movmisalign_optab, mode)->insn_code ==
2951           CODE_FOR_nothing)
2952         return false;
2953
2954       if (misalignment == -1)
2955         {
2956           /* misalignment factor is unknown at compile time but we know
2957              it's word aligned.  */
2958           if (rs6000_vector_alignment_reachable (type, is_packed))
2959             return true;
2960           return false;
2961         }
2962       /* VSX supports word-aligned vector.  */
2963       if (misalignment % 4 == 0)
2964         return true;
2965     }
2966   return false;
2967 }
2968
2969 /* Implement targetm.vectorize.builtin_vec_perm.  */
2970 tree
2971 rs6000_builtin_vec_perm (tree type, tree *mask_element_type)
2972 {
2973   tree inner_type = TREE_TYPE (type);
2974   bool uns_p = TYPE_UNSIGNED (inner_type);
2975   tree d;
2976
2977   *mask_element_type = unsigned_char_type_node;
2978
2979   switch (TYPE_MODE (type))
2980     {
2981     case V16QImode:
2982       d = (uns_p
2983            ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_16QI_UNS]
2984            : rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_16QI]);
2985       break;
2986
2987     case V8HImode:
2988       d = (uns_p
2989            ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_8HI_UNS]
2990            : rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_8HI]);
2991       break;
2992
2993     case V4SImode:
2994       d = (uns_p
2995            ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_4SI_UNS]
2996            : rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_4SI]);
2997       break;
2998
2999     case V4SFmode:
3000       d = rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_4SF];
3001       break;
3002
3003     case V2DFmode:
3004       if (!TARGET_ALLOW_DF_PERMUTE)
3005         return NULL_TREE;
3006
3007       d = rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_2DF];
3008       break;
3009
3010     case V2DImode:
3011       if (!TARGET_ALLOW_DF_PERMUTE)
3012         return NULL_TREE;
3013
3014       d = (uns_p
3015            ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_2DI_UNS]
3016            : rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_2DI]);
3017       break;
3018
3019     default:
3020       return NULL_TREE;
3021     }
3022
3023   gcc_assert (d);
3024   return d;
3025 }
3026
3027 /* Handle generic options of the form -mfoo=yes/no.
3028    NAME is the option name.
3029    VALUE is the option value.
3030    FLAG is the pointer to the flag where to store a 1 or 0, depending on
3031    whether the option value is 'yes' or 'no' respectively.  */
3032 static void
3033 rs6000_parse_yes_no_option (const char *name, const char *value, int *flag)
3034 {
3035   if (value == 0)
3036     return;
3037   else if (!strcmp (value, "yes"))
3038     *flag = 1;
3039   else if (!strcmp (value, "no"))
3040     *flag = 0;
3041   else
3042     error ("unknown -m%s= option specified: '%s'", name, value);
3043 }
3044
3045 /* Validate and record the size specified with the -mtls-size option.  */
3046
3047 static void
3048 rs6000_parse_tls_size_option (void)
3049 {
3050   if (rs6000_tls_size_string == 0)
3051     return;
3052   else if (strcmp (rs6000_tls_size_string, "16") == 0)
3053     rs6000_tls_size = 16;
3054   else if (strcmp (rs6000_tls_size_string, "32") == 0)
3055     rs6000_tls_size = 32;
3056   else if (strcmp (rs6000_tls_size_string, "64") == 0)
3057     rs6000_tls_size = 64;
3058   else
3059     error ("bad value %qs for -mtls-size switch", rs6000_tls_size_string);
3060 }
3061
3062 void
3063 optimization_options (int level ATTRIBUTE_UNUSED, int size ATTRIBUTE_UNUSED)
3064 {
3065   if (DEFAULT_ABI == ABI_DARWIN)
3066     /* The Darwin libraries never set errno, so we might as well
3067        avoid calling them when that's the only reason we would.  */
3068     flag_errno_math = 0;
3069
3070   /* Double growth factor to counter reduced min jump length.  */
3071   set_param_value ("max-grow-copy-bb-insns", 16);
3072
3073   /* Enable section anchors by default.
3074      Skip section anchors for Objective C and Objective C++
3075      until front-ends fixed.  */
3076   if (!TARGET_MACHO && lang_hooks.name[4] != 'O')
3077     flag_section_anchors = 2;
3078 }
3079
3080 static enum fpu_type_t
3081 rs6000_parse_fpu_option (const char *option)
3082 {
3083   if (!strcmp("none", option)) return FPU_NONE;
3084   if (!strcmp("sp_lite", option)) return FPU_SF_LITE;
3085   if (!strcmp("dp_lite", option)) return FPU_DF_LITE;
3086   if (!strcmp("sp_full", option)) return FPU_SF_FULL;
3087   if (!strcmp("dp_full", option)) return FPU_DF_FULL;
3088   error("unknown value %s for -mfpu", option);
3089   return FPU_NONE;
3090 }
3091
3092 /* Returns a function decl for a vectorized version of the builtin function
3093    with builtin function code FN and the result vector type TYPE, or NULL_TREE
3094    if it is not available.  */
3095
3096 static tree
3097 rs6000_builtin_vectorized_function (unsigned int fn, tree type_out,
3098                                     tree type_in)
3099 {
3100   enum machine_mode in_mode, out_mode;
3101   int in_n, out_n;
3102
3103   if (TREE_CODE (type_out) != VECTOR_TYPE
3104       || TREE_CODE (type_in) != VECTOR_TYPE
3105       || !TARGET_VECTORIZE_BUILTINS)
3106     return NULL_TREE;
3107
3108   out_mode = TYPE_MODE (TREE_TYPE (type_out));
3109   out_n = TYPE_VECTOR_SUBPARTS (type_out);
3110   in_mode = TYPE_MODE (TREE_TYPE (type_in));
3111   in_n = TYPE_VECTOR_SUBPARTS (type_in);
3112
3113   switch (fn)
3114     {
3115     case BUILT_IN_COPYSIGN:
3116       if (VECTOR_UNIT_VSX_P (V2DFmode)
3117           && out_mode == DFmode && out_n == 2
3118           && in_mode == DFmode && in_n == 2)
3119         return rs6000_builtin_decls[VSX_BUILTIN_CPSGNDP];
3120       break;
3121     case BUILT_IN_COPYSIGNF:
3122       if (out_mode != SFmode || out_n != 4
3123           || in_mode != SFmode || in_n != 4)
3124         break;
3125       if (VECTOR_UNIT_VSX_P (V4SFmode))
3126         return rs6000_builtin_decls[VSX_BUILTIN_CPSGNSP];
3127       if (VECTOR_UNIT_ALTIVEC_P (V4SFmode))
3128         return rs6000_builtin_decls[ALTIVEC_BUILTIN_COPYSIGN_V4SF];
3129       break;
3130     case BUILT_IN_SQRT:
3131       if (VECTOR_UNIT_VSX_P (V2DFmode)
3132           && out_mode == DFmode && out_n == 2
3133           && in_mode == DFmode && in_n == 2)
3134         return rs6000_builtin_decls[VSX_BUILTIN_XVSQRTDP];
3135       break;
3136     case BUILT_IN_SQRTF:
3137       if (VECTOR_UNIT_VSX_P (V4SFmode)
3138           && out_mode == SFmode && out_n == 4
3139           && in_mode == SFmode && in_n == 4)
3140         return rs6000_builtin_decls[VSX_BUILTIN_XVSQRTSP];
3141       break;
3142     case BUILT_IN_CEIL:
3143       if (VECTOR_UNIT_VSX_P (V2DFmode)
3144           && out_mode == DFmode && out_n == 2
3145           && in_mode == DFmode && in_n == 2)
3146         return rs6000_builtin_decls[VSX_BUILTIN_XVRDPIP];
3147       break;
3148     case BUILT_IN_CEILF:
3149       if (out_mode != SFmode || out_n != 4
3150           || in_mode != SFmode || in_n != 4)
3151         break;
3152       if (VECTOR_UNIT_VSX_P (V4SFmode))
3153         return rs6000_builtin_decls[VSX_BUILTIN_XVRSPIP];
3154       if (VECTOR_UNIT_ALTIVEC_P (V4SFmode))
3155         return rs6000_builtin_decls[ALTIVEC_BUILTIN_VRFIP];
3156       break;
3157     case BUILT_IN_FLOOR:
3158       if (VECTOR_UNIT_VSX_P (V2DFmode)
3159           && out_mode == DFmode && out_n == 2
3160           && in_mode == DFmode && in_n == 2)
3161         return rs6000_builtin_decls[VSX_BUILTIN_XVRDPIM];
3162       break;
3163     case BUILT_IN_FLOORF:
3164       if (out_mode != SFmode || out_n != 4
3165           || in_mode != SFmode || in_n != 4)
3166         break;
3167       if (VECTOR_UNIT_VSX_P (V4SFmode))
3168         return rs6000_builtin_decls[VSX_BUILTIN_XVRSPIM];
3169       if (VECTOR_UNIT_ALTIVEC_P (V4SFmode))
3170         return rs6000_builtin_decls[ALTIVEC_BUILTIN_VRFIM];
3171       break;
3172     case BUILT_IN_TRUNC:
3173       if (VECTOR_UNIT_VSX_P (V2DFmode)
3174           && out_mode == DFmode && out_n == 2
3175           && in_mode == DFmode && in_n == 2)
3176         return rs6000_builtin_decls[VSX_BUILTIN_XVRDPIZ];
3177       break;
3178     case BUILT_IN_TRUNCF:
3179       if (out_mode != SFmode || out_n != 4
3180           || in_mode != SFmode || in_n != 4)
3181         break;
3182       if (VECTOR_UNIT_VSX_P (V4SFmode))
3183         return rs6000_builtin_decls[VSX_BUILTIN_XVRSPIZ];
3184       if (VECTOR_UNIT_ALTIVEC_P (V4SFmode))
3185         return rs6000_builtin_decls[ALTIVEC_BUILTIN_VRFIZ];
3186       break;
3187     case BUILT_IN_NEARBYINT:
3188       if (VECTOR_UNIT_VSX_P (V2DFmode)
3189           && flag_unsafe_math_optimizations
3190           && out_mode == DFmode && out_n == 2
3191           && in_mode == DFmode && in_n == 2)
3192         return rs6000_builtin_decls[VSX_BUILTIN_XVRDPI];
3193       break;
3194     case BUILT_IN_NEARBYINTF:
3195       if (VECTOR_UNIT_VSX_P (V4SFmode)
3196           && flag_unsafe_math_optimizations
3197           && out_mode == SFmode && out_n == 4
3198           && in_mode == SFmode && in_n == 4)
3199         return rs6000_builtin_decls[VSX_BUILTIN_XVRSPI];
3200       break;
3201     case BUILT_IN_RINT:
3202       if (VECTOR_UNIT_VSX_P (V2DFmode)
3203           && !flag_trapping_math
3204           && out_mode == DFmode && out_n == 2
3205           && in_mode == DFmode && in_n == 2)
3206         return rs6000_builtin_decls[VSX_BUILTIN_XVRDPIC];
3207       break;
3208     case BUILT_IN_RINTF:
3209       if (VECTOR_UNIT_VSX_P (V4SFmode)
3210           && !flag_trapping_math
3211           && out_mode == SFmode && out_n == 4
3212           && in_mode == SFmode && in_n == 4)
3213         return rs6000_builtin_decls[VSX_BUILTIN_XVRSPIC];
3214       break;
3215     default:
3216       break;
3217     }
3218   return NULL_TREE;
3219 }
3220
3221
3222 /* Implement TARGET_HANDLE_OPTION.  */
3223
3224 static bool
3225 rs6000_handle_option (size_t code, const char *arg, int value)
3226 {
3227   enum fpu_type_t fpu_type = FPU_NONE;
3228   int isel;
3229
3230   switch (code)
3231     {
3232     case OPT_mno_power:
3233       target_flags &= ~(MASK_POWER | MASK_POWER2
3234                         | MASK_MULTIPLE | MASK_STRING);
3235       target_flags_explicit |= (MASK_POWER | MASK_POWER2
3236                                 | MASK_MULTIPLE | MASK_STRING);
3237       break;
3238     case OPT_mno_powerpc:
3239       target_flags &= ~(MASK_POWERPC | MASK_PPC_GPOPT
3240                         | MASK_PPC_GFXOPT | MASK_POWERPC64);
3241       target_flags_explicit |= (MASK_POWERPC | MASK_PPC_GPOPT
3242                                 | MASK_PPC_GFXOPT | MASK_POWERPC64);
3243       break;
3244     case OPT_mfull_toc:
3245       target_flags &= ~MASK_MINIMAL_TOC;
3246       TARGET_NO_FP_IN_TOC = 0;
3247       TARGET_NO_SUM_IN_TOC = 0;
3248       target_flags_explicit |= MASK_MINIMAL_TOC;
3249 #ifdef TARGET_USES_SYSV4_OPT
3250       /* Note, V.4 no longer uses a normal TOC, so make -mfull-toc, be
3251          just the same as -mminimal-toc.  */
3252       target_flags |= MASK_MINIMAL_TOC;
3253       target_flags_explicit |= MASK_MINIMAL_TOC;
3254 #endif
3255       break;
3256
3257 #ifdef TARGET_USES_SYSV4_OPT
3258     case OPT_mtoc:
3259       /* Make -mtoc behave like -mminimal-toc.  */
3260       target_flags |= MASK_MINIMAL_TOC;
3261       target_flags_explicit |= MASK_MINIMAL_TOC;
3262       break;
3263 #endif
3264
3265 #ifdef TARGET_USES_AIX64_OPT
3266     case OPT_maix64:
3267 #else
3268     case OPT_m64:
3269 #endif
3270       target_flags |= MASK_POWERPC64 | MASK_POWERPC;
3271       target_flags |= ~target_flags_explicit & MASK_PPC_GFXOPT;
3272       target_flags_explicit |= MASK_POWERPC64 | MASK_POWERPC;
3273       break;
3274
3275 #ifdef TARGET_USES_AIX64_OPT
3276     case OPT_maix32:
3277 #else
3278     case OPT_m32:
3279 #endif
3280       target_flags &= ~MASK_POWERPC64;
3281       target_flags_explicit |= MASK_POWERPC64;
3282       break;
3283
3284     case OPT_minsert_sched_nops_:
3285       rs6000_sched_insert_nops_str = arg;
3286       break;
3287
3288     case OPT_mminimal_toc:
3289       if (value == 1)
3290         {
3291           TARGET_NO_FP_IN_TOC = 0;
3292           TARGET_NO_SUM_IN_TOC = 0;
3293         }
3294       break;
3295
3296     case OPT_mpower:
3297       if (value == 1)
3298         {
3299           target_flags |= (MASK_MULTIPLE | MASK_STRING);
3300           target_flags_explicit |= (MASK_MULTIPLE | MASK_STRING);
3301         }
3302       break;
3303
3304     case OPT_mpower2:
3305       if (value == 1)
3306         {
3307           target_flags |= (MASK_POWER | MASK_MULTIPLE | MASK_STRING);
3308           target_flags_explicit |= (MASK_POWER | MASK_MULTIPLE | MASK_STRING);
3309         }
3310       break;
3311
3312     case OPT_mpowerpc_gpopt:
3313     case OPT_mpowerpc_gfxopt:
3314       if (value == 1)
3315         {
3316           target_flags |= MASK_POWERPC;
3317           target_flags_explicit |= MASK_POWERPC;
3318         }
3319       break;
3320
3321     case OPT_maix_struct_return:
3322     case OPT_msvr4_struct_return:
3323       rs6000_explicit_options.aix_struct_ret = true;
3324       break;
3325
3326     case OPT_mvrsave:
3327       rs6000_explicit_options.vrsave = true;
3328       TARGET_ALTIVEC_VRSAVE = value;
3329       break;
3330
3331     case OPT_mvrsave_:
3332       rs6000_explicit_options.vrsave = true;
3333       rs6000_parse_yes_no_option ("vrsave", arg, &(TARGET_ALTIVEC_VRSAVE));
3334       break;
3335
3336     case OPT_misel_:
3337       target_flags_explicit |= MASK_ISEL;
3338       isel = 0;
3339       rs6000_parse_yes_no_option ("isel", arg, &isel);
3340       if (isel)
3341         target_flags |= MASK_ISEL;
3342       else
3343         target_flags &= ~MASK_ISEL;
3344       break;
3345
3346     case OPT_mspe:
3347       rs6000_explicit_options.spe = true;
3348       rs6000_spe = value;
3349       break;
3350
3351     case OPT_mspe_:
3352       rs6000_explicit_options.spe = true;
3353       rs6000_parse_yes_no_option ("spe", arg, &(rs6000_spe));
3354       break;
3355
3356     case OPT_mdebug_:
3357       rs6000_debug_name = arg;
3358       break;
3359
3360 #ifdef TARGET_USES_SYSV4_OPT
3361     case OPT_mcall_:
3362       rs6000_abi_name = arg;
3363       break;
3364
3365     case OPT_msdata_:
3366       rs6000_sdata_name = arg;
3367       break;
3368
3369     case OPT_mtls_size_:
3370       rs6000_tls_size_string = arg;
3371       break;
3372
3373     case OPT_mrelocatable:
3374       if (value == 1)
3375         {
3376           target_flags |= MASK_MINIMAL_TOC;
3377           target_flags_explicit |= MASK_MINIMAL_TOC;
3378           TARGET_NO_FP_IN_TOC = 1;
3379         }
3380       break;
3381
3382     case OPT_mrelocatable_lib:
3383       if (value == 1)
3384         {
3385           target_flags |= MASK_RELOCATABLE | MASK_MINIMAL_TOC;
3386           target_flags_explicit |= MASK_RELOCATABLE | MASK_MINIMAL_TOC;
3387           TARGET_NO_FP_IN_TOC = 1;
3388         }
3389       else
3390         {
3391           target_flags &= ~MASK_RELOCATABLE;
3392           target_flags_explicit |= MASK_RELOCATABLE;
3393         }
3394       break;
3395 #endif
3396
3397     case OPT_mabi_:
3398       if (!strcmp (arg, "altivec"))
3399         {
3400           rs6000_explicit_options.altivec_abi = true;
3401           rs6000_altivec_abi = 1;
3402
3403           /* Enabling the AltiVec ABI turns off the SPE ABI.  */
3404           rs6000_spe_abi = 0;
3405         }
3406       else if (! strcmp (arg, "no-altivec"))