OSDN Git Service

333babc255f9f131dd9c2662d466916f178a8335
[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 rtx rs6000_expand_unop_builtin (enum insn_code, tree, rtx);
951 static rtx rs6000_expand_binop_builtin (enum insn_code, tree, rtx);
952 static rtx rs6000_expand_ternop_builtin (enum insn_code, tree, rtx);
953 static rtx rs6000_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
954 static void altivec_init_builtins (void);
955 static unsigned builtin_hash_function (const void *);
956 static int builtin_hash_eq (const void *, const void *);
957 static tree builtin_function_type (enum machine_mode, enum machine_mode,
958                                    enum machine_mode, enum machine_mode,
959                                    enum rs6000_builtins, const char *name);
960 static void rs6000_common_init_builtins (void);
961 static void rs6000_init_libfuncs (void);
962
963 static void paired_init_builtins (void);
964 static rtx paired_expand_builtin (tree, rtx, bool *);
965 static rtx paired_expand_lv_builtin (enum insn_code, tree, rtx);
966 static rtx paired_expand_stv_builtin (enum insn_code, tree);
967 static rtx paired_expand_predicate_builtin (enum insn_code, tree, rtx);
968
969 static void enable_mask_for_builtins (struct builtin_description *, int,
970                                       enum rs6000_builtins,
971                                       enum rs6000_builtins);
972 static void spe_init_builtins (void);
973 static rtx spe_expand_builtin (tree, rtx, bool *);
974 static rtx spe_expand_stv_builtin (enum insn_code, tree);
975 static rtx spe_expand_predicate_builtin (enum insn_code, tree, rtx);
976 static rtx spe_expand_evsel_builtin (enum insn_code, tree, rtx);
977 static int rs6000_emit_int_cmove (rtx, rtx, rtx, rtx);
978 static rs6000_stack_t *rs6000_stack_info (void);
979 static void debug_stack_info (rs6000_stack_t *);
980
981 static rtx altivec_expand_builtin (tree, rtx, bool *);
982 static rtx altivec_expand_ld_builtin (tree, rtx, bool *);
983 static rtx altivec_expand_st_builtin (tree, rtx, bool *);
984 static rtx altivec_expand_dst_builtin (tree, rtx, bool *);
985 static rtx altivec_expand_abs_builtin (enum insn_code, tree, rtx);
986 static rtx altivec_expand_predicate_builtin (enum insn_code, tree, rtx);
987 static rtx altivec_expand_stv_builtin (enum insn_code, tree);
988 static rtx altivec_expand_vec_init_builtin (tree, tree, rtx);
989 static rtx altivec_expand_vec_set_builtin (tree);
990 static rtx altivec_expand_vec_ext_builtin (tree, rtx);
991 static int get_element_number (tree, tree);
992 static bool rs6000_handle_option (size_t, const char *, int);
993 static void rs6000_parse_tls_size_option (void);
994 static void rs6000_parse_yes_no_option (const char *, const char *, int *);
995 static int first_altivec_reg_to_save (void);
996 static unsigned int compute_vrsave_mask (void);
997 static void compute_save_world_info (rs6000_stack_t *info_ptr);
998 static void is_altivec_return_reg (rtx, void *);
999 static rtx generate_set_vrsave (rtx, rs6000_stack_t *, int);
1000 int easy_vector_constant (rtx, enum machine_mode);
1001 static rtx rs6000_dwarf_register_span (rtx);
1002 static void rs6000_init_dwarf_reg_sizes_extra (tree);
1003 static rtx rs6000_legitimize_address (rtx, rtx, enum machine_mode);
1004 static rtx rs6000_debug_legitimize_address (rtx, rtx, enum machine_mode);
1005 static rtx rs6000_legitimize_tls_address (rtx, enum tls_model);
1006 static void rs6000_output_dwarf_dtprel (FILE *, int, rtx) ATTRIBUTE_UNUSED;
1007 static rtx rs6000_tls_get_addr (void);
1008 static rtx rs6000_got_sym (void);
1009 static int rs6000_tls_symbol_ref_1 (rtx *, void *);
1010 static const char *rs6000_get_some_local_dynamic_name (void);
1011 static int rs6000_get_some_local_dynamic_name_1 (rtx *, void *);
1012 static rtx rs6000_complex_function_value (enum machine_mode);
1013 static rtx rs6000_spe_function_arg (CUMULATIVE_ARGS *,
1014                                     enum machine_mode, tree);
1015 static void rs6000_darwin64_record_arg_advance_flush (CUMULATIVE_ARGS *,
1016                                                       HOST_WIDE_INT);
1017 static void rs6000_darwin64_record_arg_advance_recurse (CUMULATIVE_ARGS *,
1018                                                         tree, HOST_WIDE_INT);
1019 static void rs6000_darwin64_record_arg_flush (CUMULATIVE_ARGS *,
1020                                               HOST_WIDE_INT,
1021                                               rtx[], int *);
1022 static void rs6000_darwin64_record_arg_recurse (CUMULATIVE_ARGS *,
1023                                                 const_tree, HOST_WIDE_INT,
1024                                                 rtx[], int *);
1025 static rtx rs6000_darwin64_record_arg (CUMULATIVE_ARGS *, const_tree, int, bool);
1026 static rtx rs6000_mixed_function_arg (enum machine_mode, tree, int);
1027 static void rs6000_move_block_from_reg (int regno, rtx x, int nregs);
1028 static void setup_incoming_varargs (CUMULATIVE_ARGS *,
1029                                     enum machine_mode, tree,
1030                                     int *, int);
1031 static bool rs6000_pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode,
1032                                       const_tree, bool);
1033 static int rs6000_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode,
1034                                      tree, bool);
1035 static const char *invalid_arg_for_unprototyped_fn (const_tree, const_tree, const_tree);
1036 #if TARGET_MACHO
1037 static void macho_branch_islands (void);
1038 static int no_previous_def (tree function_name);
1039 static tree get_prev_label (tree function_name);
1040 static void rs6000_darwin_file_start (void);
1041 #endif
1042
1043 static tree rs6000_build_builtin_va_list (void);
1044 static void rs6000_va_start (tree, rtx);
1045 static tree rs6000_gimplify_va_arg (tree, tree, gimple_seq *, gimple_seq *);
1046 static bool rs6000_must_pass_in_stack (enum machine_mode, const_tree);
1047 static bool rs6000_scalar_mode_supported_p (enum machine_mode);
1048 static bool rs6000_vector_mode_supported_p (enum machine_mode);
1049 static rtx rs6000_emit_vector_compare_inner (enum rtx_code, rtx, rtx);
1050 static rtx rs6000_emit_vector_compare (enum rtx_code, rtx, rtx,
1051                                        enum machine_mode);
1052 static tree rs6000_stack_protect_fail (void);
1053
1054 static rtx rs6000_legitimize_reload_address (rtx, enum machine_mode, int, int,
1055                                              int, int *);
1056
1057 static rtx rs6000_debug_legitimize_reload_address (rtx, enum machine_mode, int,
1058                                                    int, int, int *);
1059
1060 rtx (*rs6000_legitimize_reload_address_ptr) (rtx, enum machine_mode, int, int,
1061                                              int, int *)
1062   = rs6000_legitimize_reload_address;
1063
1064 static bool rs6000_mode_dependent_address (rtx);
1065 static bool rs6000_debug_mode_dependent_address (rtx);
1066 bool (*rs6000_mode_dependent_address_ptr) (rtx)
1067   = rs6000_mode_dependent_address;
1068
1069 static enum reg_class rs6000_secondary_reload_class (enum reg_class,
1070                                                      enum machine_mode, rtx);
1071 static enum reg_class rs6000_debug_secondary_reload_class (enum reg_class,
1072                                                            enum machine_mode,
1073                                                            rtx);
1074 enum reg_class (*rs6000_secondary_reload_class_ptr) (enum reg_class,
1075                                                      enum machine_mode, rtx)
1076   = rs6000_secondary_reload_class;
1077
1078 static enum reg_class rs6000_preferred_reload_class (rtx, enum reg_class);
1079 static enum reg_class rs6000_debug_preferred_reload_class (rtx,
1080                                                            enum reg_class);
1081 enum reg_class (*rs6000_preferred_reload_class_ptr) (rtx, enum reg_class)
1082   = rs6000_preferred_reload_class;
1083
1084 static bool rs6000_secondary_memory_needed (enum reg_class, enum reg_class,
1085                                             enum machine_mode);
1086
1087 static bool rs6000_debug_secondary_memory_needed (enum reg_class,
1088                                                   enum reg_class,
1089                                                   enum machine_mode);
1090
1091 bool (*rs6000_secondary_memory_needed_ptr) (enum reg_class, enum reg_class,
1092                                             enum machine_mode)
1093   = rs6000_secondary_memory_needed;
1094
1095 static bool rs6000_cannot_change_mode_class (enum machine_mode,
1096                                              enum machine_mode,
1097                                              enum reg_class);
1098 static bool rs6000_debug_cannot_change_mode_class (enum machine_mode,
1099                                                    enum machine_mode,
1100                                                    enum reg_class);
1101
1102 bool (*rs6000_cannot_change_mode_class_ptr) (enum machine_mode,
1103                                              enum machine_mode,
1104                                              enum reg_class)
1105   = rs6000_cannot_change_mode_class;
1106
1107 static enum reg_class rs6000_secondary_reload (bool, rtx, enum reg_class,
1108                                                enum machine_mode,
1109                                                struct secondary_reload_info *);
1110
1111 static const enum reg_class *rs6000_ira_cover_classes (void);
1112
1113 const int INSN_NOT_AVAILABLE = -1;
1114 static enum machine_mode rs6000_eh_return_filter_mode (void);
1115 static bool rs6000_can_eliminate (const int, const int);
1116 static void rs6000_trampoline_init (rtx, tree, rtx);
1117
1118 /* Hash table stuff for keeping track of TOC entries.  */
1119
1120 struct GTY(()) toc_hash_struct
1121 {
1122   /* `key' will satisfy CONSTANT_P; in fact, it will satisfy
1123      ASM_OUTPUT_SPECIAL_POOL_ENTRY_P.  */
1124   rtx key;
1125   enum machine_mode key_mode;
1126   int labelno;
1127 };
1128
1129 static GTY ((param_is (struct toc_hash_struct))) htab_t toc_hash_table;
1130
1131 /* Hash table to keep track of the argument types for builtin functions.  */
1132
1133 struct GTY(()) builtin_hash_struct
1134 {
1135   tree type;
1136   enum machine_mode mode[4];    /* return value + 3 arguments.  */
1137   unsigned char uns_p[4];       /* and whether the types are unsigned.  */
1138 };
1139
1140 static GTY ((param_is (struct builtin_hash_struct))) htab_t builtin_hash_table;
1141 \f
1142 /* Default register names.  */
1143 char rs6000_reg_names[][8] =
1144 {
1145       "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",
1146       "8",  "9", "10", "11", "12", "13", "14", "15",
1147      "16", "17", "18", "19", "20", "21", "22", "23",
1148      "24", "25", "26", "27", "28", "29", "30", "31",
1149       "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",
1150       "8",  "9", "10", "11", "12", "13", "14", "15",
1151      "16", "17", "18", "19", "20", "21", "22", "23",
1152      "24", "25", "26", "27", "28", "29", "30", "31",
1153      "mq", "lr", "ctr","ap",
1154       "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",
1155       "xer",
1156       /* AltiVec registers.  */
1157       "0",  "1",  "2",  "3",  "4",  "5",  "6", "7",
1158       "8",  "9",  "10", "11", "12", "13", "14", "15",
1159       "16", "17", "18", "19", "20", "21", "22", "23",
1160       "24", "25", "26", "27", "28", "29", "30", "31",
1161       "vrsave", "vscr",
1162       /* SPE registers.  */
1163       "spe_acc", "spefscr",
1164       /* Soft frame pointer.  */
1165       "sfp"
1166 };
1167
1168 #ifdef TARGET_REGNAMES
1169 static const char alt_reg_names[][8] =
1170 {
1171    "%r0",   "%r1",  "%r2",  "%r3",  "%r4",  "%r5",  "%r6",  "%r7",
1172    "%r8",   "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15",
1173   "%r16",  "%r17", "%r18", "%r19", "%r20", "%r21", "%r22", "%r23",
1174   "%r24",  "%r25", "%r26", "%r27", "%r28", "%r29", "%r30", "%r31",
1175    "%f0",   "%f1",  "%f2",  "%f3",  "%f4",  "%f5",  "%f6",  "%f7",
1176    "%f8",   "%f9", "%f10", "%f11", "%f12", "%f13", "%f14", "%f15",
1177   "%f16",  "%f17", "%f18", "%f19", "%f20", "%f21", "%f22", "%f23",
1178   "%f24",  "%f25", "%f26", "%f27", "%f28", "%f29", "%f30", "%f31",
1179     "mq",    "lr",  "ctr",   "ap",
1180   "%cr0",  "%cr1", "%cr2", "%cr3", "%cr4", "%cr5", "%cr6", "%cr7",
1181    "xer",
1182   /* AltiVec registers.  */
1183    "%v0",  "%v1",  "%v2",  "%v3",  "%v4",  "%v5",  "%v6", "%v7",
1184    "%v8",  "%v9", "%v10", "%v11", "%v12", "%v13", "%v14", "%v15",
1185   "%v16", "%v17", "%v18", "%v19", "%v20", "%v21", "%v22", "%v23",
1186   "%v24", "%v25", "%v26", "%v27", "%v28", "%v29", "%v30", "%v31",
1187   "vrsave", "vscr",
1188   /* SPE registers.  */
1189   "spe_acc", "spefscr",
1190   /* Soft frame pointer.  */
1191   "sfp"
1192 };
1193 #endif
1194
1195 /* Table of valid machine attributes.  */
1196
1197 static const struct attribute_spec rs6000_attribute_table[] =
1198 {
1199   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
1200   { "altivec",   1, 1, false, true,  false, rs6000_handle_altivec_attribute },
1201   { "longcall",  0, 0, false, true,  true,  rs6000_handle_longcall_attribute },
1202   { "shortcall", 0, 0, false, true,  true,  rs6000_handle_longcall_attribute },
1203   { "ms_struct", 0, 0, false, false, false, rs6000_handle_struct_attribute },
1204   { "gcc_struct", 0, 0, false, false, false, rs6000_handle_struct_attribute },
1205 #ifdef SUBTARGET_ATTRIBUTE_TABLE
1206   SUBTARGET_ATTRIBUTE_TABLE,
1207 #endif
1208   { NULL,        0, 0, false, false, false, NULL }
1209 };
1210 \f
1211 #ifndef MASK_STRICT_ALIGN
1212 #define MASK_STRICT_ALIGN 0
1213 #endif
1214 #ifndef TARGET_PROFILE_KERNEL
1215 #define TARGET_PROFILE_KERNEL 0
1216 #define SET_PROFILE_KERNEL(N)
1217 #else
1218 #define SET_PROFILE_KERNEL(N) TARGET_PROFILE_KERNEL = (N)
1219 #endif
1220
1221 /* The VRSAVE bitmask puts bit %v0 as the most significant bit.  */
1222 #define ALTIVEC_REG_BIT(REGNO) (0x80000000 >> ((REGNO) - FIRST_ALTIVEC_REGNO))
1223 \f
1224 /* Initialize the GCC target structure.  */
1225 #undef TARGET_ATTRIBUTE_TABLE
1226 #define TARGET_ATTRIBUTE_TABLE rs6000_attribute_table
1227 #undef TARGET_SET_DEFAULT_TYPE_ATTRIBUTES
1228 #define TARGET_SET_DEFAULT_TYPE_ATTRIBUTES rs6000_set_default_type_attributes
1229
1230 #undef TARGET_ASM_ALIGNED_DI_OP
1231 #define TARGET_ASM_ALIGNED_DI_OP DOUBLE_INT_ASM_OP
1232
1233 /* Default unaligned ops are only provided for ELF.  Find the ops needed
1234    for non-ELF systems.  */
1235 #ifndef OBJECT_FORMAT_ELF
1236 #if TARGET_XCOFF
1237 /* For XCOFF.  rs6000_assemble_integer will handle unaligned DIs on
1238    64-bit targets.  */
1239 #undef TARGET_ASM_UNALIGNED_HI_OP
1240 #define TARGET_ASM_UNALIGNED_HI_OP "\t.vbyte\t2,"
1241 #undef TARGET_ASM_UNALIGNED_SI_OP
1242 #define TARGET_ASM_UNALIGNED_SI_OP "\t.vbyte\t4,"
1243 #undef TARGET_ASM_UNALIGNED_DI_OP
1244 #define TARGET_ASM_UNALIGNED_DI_OP "\t.vbyte\t8,"
1245 #else
1246 /* For Darwin.  */
1247 #undef TARGET_ASM_UNALIGNED_HI_OP
1248 #define TARGET_ASM_UNALIGNED_HI_OP "\t.short\t"
1249 #undef TARGET_ASM_UNALIGNED_SI_OP
1250 #define TARGET_ASM_UNALIGNED_SI_OP "\t.long\t"
1251 #undef TARGET_ASM_UNALIGNED_DI_OP
1252 #define TARGET_ASM_UNALIGNED_DI_OP "\t.quad\t"
1253 #undef TARGET_ASM_ALIGNED_DI_OP
1254 #define TARGET_ASM_ALIGNED_DI_OP "\t.quad\t"
1255 #endif
1256 #endif
1257
1258 /* This hook deals with fixups for relocatable code and DI-mode objects
1259    in 64-bit code.  */
1260 #undef TARGET_ASM_INTEGER
1261 #define TARGET_ASM_INTEGER rs6000_assemble_integer
1262
1263 #ifdef HAVE_GAS_HIDDEN
1264 #undef TARGET_ASM_ASSEMBLE_VISIBILITY
1265 #define TARGET_ASM_ASSEMBLE_VISIBILITY rs6000_assemble_visibility
1266 #endif
1267
1268 #undef TARGET_HAVE_TLS
1269 #define TARGET_HAVE_TLS HAVE_AS_TLS
1270
1271 #undef TARGET_CANNOT_FORCE_CONST_MEM
1272 #define TARGET_CANNOT_FORCE_CONST_MEM rs6000_tls_referenced_p
1273
1274 #undef TARGET_ASM_FUNCTION_PROLOGUE
1275 #define TARGET_ASM_FUNCTION_PROLOGUE rs6000_output_function_prologue
1276 #undef TARGET_ASM_FUNCTION_EPILOGUE
1277 #define TARGET_ASM_FUNCTION_EPILOGUE rs6000_output_function_epilogue
1278
1279 #undef TARGET_LEGITIMIZE_ADDRESS
1280 #define TARGET_LEGITIMIZE_ADDRESS rs6000_legitimize_address
1281
1282 #undef  TARGET_SCHED_VARIABLE_ISSUE
1283 #define TARGET_SCHED_VARIABLE_ISSUE rs6000_variable_issue
1284
1285 #undef TARGET_SCHED_ISSUE_RATE
1286 #define TARGET_SCHED_ISSUE_RATE rs6000_issue_rate
1287 #undef TARGET_SCHED_ADJUST_COST
1288 #define TARGET_SCHED_ADJUST_COST rs6000_adjust_cost
1289 #undef TARGET_SCHED_ADJUST_PRIORITY
1290 #define TARGET_SCHED_ADJUST_PRIORITY rs6000_adjust_priority
1291 #undef TARGET_SCHED_IS_COSTLY_DEPENDENCE
1292 #define TARGET_SCHED_IS_COSTLY_DEPENDENCE rs6000_is_costly_dependence
1293 #undef TARGET_SCHED_INIT
1294 #define TARGET_SCHED_INIT rs6000_sched_init
1295 #undef TARGET_SCHED_FINISH
1296 #define TARGET_SCHED_FINISH rs6000_sched_finish
1297 #undef TARGET_SCHED_REORDER
1298 #define TARGET_SCHED_REORDER rs6000_sched_reorder
1299 #undef TARGET_SCHED_REORDER2
1300 #define TARGET_SCHED_REORDER2 rs6000_sched_reorder2
1301
1302 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
1303 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD rs6000_use_sched_lookahead
1304
1305 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD
1306 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD rs6000_use_sched_lookahead_guard
1307
1308 #undef TARGET_SCHED_ALLOC_SCHED_CONTEXT
1309 #define TARGET_SCHED_ALLOC_SCHED_CONTEXT rs6000_alloc_sched_context
1310 #undef TARGET_SCHED_INIT_SCHED_CONTEXT
1311 #define TARGET_SCHED_INIT_SCHED_CONTEXT rs6000_init_sched_context
1312 #undef TARGET_SCHED_SET_SCHED_CONTEXT
1313 #define TARGET_SCHED_SET_SCHED_CONTEXT rs6000_set_sched_context
1314 #undef TARGET_SCHED_FREE_SCHED_CONTEXT
1315 #define TARGET_SCHED_FREE_SCHED_CONTEXT rs6000_free_sched_context
1316
1317 #undef TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD
1318 #define TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD rs6000_builtin_mask_for_load
1319 #undef TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_EVEN
1320 #define TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_EVEN rs6000_builtin_mul_widen_even
1321 #undef TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_ODD
1322 #define TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_ODD rs6000_builtin_mul_widen_odd
1323 #undef TARGET_VECTORIZE_BUILTIN_CONVERSION
1324 #define TARGET_VECTORIZE_BUILTIN_CONVERSION rs6000_builtin_conversion
1325 #undef TARGET_VECTORIZE_BUILTIN_VEC_PERM
1326 #define TARGET_VECTORIZE_BUILTIN_VEC_PERM rs6000_builtin_vec_perm
1327 #undef TARGET_SUPPORT_VECTOR_MISALIGNMENT
1328 #define TARGET_SUPPORT_VECTOR_MISALIGNMENT              \
1329   rs6000_builtin_support_vector_misalignment
1330 #undef TARGET_VECTOR_ALIGNMENT_REACHABLE
1331 #define TARGET_VECTOR_ALIGNMENT_REACHABLE rs6000_vector_alignment_reachable
1332
1333 #undef TARGET_INIT_BUILTINS
1334 #define TARGET_INIT_BUILTINS rs6000_init_builtins
1335
1336 #undef TARGET_EXPAND_BUILTIN
1337 #define TARGET_EXPAND_BUILTIN rs6000_expand_builtin
1338
1339 #undef TARGET_MANGLE_TYPE
1340 #define TARGET_MANGLE_TYPE rs6000_mangle_type
1341
1342 #undef TARGET_INIT_LIBFUNCS
1343 #define TARGET_INIT_LIBFUNCS rs6000_init_libfuncs
1344
1345 #if TARGET_MACHO
1346 #undef TARGET_BINDS_LOCAL_P
1347 #define TARGET_BINDS_LOCAL_P darwin_binds_local_p
1348 #endif
1349
1350 #undef TARGET_MS_BITFIELD_LAYOUT_P
1351 #define TARGET_MS_BITFIELD_LAYOUT_P rs6000_ms_bitfield_layout_p
1352
1353 #undef TARGET_ASM_OUTPUT_MI_THUNK
1354 #define TARGET_ASM_OUTPUT_MI_THUNK rs6000_output_mi_thunk
1355
1356 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
1357 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK hook_bool_const_tree_hwi_hwi_const_tree_true
1358
1359 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
1360 #define TARGET_FUNCTION_OK_FOR_SIBCALL rs6000_function_ok_for_sibcall
1361
1362 #undef TARGET_INVALID_WITHIN_DOLOOP
1363 #define TARGET_INVALID_WITHIN_DOLOOP rs6000_invalid_within_doloop
1364
1365 #undef TARGET_RTX_COSTS
1366 #define TARGET_RTX_COSTS rs6000_rtx_costs
1367 #undef TARGET_ADDRESS_COST
1368 #define TARGET_ADDRESS_COST hook_int_rtx_bool_0
1369
1370 #undef TARGET_DWARF_REGISTER_SPAN
1371 #define TARGET_DWARF_REGISTER_SPAN rs6000_dwarf_register_span
1372
1373 #undef TARGET_INIT_DWARF_REG_SIZES_EXTRA
1374 #define TARGET_INIT_DWARF_REG_SIZES_EXTRA rs6000_init_dwarf_reg_sizes_extra
1375
1376 /* On rs6000, function arguments are promoted, as are function return
1377    values.  */
1378 #undef TARGET_PROMOTE_FUNCTION_MODE
1379 #define TARGET_PROMOTE_FUNCTION_MODE default_promote_function_mode_always_promote
1380
1381 #undef TARGET_RETURN_IN_MEMORY
1382 #define TARGET_RETURN_IN_MEMORY rs6000_return_in_memory
1383
1384 #undef TARGET_SETUP_INCOMING_VARARGS
1385 #define TARGET_SETUP_INCOMING_VARARGS setup_incoming_varargs
1386
1387 /* Always strict argument naming on rs6000.  */
1388 #undef TARGET_STRICT_ARGUMENT_NAMING
1389 #define TARGET_STRICT_ARGUMENT_NAMING hook_bool_CUMULATIVE_ARGS_true
1390 #undef TARGET_PRETEND_OUTGOING_VARARGS_NAMED
1391 #define TARGET_PRETEND_OUTGOING_VARARGS_NAMED hook_bool_CUMULATIVE_ARGS_true
1392 #undef TARGET_SPLIT_COMPLEX_ARG
1393 #define TARGET_SPLIT_COMPLEX_ARG hook_bool_const_tree_true
1394 #undef TARGET_MUST_PASS_IN_STACK
1395 #define TARGET_MUST_PASS_IN_STACK rs6000_must_pass_in_stack
1396 #undef TARGET_PASS_BY_REFERENCE
1397 #define TARGET_PASS_BY_REFERENCE rs6000_pass_by_reference
1398 #undef TARGET_ARG_PARTIAL_BYTES
1399 #define TARGET_ARG_PARTIAL_BYTES rs6000_arg_partial_bytes
1400
1401 #undef TARGET_BUILD_BUILTIN_VA_LIST
1402 #define TARGET_BUILD_BUILTIN_VA_LIST rs6000_build_builtin_va_list
1403
1404 #undef TARGET_EXPAND_BUILTIN_VA_START
1405 #define TARGET_EXPAND_BUILTIN_VA_START rs6000_va_start
1406
1407 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
1408 #define TARGET_GIMPLIFY_VA_ARG_EXPR rs6000_gimplify_va_arg
1409
1410 #undef TARGET_EH_RETURN_FILTER_MODE
1411 #define TARGET_EH_RETURN_FILTER_MODE rs6000_eh_return_filter_mode
1412
1413 #undef TARGET_SCALAR_MODE_SUPPORTED_P
1414 #define TARGET_SCALAR_MODE_SUPPORTED_P rs6000_scalar_mode_supported_p
1415
1416 #undef TARGET_VECTOR_MODE_SUPPORTED_P
1417 #define TARGET_VECTOR_MODE_SUPPORTED_P rs6000_vector_mode_supported_p
1418
1419 #undef TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN
1420 #define TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN invalid_arg_for_unprototyped_fn
1421
1422 #undef TARGET_HANDLE_OPTION
1423 #define TARGET_HANDLE_OPTION rs6000_handle_option
1424
1425 #undef TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION
1426 #define TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION \
1427   rs6000_builtin_vectorized_function
1428
1429 #undef TARGET_DEFAULT_TARGET_FLAGS
1430 #define TARGET_DEFAULT_TARGET_FLAGS \
1431   (TARGET_DEFAULT)
1432
1433 #undef TARGET_STACK_PROTECT_FAIL
1434 #define TARGET_STACK_PROTECT_FAIL rs6000_stack_protect_fail
1435
1436 /* MPC604EUM 3.5.2 Weak Consistency between Multiple Processors
1437    The PowerPC architecture requires only weak consistency among
1438    processors--that is, memory accesses between processors need not be
1439    sequentially consistent and memory accesses among processors can occur
1440    in any order. The ability to order memory accesses weakly provides
1441    opportunities for more efficient use of the system bus. Unless a
1442    dependency exists, the 604e allows read operations to precede store
1443    operations.  */
1444 #undef TARGET_RELAXED_ORDERING
1445 #define TARGET_RELAXED_ORDERING true
1446
1447 #ifdef HAVE_AS_TLS
1448 #undef TARGET_ASM_OUTPUT_DWARF_DTPREL
1449 #define TARGET_ASM_OUTPUT_DWARF_DTPREL rs6000_output_dwarf_dtprel
1450 #endif
1451
1452 /* Use a 32-bit anchor range.  This leads to sequences like:
1453
1454         addis   tmp,anchor,high
1455         add     dest,tmp,low
1456
1457    where tmp itself acts as an anchor, and can be shared between
1458    accesses to the same 64k page.  */
1459 #undef TARGET_MIN_ANCHOR_OFFSET
1460 #define TARGET_MIN_ANCHOR_OFFSET -0x7fffffff - 1
1461 #undef TARGET_MAX_ANCHOR_OFFSET
1462 #define TARGET_MAX_ANCHOR_OFFSET 0x7fffffff
1463 #undef TARGET_USE_BLOCKS_FOR_CONSTANT_P
1464 #define TARGET_USE_BLOCKS_FOR_CONSTANT_P rs6000_use_blocks_for_constant_p
1465
1466 #undef TARGET_BUILTIN_RECIPROCAL
1467 #define TARGET_BUILTIN_RECIPROCAL rs6000_builtin_reciprocal
1468
1469 #undef TARGET_EXPAND_TO_RTL_HOOK
1470 #define TARGET_EXPAND_TO_RTL_HOOK rs6000_alloc_sdmode_stack_slot
1471
1472 #undef TARGET_INSTANTIATE_DECLS
1473 #define TARGET_INSTANTIATE_DECLS rs6000_instantiate_decls
1474
1475 #undef TARGET_SECONDARY_RELOAD
1476 #define TARGET_SECONDARY_RELOAD rs6000_secondary_reload
1477
1478 #undef TARGET_IRA_COVER_CLASSES
1479 #define TARGET_IRA_COVER_CLASSES rs6000_ira_cover_classes
1480
1481 #undef TARGET_LEGITIMATE_ADDRESS_P
1482 #define TARGET_LEGITIMATE_ADDRESS_P rs6000_legitimate_address_p
1483
1484 #undef TARGET_CAN_ELIMINATE
1485 #define TARGET_CAN_ELIMINATE rs6000_can_eliminate
1486
1487 #undef TARGET_TRAMPOLINE_INIT
1488 #define TARGET_TRAMPOLINE_INIT rs6000_trampoline_init
1489
1490 #undef TARGET_FUNCTION_VALUE
1491 #define TARGET_FUNCTION_VALUE rs6000_function_value
1492
1493 struct gcc_target targetm = TARGET_INITIALIZER;
1494 \f
1495 /* Return number of consecutive hard regs needed starting at reg REGNO
1496    to hold something of mode MODE.
1497    This is ordinarily the length in words of a value of mode MODE
1498    but can be less for certain modes in special long registers.
1499
1500    For the SPE, GPRs are 64 bits but only 32 bits are visible in
1501    scalar instructions.  The upper 32 bits are only available to the
1502    SIMD instructions.
1503
1504    POWER and PowerPC GPRs hold 32 bits worth;
1505    PowerPC64 GPRs and FPRs point register holds 64 bits worth.  */
1506
1507 static int
1508 rs6000_hard_regno_nregs_internal (int regno, enum machine_mode mode)
1509 {
1510   unsigned HOST_WIDE_INT reg_size;
1511
1512   if (FP_REGNO_P (regno))
1513     reg_size = (VECTOR_MEM_VSX_P (mode)
1514                 ? UNITS_PER_VSX_WORD
1515                 : UNITS_PER_FP_WORD);
1516
1517   else if (SPE_SIMD_REGNO_P (regno) && TARGET_SPE && SPE_VECTOR_MODE (mode))
1518     reg_size = UNITS_PER_SPE_WORD;
1519
1520   else if (ALTIVEC_REGNO_P (regno))
1521     reg_size = UNITS_PER_ALTIVEC_WORD;
1522
1523   /* The value returned for SCmode in the E500 double case is 2 for
1524      ABI compatibility; storing an SCmode value in a single register
1525      would require function_arg and rs6000_spe_function_arg to handle
1526      SCmode so as to pass the value correctly in a pair of
1527      registers.  */
1528   else if (TARGET_E500_DOUBLE && FLOAT_MODE_P (mode) && mode != SCmode
1529            && !DECIMAL_FLOAT_MODE_P (mode))
1530     reg_size = UNITS_PER_FP_WORD;
1531
1532   else
1533     reg_size = UNITS_PER_WORD;
1534
1535   return (GET_MODE_SIZE (mode) + reg_size - 1) / reg_size;
1536 }
1537
1538 /* Value is 1 if hard register REGNO can hold a value of machine-mode
1539    MODE.  */
1540 static int
1541 rs6000_hard_regno_mode_ok (int regno, enum machine_mode mode)
1542 {
1543   int last_regno = regno + rs6000_hard_regno_nregs[mode][regno] - 1;
1544
1545   /* VSX registers that overlap the FPR registers are larger than for non-VSX
1546      implementations.  Don't allow an item to be split between a FP register
1547      and an Altivec register.  */
1548   if (VECTOR_MEM_VSX_P (mode))
1549     {
1550       if (FP_REGNO_P (regno))
1551         return FP_REGNO_P (last_regno);
1552
1553       if (ALTIVEC_REGNO_P (regno))
1554         return ALTIVEC_REGNO_P (last_regno);
1555     }
1556
1557   /* The GPRs can hold any mode, but values bigger than one register
1558      cannot go past R31.  */
1559   if (INT_REGNO_P (regno))
1560     return INT_REGNO_P (last_regno);
1561
1562   /* The float registers (except for VSX vector modes) can only hold floating
1563      modes and DImode.  This excludes the 32-bit decimal float mode for
1564      now.  */
1565   if (FP_REGNO_P (regno))
1566     {
1567       if (SCALAR_FLOAT_MODE_P (mode)
1568           && (mode != TDmode || (regno % 2) == 0)
1569           && FP_REGNO_P (last_regno))
1570         return 1;
1571
1572       if (GET_MODE_CLASS (mode) == MODE_INT
1573           && GET_MODE_SIZE (mode) == UNITS_PER_FP_WORD)
1574         return 1;
1575
1576       if (PAIRED_SIMD_REGNO_P (regno) && TARGET_PAIRED_FLOAT
1577           && PAIRED_VECTOR_MODE (mode))
1578         return 1;
1579
1580       return 0;
1581     }
1582
1583   /* The CR register can only hold CC modes.  */
1584   if (CR_REGNO_P (regno))
1585     return GET_MODE_CLASS (mode) == MODE_CC;
1586
1587   if (XER_REGNO_P (regno))
1588     return mode == PSImode;
1589
1590   /* AltiVec only in AldyVec registers.  */
1591   if (ALTIVEC_REGNO_P (regno))
1592     return VECTOR_MEM_ALTIVEC_OR_VSX_P (mode);
1593
1594   /* ...but GPRs can hold SIMD data on the SPE in one register.  */
1595   if (SPE_SIMD_REGNO_P (regno) && TARGET_SPE && SPE_VECTOR_MODE (mode))
1596     return 1;
1597
1598   /* We cannot put TImode anywhere except general register and it must be able
1599      to fit within the register set.  In the future, allow TImode in the
1600      Altivec or VSX registers.  */
1601
1602   return GET_MODE_SIZE (mode) <= UNITS_PER_WORD;
1603 }
1604
1605 /* Print interesting facts about registers.  */
1606 static void
1607 rs6000_debug_reg_print (int first_regno, int last_regno, const char *reg_name)
1608 {
1609   int r, m;
1610
1611   for (r = first_regno; r <= last_regno; ++r)
1612     {
1613       const char *comma = "";
1614       int len;
1615
1616       if (first_regno == last_regno)
1617         fprintf (stderr, "%s:\t", reg_name);
1618       else
1619         fprintf (stderr, "%s%d:\t", reg_name, r - first_regno);
1620
1621       len = 8;
1622       for (m = 0; m < NUM_MACHINE_MODES; ++m)
1623         if (rs6000_hard_regno_mode_ok_p[m][r] && rs6000_hard_regno_nregs[m][r])
1624           {
1625             if (len > 70)
1626               {
1627                 fprintf (stderr, ",\n\t");
1628                 len = 8;
1629                 comma = "";
1630               }
1631
1632             if (rs6000_hard_regno_nregs[m][r] > 1)
1633               len += fprintf (stderr, "%s%s/%d", comma, GET_MODE_NAME (m),
1634                              rs6000_hard_regno_nregs[m][r]);
1635             else
1636               len += fprintf (stderr, "%s%s", comma, GET_MODE_NAME (m));
1637
1638             comma = ", ";
1639           }
1640
1641       if (call_used_regs[r])
1642         {
1643           if (len > 70)
1644             {
1645               fprintf (stderr, ",\n\t");
1646               len = 8;
1647               comma = "";
1648             }
1649
1650           len += fprintf (stderr, "%s%s", comma, "call-used");
1651           comma = ", ";
1652         }
1653
1654       if (fixed_regs[r])
1655         {
1656           if (len > 70)
1657             {
1658               fprintf (stderr, ",\n\t");
1659               len = 8;
1660               comma = "";
1661             }
1662
1663           len += fprintf (stderr, "%s%s", comma, "fixed");
1664           comma = ", ";
1665         }
1666
1667       if (len > 70)
1668         {
1669           fprintf (stderr, ",\n\t");
1670           comma = "";
1671         }
1672
1673       fprintf (stderr, "%sregno = %d\n", comma, r);
1674     }
1675 }
1676
1677 /* Print various interesting information with -mdebug=reg.  */
1678 static void
1679 rs6000_debug_reg_global (void)
1680 {
1681   const char *nl = (const char *)0;
1682   int m;
1683   char costly_num[20];
1684   char nop_num[20];
1685   const char *costly_str;
1686   const char *nop_str;
1687
1688   /* Map enum rs6000_vector to string.  */
1689   static const char *rs6000_debug_vector_unit[] = {
1690     "none",
1691     "altivec",
1692     "vsx",
1693     "paired",
1694     "spe",
1695     "other"
1696   };
1697
1698   fprintf (stderr, "Register information: (last virtual reg = %d)\n",
1699            LAST_VIRTUAL_REGISTER);
1700   rs6000_debug_reg_print (0, 31, "gr");
1701   rs6000_debug_reg_print (32, 63, "fp");
1702   rs6000_debug_reg_print (FIRST_ALTIVEC_REGNO,
1703                           LAST_ALTIVEC_REGNO,
1704                           "vs");
1705   rs6000_debug_reg_print (LR_REGNO, LR_REGNO, "lr");
1706   rs6000_debug_reg_print (CTR_REGNO, CTR_REGNO, "ctr");
1707   rs6000_debug_reg_print (CR0_REGNO, CR7_REGNO, "cr");
1708   rs6000_debug_reg_print (MQ_REGNO, MQ_REGNO, "mq");
1709   rs6000_debug_reg_print (XER_REGNO, XER_REGNO, "xer");
1710   rs6000_debug_reg_print (VRSAVE_REGNO, VRSAVE_REGNO, "vrsave");
1711   rs6000_debug_reg_print (VSCR_REGNO, VSCR_REGNO, "vscr");
1712   rs6000_debug_reg_print (SPE_ACC_REGNO, SPE_ACC_REGNO, "spe_a");
1713   rs6000_debug_reg_print (SPEFSCR_REGNO, SPEFSCR_REGNO, "spe_f");
1714
1715   fprintf (stderr,
1716            "\n"
1717            "d  reg_class = %s\n"
1718            "f  reg_class = %s\n"
1719            "v  reg_class = %s\n"
1720            "wa reg_class = %s\n"
1721            "wd reg_class = %s\n"
1722            "wf reg_class = %s\n"
1723            "ws reg_class = %s\n\n",
1724            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_d]],
1725            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_f]],
1726            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_v]],
1727            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_wa]],
1728            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_wd]],
1729            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_wf]],
1730            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_ws]]);
1731
1732   for (m = 0; m < NUM_MACHINE_MODES; ++m)
1733     if (rs6000_vector_unit[m] || rs6000_vector_mem[m])
1734       {
1735         nl = "\n";
1736         fprintf (stderr, "Vector mode: %-5s arithmetic: %-8s move: %-8s\n",
1737                  GET_MODE_NAME (m),
1738                  rs6000_debug_vector_unit[ rs6000_vector_unit[m] ],
1739                  rs6000_debug_vector_unit[ rs6000_vector_mem[m] ]);
1740       }
1741
1742   if (nl)
1743     fputs (nl, stderr);
1744
1745   switch (rs6000_sched_costly_dep)
1746     {
1747     case max_dep_latency:
1748       costly_str = "max_dep_latency";
1749       break;
1750
1751     case no_dep_costly:
1752       costly_str = "no_dep_costly";
1753       break;
1754
1755     case all_deps_costly:
1756       costly_str = "all_deps_costly";
1757       break;
1758
1759     case true_store_to_load_dep_costly:
1760       costly_str = "true_store_to_load_dep_costly";
1761       break;
1762
1763     case store_to_load_dep_costly:
1764       costly_str = "store_to_load_dep_costly";
1765       break;
1766
1767     default:
1768       costly_str = costly_num;
1769       sprintf (costly_num, "%d", (int)rs6000_sched_costly_dep);
1770       break;
1771     }
1772
1773   switch (rs6000_sched_insert_nops)
1774     {
1775     case sched_finish_regroup_exact:
1776       nop_str = "sched_finish_regroup_exact";
1777       break;
1778
1779     case sched_finish_pad_groups:
1780       nop_str = "sched_finish_pad_groups";
1781       break;
1782
1783     case sched_finish_none:
1784       nop_str = "sched_finish_none";
1785       break;
1786
1787     default:
1788       nop_str = nop_num;
1789       sprintf (nop_num, "%d", (int)rs6000_sched_insert_nops);
1790       break;
1791     }
1792
1793   fprintf (stderr,
1794            "always_hint                     = %s\n"
1795            "align_branch_targets            = %s\n"
1796            "sched_restricted_insns_priority = %d\n"
1797            "sched_costly_dep                = %s\n"
1798            "sched_insert_nops               = %s\n\n",
1799            rs6000_always_hint ? "true" : "false",
1800            rs6000_align_branch_targets ? "true" : "false",
1801            (int)rs6000_sched_restricted_insns_priority,
1802            costly_str, nop_str);
1803 }
1804
1805 /* Initialize the various global tables that are based on register size.  */
1806 static void
1807 rs6000_init_hard_regno_mode_ok (void)
1808 {
1809   int r, m, c;
1810   int align64;
1811   int align32;
1812
1813   /* Precalculate REGNO_REG_CLASS.  */
1814   rs6000_regno_regclass[0] = GENERAL_REGS;
1815   for (r = 1; r < 32; ++r)
1816     rs6000_regno_regclass[r] = BASE_REGS;
1817
1818   for (r = 32; r < 64; ++r)
1819     rs6000_regno_regclass[r] = FLOAT_REGS;
1820
1821   for (r = 64; r < FIRST_PSEUDO_REGISTER; ++r)
1822     rs6000_regno_regclass[r] = NO_REGS;
1823
1824   for (r = FIRST_ALTIVEC_REGNO; r <= LAST_ALTIVEC_REGNO; ++r)
1825     rs6000_regno_regclass[r] = ALTIVEC_REGS;
1826
1827   rs6000_regno_regclass[CR0_REGNO] = CR0_REGS;
1828   for (r = CR1_REGNO; r <= CR7_REGNO; ++r)
1829     rs6000_regno_regclass[r] = CR_REGS;
1830
1831   rs6000_regno_regclass[MQ_REGNO] = MQ_REGS;
1832   rs6000_regno_regclass[LR_REGNO] = LINK_REGS;
1833   rs6000_regno_regclass[CTR_REGNO] = CTR_REGS;
1834   rs6000_regno_regclass[XER_REGNO] = XER_REGS;
1835   rs6000_regno_regclass[VRSAVE_REGNO] = VRSAVE_REGS;
1836   rs6000_regno_regclass[VSCR_REGNO] = VRSAVE_REGS;
1837   rs6000_regno_regclass[SPE_ACC_REGNO] = SPE_ACC_REGS;
1838   rs6000_regno_regclass[SPEFSCR_REGNO] = SPEFSCR_REGS;
1839   rs6000_regno_regclass[ARG_POINTER_REGNUM] = BASE_REGS;
1840   rs6000_regno_regclass[FRAME_POINTER_REGNUM] = BASE_REGS;
1841
1842   /* Precalculate vector information, this must be set up before the
1843      rs6000_hard_regno_nregs_internal below.  */
1844   for (m = 0; m < NUM_MACHINE_MODES; ++m)
1845     {
1846       rs6000_vector_unit[m] = rs6000_vector_mem[m] = VECTOR_NONE;
1847       rs6000_vector_reload[m][0] = CODE_FOR_nothing;
1848       rs6000_vector_reload[m][1] = CODE_FOR_nothing;
1849     }
1850
1851   for (c = 0; c < (int)(int)RS6000_CONSTRAINT_MAX; c++)
1852     rs6000_constraints[c] = NO_REGS;
1853
1854   /* The VSX hardware allows native alignment for vectors, but control whether the compiler
1855      believes it can use native alignment or still uses 128-bit alignment.  */
1856   if (TARGET_VSX && !TARGET_VSX_ALIGN_128)
1857     {
1858       align64 = 64;
1859       align32 = 32;
1860     }
1861   else
1862     {
1863       align64 = 128;
1864       align32 = 128;
1865     }
1866
1867   /* V2DF mode, VSX only.  */
1868   if (TARGET_VSX)
1869     {
1870       rs6000_vector_unit[V2DFmode] = VECTOR_VSX;
1871       rs6000_vector_mem[V2DFmode] = VECTOR_VSX;
1872       rs6000_vector_align[V2DFmode] = align64;
1873     }
1874
1875   /* V4SF mode, either VSX or Altivec.  */
1876   if (TARGET_VSX)
1877     {
1878       rs6000_vector_unit[V4SFmode] = VECTOR_VSX;
1879       rs6000_vector_mem[V4SFmode] = VECTOR_VSX;
1880       rs6000_vector_align[V4SFmode] = align32;
1881     }
1882   else if (TARGET_ALTIVEC)
1883     {
1884       rs6000_vector_unit[V4SFmode] = VECTOR_ALTIVEC;
1885       rs6000_vector_mem[V4SFmode] = VECTOR_ALTIVEC;
1886       rs6000_vector_align[V4SFmode] = align32;
1887     }
1888
1889   /* V16QImode, V8HImode, V4SImode are Altivec only, but possibly do VSX loads
1890      and stores. */
1891   if (TARGET_ALTIVEC)
1892     {
1893       rs6000_vector_unit[V4SImode] = VECTOR_ALTIVEC;
1894       rs6000_vector_unit[V8HImode] = VECTOR_ALTIVEC;
1895       rs6000_vector_unit[V16QImode] = VECTOR_ALTIVEC;
1896       rs6000_vector_align[V4SImode] = align32;
1897       rs6000_vector_align[V8HImode] = align32;
1898       rs6000_vector_align[V16QImode] = align32;
1899
1900       if (TARGET_VSX)
1901         {
1902           rs6000_vector_mem[V4SImode] = VECTOR_VSX;
1903           rs6000_vector_mem[V8HImode] = VECTOR_VSX;
1904           rs6000_vector_mem[V16QImode] = VECTOR_VSX;
1905         }
1906       else
1907         {
1908           rs6000_vector_mem[V4SImode] = VECTOR_ALTIVEC;
1909           rs6000_vector_mem[V8HImode] = VECTOR_ALTIVEC;
1910           rs6000_vector_mem[V16QImode] = VECTOR_ALTIVEC;
1911         }
1912     }
1913
1914   /* V2DImode, only allow under VSX, which can do V2DI insert/splat/extract.
1915      Altivec doesn't have 64-bit support.  */
1916   if (TARGET_VSX)
1917     {
1918       rs6000_vector_mem[V2DImode] = VECTOR_VSX;
1919       rs6000_vector_unit[V2DImode] = VECTOR_NONE;
1920       rs6000_vector_align[V2DImode] = align64;
1921     }
1922
1923   /* DFmode, see if we want to use the VSX unit.  */
1924   if (TARGET_VSX && TARGET_VSX_SCALAR_DOUBLE)
1925     {
1926       rs6000_vector_unit[DFmode] = VECTOR_VSX;
1927       rs6000_vector_mem[DFmode]
1928         = (TARGET_VSX_SCALAR_MEMORY ? VECTOR_VSX : VECTOR_NONE);
1929       rs6000_vector_align[DFmode] = align64;
1930     }
1931
1932   /* TODO add SPE and paired floating point vector support.  */
1933
1934   /* Register class constaints for the constraints that depend on compile
1935      switches.  */
1936   if (TARGET_HARD_FLOAT && TARGET_FPRS)
1937     rs6000_constraints[RS6000_CONSTRAINT_f] = FLOAT_REGS;
1938
1939   if (TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT)
1940     rs6000_constraints[RS6000_CONSTRAINT_d] = FLOAT_REGS;
1941
1942   if (TARGET_VSX)
1943     {
1944       /* At present, we just use VSX_REGS, but we have different constraints
1945          based on the use, in case we want to fine tune the default register
1946          class used.  wa = any VSX register, wf = register class to use for
1947          V4SF, wd = register class to use for V2DF, and ws = register classs to
1948          use for DF scalars.  */
1949       rs6000_constraints[RS6000_CONSTRAINT_wa] = VSX_REGS;
1950       rs6000_constraints[RS6000_CONSTRAINT_wf] = VSX_REGS;
1951       rs6000_constraints[RS6000_CONSTRAINT_wd] = VSX_REGS;
1952       if (TARGET_VSX_SCALAR_DOUBLE)
1953         rs6000_constraints[RS6000_CONSTRAINT_ws] = VSX_REGS;
1954     }
1955
1956   if (TARGET_ALTIVEC)
1957     rs6000_constraints[RS6000_CONSTRAINT_v] = ALTIVEC_REGS;
1958
1959   /* Set up the reload helper functions.  */
1960   if (TARGET_VSX || TARGET_ALTIVEC)
1961     {
1962       if (TARGET_64BIT)
1963         {
1964           rs6000_vector_reload[V16QImode][0] = CODE_FOR_reload_v16qi_di_store;
1965           rs6000_vector_reload[V16QImode][1] = CODE_FOR_reload_v16qi_di_load;
1966           rs6000_vector_reload[V8HImode][0]  = CODE_FOR_reload_v8hi_di_store;
1967           rs6000_vector_reload[V8HImode][1]  = CODE_FOR_reload_v8hi_di_load;
1968           rs6000_vector_reload[V4SImode][0]  = CODE_FOR_reload_v4si_di_store;
1969           rs6000_vector_reload[V4SImode][1]  = CODE_FOR_reload_v4si_di_load;
1970           rs6000_vector_reload[V2DImode][0]  = CODE_FOR_reload_v2di_di_store;
1971           rs6000_vector_reload[V2DImode][1]  = CODE_FOR_reload_v2di_di_load;
1972           rs6000_vector_reload[V4SFmode][0]  = CODE_FOR_reload_v4sf_di_store;
1973           rs6000_vector_reload[V4SFmode][1]  = CODE_FOR_reload_v4sf_di_load;
1974           rs6000_vector_reload[V2DFmode][0]  = CODE_FOR_reload_v2df_di_store;
1975           rs6000_vector_reload[V2DFmode][1]  = CODE_FOR_reload_v2df_di_load;
1976         }
1977       else
1978         {
1979           rs6000_vector_reload[V16QImode][0] = CODE_FOR_reload_v16qi_si_store;
1980           rs6000_vector_reload[V16QImode][1] = CODE_FOR_reload_v16qi_si_load;
1981           rs6000_vector_reload[V8HImode][0]  = CODE_FOR_reload_v8hi_si_store;
1982           rs6000_vector_reload[V8HImode][1]  = CODE_FOR_reload_v8hi_si_load;
1983           rs6000_vector_reload[V4SImode][0]  = CODE_FOR_reload_v4si_si_store;
1984           rs6000_vector_reload[V4SImode][1]  = CODE_FOR_reload_v4si_si_load;
1985           rs6000_vector_reload[V2DImode][0]  = CODE_FOR_reload_v2di_si_store;
1986           rs6000_vector_reload[V2DImode][1]  = CODE_FOR_reload_v2di_si_load;
1987           rs6000_vector_reload[V4SFmode][0]  = CODE_FOR_reload_v4sf_si_store;
1988           rs6000_vector_reload[V4SFmode][1]  = CODE_FOR_reload_v4sf_si_load;
1989           rs6000_vector_reload[V2DFmode][0]  = CODE_FOR_reload_v2df_si_store;
1990           rs6000_vector_reload[V2DFmode][1]  = CODE_FOR_reload_v2df_si_load;
1991         }
1992     }
1993
1994   /* Precalculate HARD_REGNO_NREGS.  */
1995   for (r = 0; r < FIRST_PSEUDO_REGISTER; ++r)
1996     for (m = 0; m < NUM_MACHINE_MODES; ++m)
1997       rs6000_hard_regno_nregs[m][r]
1998         = rs6000_hard_regno_nregs_internal (r, (enum machine_mode)m);
1999
2000   /* Precalculate HARD_REGNO_MODE_OK.  */
2001   for (r = 0; r < FIRST_PSEUDO_REGISTER; ++r)
2002     for (m = 0; m < NUM_MACHINE_MODES; ++m)
2003       if (rs6000_hard_regno_mode_ok (r, (enum machine_mode)m))
2004         rs6000_hard_regno_mode_ok_p[m][r] = true;
2005
2006   /* Precalculate CLASS_MAX_NREGS sizes.  */
2007   for (c = 0; c < LIM_REG_CLASSES; ++c)
2008     {
2009       int reg_size;
2010
2011       if (TARGET_VSX && VSX_REG_CLASS_P (c))
2012         reg_size = UNITS_PER_VSX_WORD;
2013
2014       else if (c == ALTIVEC_REGS)
2015         reg_size = UNITS_PER_ALTIVEC_WORD;
2016
2017       else if (c == FLOAT_REGS)
2018         reg_size = UNITS_PER_FP_WORD;
2019
2020       else
2021         reg_size = UNITS_PER_WORD;
2022
2023       for (m = 0; m < NUM_MACHINE_MODES; ++m)
2024         rs6000_class_max_nregs[m][c]
2025           = (GET_MODE_SIZE (m) + reg_size - 1) / reg_size;
2026     }
2027
2028   if (TARGET_E500_DOUBLE)
2029     rs6000_class_max_nregs[DFmode][GENERAL_REGS] = 1;
2030
2031   if (TARGET_DEBUG_REG)
2032     rs6000_debug_reg_global ();
2033 }
2034
2035 #if TARGET_MACHO
2036 /* The Darwin version of SUBTARGET_OVERRIDE_OPTIONS.  */
2037
2038 static void
2039 darwin_rs6000_override_options (void)
2040 {
2041   /* The Darwin ABI always includes AltiVec, can't be (validly) turned
2042      off.  */
2043   rs6000_altivec_abi = 1;
2044   TARGET_ALTIVEC_VRSAVE = 1;
2045   if (DEFAULT_ABI == ABI_DARWIN)
2046   {
2047     if (MACHO_DYNAMIC_NO_PIC_P)
2048       {
2049         if (flag_pic)
2050             warning (0, "-mdynamic-no-pic overrides -fpic or -fPIC");
2051         flag_pic = 0;
2052       }
2053     else if (flag_pic == 1)
2054       {
2055         flag_pic = 2;
2056       }
2057   }
2058   if (TARGET_64BIT && ! TARGET_POWERPC64)
2059     {
2060       target_flags |= MASK_POWERPC64;
2061       warning (0, "-m64 requires PowerPC64 architecture, enabling");
2062     }
2063   if (flag_mkernel)
2064     {
2065       rs6000_default_long_calls = 1;
2066       target_flags |= MASK_SOFT_FLOAT;
2067     }
2068
2069   /* Make -m64 imply -maltivec.  Darwin's 64-bit ABI includes
2070      Altivec.  */
2071   if (!flag_mkernel && !flag_apple_kext
2072       && TARGET_64BIT
2073       && ! (target_flags_explicit & MASK_ALTIVEC))
2074     target_flags |= MASK_ALTIVEC;
2075
2076   /* Unless the user (not the configurer) has explicitly overridden
2077      it with -mcpu=G3 or -mno-altivec, then 10.5+ targets default to
2078      G4 unless targetting the kernel.  */
2079   if (!flag_mkernel
2080       && !flag_apple_kext
2081       && strverscmp (darwin_macosx_version_min, "10.5") >= 0
2082       && ! (target_flags_explicit & MASK_ALTIVEC)
2083       && ! rs6000_select[1].string)
2084     {
2085       target_flags |= MASK_ALTIVEC;
2086     }
2087 }
2088 #endif
2089
2090 /* If not otherwise specified by a target, make 'long double' equivalent to
2091    'double'.  */
2092
2093 #ifndef RS6000_DEFAULT_LONG_DOUBLE_SIZE
2094 #define RS6000_DEFAULT_LONG_DOUBLE_SIZE 64
2095 #endif
2096
2097 /* Override command line options.  Mostly we process the processor
2098    type and sometimes adjust other TARGET_ options.  */
2099
2100 void
2101 rs6000_override_options (const char *default_cpu)
2102 {
2103   size_t i, j;
2104   struct rs6000_cpu_select *ptr;
2105   int set_masks;
2106
2107   /* Simplifications for entries below.  */
2108
2109   enum {
2110     POWERPC_BASE_MASK = MASK_POWERPC | MASK_NEW_MNEMONICS,
2111     POWERPC_7400_MASK = POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_ALTIVEC
2112   };
2113
2114   /* This table occasionally claims that a processor does not support
2115      a particular feature even though it does, but the feature is slower
2116      than the alternative.  Thus, it shouldn't be relied on as a
2117      complete description of the processor's support.
2118
2119      Please keep this list in order, and don't forget to update the
2120      documentation in invoke.texi when adding a new processor or
2121      flag.  */
2122   static struct ptt
2123     {
2124       const char *const name;           /* Canonical processor name.  */
2125       const enum processor_type processor; /* Processor type enum value.  */
2126       const int target_enable;  /* Target flags to enable.  */
2127     } const processor_target_table[]
2128       = {{"401", PROCESSOR_PPC403, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
2129          {"403", PROCESSOR_PPC403,
2130           POWERPC_BASE_MASK | MASK_SOFT_FLOAT | MASK_STRICT_ALIGN},
2131          {"405", PROCESSOR_PPC405,
2132           POWERPC_BASE_MASK | MASK_SOFT_FLOAT | MASK_MULHW | MASK_DLMZB},
2133          {"405fp", PROCESSOR_PPC405,
2134           POWERPC_BASE_MASK | MASK_MULHW | MASK_DLMZB},
2135          {"440", PROCESSOR_PPC440,
2136           POWERPC_BASE_MASK | MASK_SOFT_FLOAT | MASK_MULHW | MASK_DLMZB},
2137          {"440fp", PROCESSOR_PPC440,
2138           POWERPC_BASE_MASK | MASK_MULHW | MASK_DLMZB},
2139          {"464", PROCESSOR_PPC440,
2140           POWERPC_BASE_MASK | MASK_SOFT_FLOAT | MASK_MULHW | MASK_DLMZB},
2141          {"464fp", PROCESSOR_PPC440,
2142           POWERPC_BASE_MASK | MASK_MULHW | MASK_DLMZB},
2143          {"505", PROCESSOR_MPCCORE, POWERPC_BASE_MASK},
2144          {"601", PROCESSOR_PPC601,
2145           MASK_POWER | POWERPC_BASE_MASK | MASK_MULTIPLE | MASK_STRING},
2146          {"602", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
2147          {"603", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
2148          {"603e", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
2149          {"604", PROCESSOR_PPC604, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
2150          {"604e", PROCESSOR_PPC604e, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
2151          {"620", PROCESSOR_PPC620,
2152           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
2153          {"630", PROCESSOR_PPC630,
2154           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
2155          {"740", PROCESSOR_PPC750, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
2156          {"7400", PROCESSOR_PPC7400, POWERPC_7400_MASK},
2157          {"7450", PROCESSOR_PPC7450, POWERPC_7400_MASK},
2158          {"750", PROCESSOR_PPC750, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
2159          {"801", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
2160          {"821", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
2161          {"823", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
2162          {"8540", PROCESSOR_PPC8540, POWERPC_BASE_MASK | MASK_STRICT_ALIGN
2163           | MASK_ISEL},
2164          /* 8548 has a dummy entry for now.  */
2165          {"8548", PROCESSOR_PPC8540, POWERPC_BASE_MASK | MASK_STRICT_ALIGN
2166           | MASK_ISEL},
2167          {"a2", PROCESSOR_PPCA2,
2168           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64 | MASK_POPCNTB
2169           | MASK_CMPB | MASK_NO_UPDATE },
2170          {"e300c2", PROCESSOR_PPCE300C2, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
2171          {"e300c3", PROCESSOR_PPCE300C3, POWERPC_BASE_MASK},
2172          {"e500mc", PROCESSOR_PPCE500MC, POWERPC_BASE_MASK | MASK_PPC_GFXOPT
2173           | MASK_ISEL},
2174          {"860", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
2175          {"970", PROCESSOR_POWER4,
2176           POWERPC_7400_MASK | MASK_PPC_GPOPT | MASK_MFCRF | MASK_POWERPC64},
2177          {"cell", PROCESSOR_CELL,
2178           POWERPC_7400_MASK  | MASK_PPC_GPOPT | MASK_MFCRF | MASK_POWERPC64},
2179          {"common", PROCESSOR_COMMON, MASK_NEW_MNEMONICS},
2180          {"ec603e", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
2181          {"G3", PROCESSOR_PPC750, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
2182          {"G4",  PROCESSOR_PPC7450, POWERPC_7400_MASK},
2183          {"G5", PROCESSOR_POWER4,
2184           POWERPC_7400_MASK | MASK_PPC_GPOPT | MASK_MFCRF | MASK_POWERPC64},
2185          {"power", PROCESSOR_POWER, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
2186          {"power2", PROCESSOR_POWER,
2187           MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING},
2188          {"power3", PROCESSOR_PPC630,
2189           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
2190          {"power4", PROCESSOR_POWER4,
2191           POWERPC_BASE_MASK | MASK_POWERPC64 | MASK_PPC_GPOPT | MASK_PPC_GFXOPT
2192           | MASK_MFCRF},
2193          {"power5", PROCESSOR_POWER5,
2194           POWERPC_BASE_MASK | MASK_POWERPC64 | MASK_PPC_GPOPT | MASK_PPC_GFXOPT
2195           | MASK_MFCRF | MASK_POPCNTB},
2196          {"power5+", PROCESSOR_POWER5,
2197           POWERPC_BASE_MASK | MASK_POWERPC64 | MASK_PPC_GPOPT | MASK_PPC_GFXOPT
2198           | MASK_MFCRF | MASK_POPCNTB | MASK_FPRND},
2199          {"power6", PROCESSOR_POWER6,
2200           POWERPC_BASE_MASK | MASK_POWERPC64 | MASK_PPC_GPOPT | MASK_PPC_GFXOPT
2201           | MASK_MFCRF | MASK_POPCNTB | MASK_FPRND | MASK_CMPB | MASK_DFP},
2202          {"power6x", PROCESSOR_POWER6,
2203           POWERPC_BASE_MASK | MASK_POWERPC64 | MASK_PPC_GPOPT | MASK_PPC_GFXOPT
2204           | MASK_MFCRF | MASK_POPCNTB | MASK_FPRND | MASK_CMPB | MASK_DFP
2205           | MASK_MFPGPR},
2206          {"power7", PROCESSOR_POWER7,
2207           POWERPC_7400_MASK | MASK_POWERPC64 | MASK_PPC_GPOPT | MASK_MFCRF
2208           | MASK_POPCNTB | MASK_FPRND | MASK_CMPB | MASK_DFP | MASK_POPCNTD
2209           | MASK_VSX},          /* Don't add MASK_ISEL by default */
2210          {"powerpc", PROCESSOR_POWERPC, POWERPC_BASE_MASK},
2211          {"powerpc64", PROCESSOR_POWERPC64,
2212           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
2213          {"rios", PROCESSOR_RIOS1, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
2214          {"rios1", PROCESSOR_RIOS1, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
2215          {"rios2", PROCESSOR_RIOS2,
2216           MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING},
2217          {"rsc", PROCESSOR_PPC601, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
2218          {"rsc1", PROCESSOR_PPC601, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
2219          {"rs64", PROCESSOR_RS64A,
2220           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64}
2221       };
2222
2223   const size_t ptt_size = ARRAY_SIZE (processor_target_table);
2224
2225   /* Some OSs don't support saving the high part of 64-bit registers on
2226      context switch.  Other OSs don't support saving Altivec registers.
2227      On those OSs, we don't touch the MASK_POWERPC64 or MASK_ALTIVEC
2228      settings; if the user wants either, the user must explicitly specify
2229      them and we won't interfere with the user's specification.  */
2230
2231   enum {
2232     POWER_MASKS = MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING,
2233     POWERPC_MASKS = (POWERPC_BASE_MASK | MASK_PPC_GPOPT | MASK_STRICT_ALIGN
2234                      | MASK_PPC_GFXOPT | MASK_POWERPC64 | MASK_ALTIVEC
2235                      | MASK_MFCRF | MASK_POPCNTB | MASK_FPRND | MASK_MULHW
2236                      | MASK_DLMZB | MASK_CMPB | MASK_MFPGPR | MASK_DFP
2237                      | MASK_POPCNTD | MASK_VSX | MASK_ISEL | MASK_NO_UPDATE)
2238   };
2239
2240   /* Set the pointer size.  */
2241   if (TARGET_64BIT)
2242     {
2243       rs6000_pmode = (int)DImode;
2244       rs6000_pointer_size = 64;
2245     }
2246   else
2247     {
2248       rs6000_pmode = (int)SImode;
2249       rs6000_pointer_size = 32;
2250     }
2251
2252   set_masks = POWER_MASKS | POWERPC_MASKS | MASK_SOFT_FLOAT;
2253 #ifdef OS_MISSING_POWERPC64
2254   if (OS_MISSING_POWERPC64)
2255     set_masks &= ~MASK_POWERPC64;
2256 #endif
2257 #ifdef OS_MISSING_ALTIVEC
2258   if (OS_MISSING_ALTIVEC)
2259     set_masks &= ~MASK_ALTIVEC;
2260 #endif
2261
2262   /* Don't override by the processor default if given explicitly.  */
2263   set_masks &= ~target_flags_explicit;
2264
2265   /* Identify the processor type.  */
2266   rs6000_select[0].string = default_cpu;
2267   rs6000_cpu = TARGET_POWERPC64 ? PROCESSOR_DEFAULT64 : PROCESSOR_DEFAULT;
2268
2269   for (i = 0; i < ARRAY_SIZE (rs6000_select); i++)
2270     {
2271       ptr = &rs6000_select[i];
2272       if (ptr->string != (char *)0 && ptr->string[0] != '\0')
2273         {
2274           for (j = 0; j < ptt_size; j++)
2275             if (! strcmp (ptr->string, processor_target_table[j].name))
2276               {
2277                 if (ptr->set_tune_p)
2278                   rs6000_cpu = processor_target_table[j].processor;
2279
2280                 if (ptr->set_arch_p)
2281                   {
2282                     target_flags &= ~set_masks;
2283                     target_flags |= (processor_target_table[j].target_enable
2284                                      & set_masks);
2285                   }
2286                 break;
2287               }
2288
2289           if (j == ptt_size)
2290             error ("bad value (%s) for %s switch", ptr->string, ptr->name);
2291         }
2292     }
2293
2294   if (rs6000_cpu == PROCESSOR_PPCE300C2 || rs6000_cpu == PROCESSOR_PPCE300C3
2295       || rs6000_cpu == PROCESSOR_PPCE500MC)
2296     {
2297       if (TARGET_ALTIVEC)
2298         error ("AltiVec not supported in this target");
2299       if (TARGET_SPE)
2300         error ("Spe not supported in this target");
2301     }
2302
2303   /* Disable Cell microcode if we are optimizing for the Cell
2304      and not optimizing for size.  */
2305   if (rs6000_gen_cell_microcode == -1)
2306     rs6000_gen_cell_microcode = !(rs6000_cpu == PROCESSOR_CELL
2307                                   && !optimize_size);
2308
2309   /* If we are optimizing big endian systems for space, use the load/store
2310      multiple and string instructions unless we are not generating
2311      Cell microcode.  */
2312   if (BYTES_BIG_ENDIAN && optimize_size && !rs6000_gen_cell_microcode)
2313     target_flags |= ~target_flags_explicit & (MASK_MULTIPLE | MASK_STRING);
2314
2315   /* Don't allow -mmultiple or -mstring on little endian systems
2316      unless the cpu is a 750, because the hardware doesn't support the
2317      instructions used in little endian mode, and causes an alignment
2318      trap.  The 750 does not cause an alignment trap (except when the
2319      target is unaligned).  */
2320
2321   if (!BYTES_BIG_ENDIAN && rs6000_cpu != PROCESSOR_PPC750)
2322     {
2323       if (TARGET_MULTIPLE)
2324         {
2325           target_flags &= ~MASK_MULTIPLE;
2326           if ((target_flags_explicit & MASK_MULTIPLE) != 0)
2327             warning (0, "-mmultiple is not supported on little endian systems");
2328         }
2329
2330       if (TARGET_STRING)
2331         {
2332           target_flags &= ~MASK_STRING;
2333           if ((target_flags_explicit & MASK_STRING) != 0)
2334             warning (0, "-mstring is not supported on little endian systems");
2335         }
2336     }
2337
2338   /* Add some warnings for VSX.  Enable -maltivec unless the user explicitly
2339      used -mno-altivec  */
2340   if (TARGET_VSX)
2341     {
2342       const char *msg = NULL;
2343       if (!TARGET_HARD_FLOAT || !TARGET_FPRS
2344           || !TARGET_SINGLE_FLOAT || !TARGET_DOUBLE_FLOAT)
2345         {
2346           if (target_flags_explicit & MASK_VSX)
2347             msg = N_("-mvsx requires hardware floating point");
2348           else
2349             target_flags &= ~ MASK_VSX;
2350         }
2351       else if (TARGET_PAIRED_FLOAT)
2352         msg = N_("-mvsx and -mpaired are incompatible");
2353       /* The hardware will allow VSX and little endian, but until we make sure
2354          things like vector select, etc. work don't allow VSX on little endian
2355          systems at this point.  */
2356       else if (!BYTES_BIG_ENDIAN)
2357         msg = N_("-mvsx used with little endian code");
2358       else if (TARGET_AVOID_XFORM > 0)
2359         msg = N_("-mvsx needs indexed addressing");
2360
2361       if (msg)
2362         {
2363           warning (0, msg);
2364           target_flags &= ~ MASK_VSX;
2365         }
2366       else if (TARGET_VSX && !TARGET_ALTIVEC
2367                && (target_flags_explicit & MASK_ALTIVEC) == 0)
2368         target_flags |= MASK_ALTIVEC;
2369     }
2370
2371   /* Set debug flags */
2372   if (rs6000_debug_name)
2373     {
2374       if (! strcmp (rs6000_debug_name, "all"))
2375         rs6000_debug_stack = rs6000_debug_arg = rs6000_debug_reg
2376           = rs6000_debug_addr = rs6000_debug_cost = 1;
2377       else if (! strcmp (rs6000_debug_name, "stack"))
2378         rs6000_debug_stack = 1;
2379       else if (! strcmp (rs6000_debug_name, "arg"))
2380         rs6000_debug_arg = 1;
2381       else if (! strcmp (rs6000_debug_name, "reg"))
2382         rs6000_debug_reg = 1;
2383       else if (! strcmp (rs6000_debug_name, "addr"))
2384         rs6000_debug_addr = 1;
2385       else if (! strcmp (rs6000_debug_name, "cost"))
2386         rs6000_debug_cost = 1;
2387       else
2388         error ("unknown -mdebug-%s switch", rs6000_debug_name);
2389
2390       /* If the appropriate debug option is enabled, replace the target hooks
2391          with debug versions that call the real version and then prints
2392          debugging information.  */
2393       if (TARGET_DEBUG_COST)
2394         {
2395           targetm.rtx_costs = rs6000_debug_rtx_costs;
2396           targetm.address_cost = rs6000_debug_address_cost;
2397           targetm.sched.adjust_cost = rs6000_debug_adjust_cost;
2398         }
2399
2400       if (TARGET_DEBUG_ADDR)
2401         {
2402           targetm.legitimate_address_p = rs6000_debug_legitimate_address_p;
2403           targetm.legitimize_address = rs6000_debug_legitimize_address;
2404           rs6000_secondary_reload_class_ptr
2405             = rs6000_debug_secondary_reload_class;
2406           rs6000_secondary_memory_needed_ptr
2407             = rs6000_debug_secondary_memory_needed;
2408           rs6000_cannot_change_mode_class_ptr
2409             = rs6000_debug_cannot_change_mode_class;
2410           rs6000_preferred_reload_class_ptr
2411             = rs6000_debug_preferred_reload_class;
2412           rs6000_legitimize_reload_address_ptr
2413             = rs6000_debug_legitimize_reload_address;
2414           rs6000_mode_dependent_address_ptr
2415             = rs6000_debug_mode_dependent_address;
2416         }
2417     }
2418
2419   if (rs6000_traceback_name)
2420     {
2421       if (! strncmp (rs6000_traceback_name, "full", 4))
2422         rs6000_traceback = traceback_full;
2423       else if (! strncmp (rs6000_traceback_name, "part", 4))
2424         rs6000_traceback = traceback_part;
2425       else if (! strncmp (rs6000_traceback_name, "no", 2))
2426         rs6000_traceback = traceback_none;
2427       else
2428         error ("unknown -mtraceback arg %qs; expecting %<full%>, %<partial%> or %<none%>",
2429                rs6000_traceback_name);
2430     }
2431
2432   if (!rs6000_explicit_options.long_double)
2433     rs6000_long_double_type_size = RS6000_DEFAULT_LONG_DOUBLE_SIZE;
2434
2435 #ifndef POWERPC_LINUX
2436   if (!rs6000_explicit_options.ieee)
2437     rs6000_ieeequad = 1;
2438 #endif
2439
2440   /* Enable Altivec ABI for AIX -maltivec.  */
2441   if (TARGET_XCOFF && (TARGET_ALTIVEC || TARGET_VSX))
2442     rs6000_altivec_abi = 1;
2443
2444   /* The AltiVec ABI is the default for PowerPC-64 GNU/Linux.  For
2445      PowerPC-32 GNU/Linux, -maltivec implies the AltiVec ABI.  It can
2446      be explicitly overridden in either case.  */
2447   if (TARGET_ELF)
2448     {
2449       if (!rs6000_explicit_options.altivec_abi
2450           && (TARGET_64BIT || TARGET_ALTIVEC || TARGET_VSX))
2451         rs6000_altivec_abi = 1;
2452
2453       /* Enable VRSAVE for AltiVec ABI, unless explicitly overridden.  */
2454       if (!rs6000_explicit_options.vrsave)
2455         TARGET_ALTIVEC_VRSAVE = rs6000_altivec_abi;
2456     }
2457
2458   /* Set the Darwin64 ABI as default for 64-bit Darwin.  */
2459   if (DEFAULT_ABI == ABI_DARWIN && TARGET_64BIT)
2460     {
2461       rs6000_darwin64_abi = 1;
2462 #if TARGET_MACHO
2463       darwin_one_byte_bool = 1;
2464 #endif
2465       /* Default to natural alignment, for better performance.  */
2466       rs6000_alignment_flags = MASK_ALIGN_NATURAL;
2467     }
2468
2469   /* Place FP constants in the constant pool instead of TOC
2470      if section anchors enabled.  */
2471   if (flag_section_anchors)
2472     TARGET_NO_FP_IN_TOC = 1;
2473
2474   /* Handle -mtls-size option.  */
2475   rs6000_parse_tls_size_option ();
2476
2477 #ifdef SUBTARGET_OVERRIDE_OPTIONS
2478   SUBTARGET_OVERRIDE_OPTIONS;
2479 #endif
2480 #ifdef SUBSUBTARGET_OVERRIDE_OPTIONS
2481   SUBSUBTARGET_OVERRIDE_OPTIONS;
2482 #endif
2483 #ifdef SUB3TARGET_OVERRIDE_OPTIONS
2484   SUB3TARGET_OVERRIDE_OPTIONS;
2485 #endif
2486
2487   if (TARGET_E500 || rs6000_cpu == PROCESSOR_PPCE500MC)
2488     {
2489       /* The e500 and e500mc do not have string instructions, and we set
2490          MASK_STRING above when optimizing for size.  */
2491       if ((target_flags & MASK_STRING) != 0)
2492         target_flags = target_flags & ~MASK_STRING;
2493     }
2494   else if (rs6000_select[1].string != NULL)
2495     {
2496       /* For the powerpc-eabispe configuration, we set all these by
2497          default, so let's unset them if we manually set another
2498          CPU that is not the E500.  */
2499       if (!rs6000_explicit_options.spe_abi)
2500         rs6000_spe_abi = 0;
2501       if (!rs6000_explicit_options.spe)
2502         rs6000_spe = 0;
2503       if (!rs6000_explicit_options.float_gprs)
2504         rs6000_float_gprs = 0;
2505       if (!(target_flags_explicit & MASK_ISEL))
2506         target_flags &= ~MASK_ISEL;
2507     }
2508
2509   /* Detect invalid option combinations with E500.  */
2510   CHECK_E500_OPTIONS;
2511
2512   rs6000_always_hint = (rs6000_cpu != PROCESSOR_POWER4
2513                         && rs6000_cpu != PROCESSOR_POWER5
2514                         && rs6000_cpu != PROCESSOR_POWER6
2515                         && rs6000_cpu != PROCESSOR_POWER7
2516                         && rs6000_cpu != PROCESSOR_PPCA2
2517                         && rs6000_cpu != PROCESSOR_CELL);
2518   rs6000_sched_groups = (rs6000_cpu == PROCESSOR_POWER4
2519                          || rs6000_cpu == PROCESSOR_POWER5
2520                          || rs6000_cpu == PROCESSOR_POWER7);
2521   rs6000_align_branch_targets = (rs6000_cpu == PROCESSOR_POWER4
2522                                  || rs6000_cpu == PROCESSOR_POWER5
2523                                  || rs6000_cpu == PROCESSOR_POWER6
2524                                  || rs6000_cpu == PROCESSOR_POWER7);
2525
2526   /* Allow debug switches to override the above settings.  */
2527   if (TARGET_ALWAYS_HINT > 0)
2528     rs6000_always_hint = TARGET_ALWAYS_HINT;
2529
2530   if (TARGET_SCHED_GROUPS > 0)
2531     rs6000_sched_groups = TARGET_SCHED_GROUPS;
2532
2533   if (TARGET_ALIGN_BRANCH_TARGETS > 0)
2534     rs6000_align_branch_targets = TARGET_ALIGN_BRANCH_TARGETS;
2535
2536   rs6000_sched_restricted_insns_priority
2537     = (rs6000_sched_groups ? 1 : 0);
2538
2539   /* Handle -msched-costly-dep option.  */
2540   rs6000_sched_costly_dep
2541     = (rs6000_sched_groups ? store_to_load_dep_costly : no_dep_costly);
2542
2543   if (rs6000_sched_costly_dep_str)
2544     {
2545       if (! strcmp (rs6000_sched_costly_dep_str, "no"))
2546         rs6000_sched_costly_dep = no_dep_costly;
2547       else if (! strcmp (rs6000_sched_costly_dep_str, "all"))
2548         rs6000_sched_costly_dep = all_deps_costly;
2549       else if (! strcmp (rs6000_sched_costly_dep_str, "true_store_to_load"))
2550         rs6000_sched_costly_dep = true_store_to_load_dep_costly;
2551       else if (! strcmp (rs6000_sched_costly_dep_str, "store_to_load"))
2552         rs6000_sched_costly_dep = store_to_load_dep_costly;
2553       else
2554         rs6000_sched_costly_dep = ((enum rs6000_dependence_cost)
2555                                    atoi (rs6000_sched_costly_dep_str));
2556     }
2557
2558   /* Handle -minsert-sched-nops option.  */
2559   rs6000_sched_insert_nops
2560     = (rs6000_sched_groups ? sched_finish_regroup_exact : sched_finish_none);
2561
2562   if (rs6000_sched_insert_nops_str)
2563     {
2564       if (! strcmp (rs6000_sched_insert_nops_str, "no"))
2565         rs6000_sched_insert_nops = sched_finish_none;
2566       else if (! strcmp (rs6000_sched_insert_nops_str, "pad"))
2567         rs6000_sched_insert_nops = sched_finish_pad_groups;
2568       else if (! strcmp (rs6000_sched_insert_nops_str, "regroup_exact"))
2569         rs6000_sched_insert_nops = sched_finish_regroup_exact;
2570       else
2571         rs6000_sched_insert_nops = ((enum rs6000_nop_insertion)
2572                                     atoi (rs6000_sched_insert_nops_str));
2573     }
2574
2575 #ifdef TARGET_REGNAMES
2576   /* If the user desires alternate register names, copy in the
2577      alternate names now.  */
2578   if (TARGET_REGNAMES)
2579     memcpy (rs6000_reg_names, alt_reg_names, sizeof (rs6000_reg_names));
2580 #endif
2581
2582   /* Set aix_struct_return last, after the ABI is determined.
2583      If -maix-struct-return or -msvr4-struct-return was explicitly
2584      used, don't override with the ABI default.  */
2585   if (!rs6000_explicit_options.aix_struct_ret)
2586     aix_struct_return = (DEFAULT_ABI != ABI_V4 || DRAFT_V4_STRUCT_RET);
2587
2588   if (TARGET_LONG_DOUBLE_128 && !TARGET_IEEEQUAD)
2589     REAL_MODE_FORMAT (TFmode) = &ibm_extended_format;
2590
2591   if (TARGET_TOC)
2592     ASM_GENERATE_INTERNAL_LABEL (toc_label_name, "LCTOC", 1);
2593
2594   /* We can only guarantee the availability of DI pseudo-ops when
2595      assembling for 64-bit targets.  */
2596   if (!TARGET_64BIT)
2597     {
2598       targetm.asm_out.aligned_op.di = NULL;
2599       targetm.asm_out.unaligned_op.di = NULL;
2600     }
2601
2602   /* Set branch target alignment, if not optimizing for size.  */
2603   if (!optimize_size)
2604     {
2605       /* Cell wants to be aligned 8byte for dual issue. */
2606       if (rs6000_cpu == PROCESSOR_CELL)
2607         {
2608           if (align_functions <= 0)
2609             align_functions = 8;
2610           if (align_jumps <= 0)
2611             align_jumps = 8;
2612           if (align_loops <= 0)
2613             align_loops = 8;
2614         }
2615       if (rs6000_align_branch_targets)
2616         {
2617           if (align_functions <= 0)
2618             align_functions = 16;
2619           if (align_jumps <= 0)
2620             align_jumps = 16;
2621           if (align_loops <= 0)
2622             align_loops = 16;
2623         }
2624       if (align_jumps_max_skip <= 0)
2625         align_jumps_max_skip = 15;
2626       if (align_loops_max_skip <= 0)
2627         align_loops_max_skip = 15;
2628     }
2629
2630   /* Arrange to save and restore machine status around nested functions.  */
2631   init_machine_status = rs6000_init_machine_status;
2632
2633   /* We should always be splitting complex arguments, but we can't break
2634      Linux and Darwin ABIs at the moment.  For now, only AIX is fixed.  */
2635   if (DEFAULT_ABI != ABI_AIX)
2636     targetm.calls.split_complex_arg = NULL;
2637
2638   /* Initialize rs6000_cost with the appropriate target costs.  */
2639   if (optimize_size)
2640     rs6000_cost = TARGET_POWERPC64 ? &size64_cost : &size32_cost;
2641   else
2642     switch (rs6000_cpu)
2643       {
2644       case PROCESSOR_RIOS1:
2645         rs6000_cost = &rios1_cost;
2646         break;
2647
2648       case PROCESSOR_RIOS2:
2649         rs6000_cost = &rios2_cost;
2650         break;
2651
2652       case PROCESSOR_RS64A:
2653         rs6000_cost = &rs64a_cost;
2654         break;
2655
2656       case PROCESSOR_MPCCORE:
2657         rs6000_cost = &mpccore_cost;
2658         break;
2659
2660       case PROCESSOR_PPC403:
2661         rs6000_cost = &ppc403_cost;
2662         break;
2663
2664       case PROCESSOR_PPC405:
2665         rs6000_cost = &ppc405_cost;
2666         break;
2667
2668       case PROCESSOR_PPC440:
2669         rs6000_cost = &ppc440_cost;
2670         break;
2671
2672       case PROCESSOR_PPC601:
2673         rs6000_cost = &ppc601_cost;
2674         break;
2675
2676       case PROCESSOR_PPC603:
2677         rs6000_cost = &ppc603_cost;
2678         break;
2679
2680       case PROCESSOR_PPC604:
2681         rs6000_cost = &ppc604_cost;
2682         break;
2683
2684       case PROCESSOR_PPC604e:
2685         rs6000_cost = &ppc604e_cost;
2686         break;
2687
2688       case PROCESSOR_PPC620:
2689         rs6000_cost = &ppc620_cost;
2690         break;
2691
2692       case PROCESSOR_PPC630:
2693         rs6000_cost = &ppc630_cost;
2694         break;
2695
2696       case PROCESSOR_CELL:
2697         rs6000_cost = &ppccell_cost;
2698         break;
2699
2700       case PROCESSOR_PPC750:
2701       case PROCESSOR_PPC7400:
2702         rs6000_cost = &ppc750_cost;
2703         break;
2704
2705       case PROCESSOR_PPC7450:
2706         rs6000_cost = &ppc7450_cost;
2707         break;
2708
2709       case PROCESSOR_PPC8540:
2710         rs6000_cost = &ppc8540_cost;
2711         break;
2712
2713       case PROCESSOR_PPCE300C2:
2714       case PROCESSOR_PPCE300C3:
2715         rs6000_cost = &ppce300c2c3_cost;
2716         break;
2717
2718       case PROCESSOR_PPCE500MC:
2719         rs6000_cost = &ppce500mc_cost;
2720         break;
2721
2722       case PROCESSOR_POWER4:
2723       case PROCESSOR_POWER5:
2724         rs6000_cost = &power4_cost;
2725         break;
2726
2727       case PROCESSOR_POWER6:
2728         rs6000_cost = &power6_cost;
2729         break;
2730
2731       case PROCESSOR_POWER7:
2732         rs6000_cost = &power7_cost;
2733         break;
2734
2735       case PROCESSOR_PPCA2:
2736         rs6000_cost = &ppca2_cost;
2737         break;
2738
2739       default:
2740         gcc_unreachable ();
2741       }
2742
2743   if (!PARAM_SET_P (PARAM_SIMULTANEOUS_PREFETCHES))
2744     set_param_value ("simultaneous-prefetches",
2745                      rs6000_cost->simultaneous_prefetches);
2746   if (!PARAM_SET_P (PARAM_L1_CACHE_SIZE))
2747     set_param_value ("l1-cache-size", rs6000_cost->l1_cache_size);
2748   if (!PARAM_SET_P (PARAM_L1_CACHE_LINE_SIZE))
2749     set_param_value ("l1-cache-line-size", rs6000_cost->cache_line_size);
2750   if (!PARAM_SET_P (PARAM_L2_CACHE_SIZE))
2751     set_param_value ("l2-cache-size", rs6000_cost->l2_cache_size);
2752
2753   /* If using typedef char *va_list, signal that __builtin_va_start (&ap, 0)
2754      can be optimized to ap = __builtin_next_arg (0).  */
2755   if (DEFAULT_ABI != ABI_V4)
2756     targetm.expand_builtin_va_start = NULL;
2757
2758   /* Set up single/double float flags.  
2759      If TARGET_HARD_FLOAT is set, but neither single or double is set, 
2760      then set both flags. */
2761   if (TARGET_HARD_FLOAT && TARGET_FPRS 
2762       && rs6000_single_float == 0 && rs6000_double_float == 0)
2763     rs6000_single_float = rs6000_double_float = 1;
2764
2765   /* Reset single and double FP flags if target is E500. */
2766   if (TARGET_E500) 
2767   {
2768     rs6000_single_float = rs6000_double_float = 0;
2769     if (TARGET_E500_SINGLE)
2770       rs6000_single_float = 1; 
2771     if (TARGET_E500_DOUBLE)
2772       rs6000_single_float = rs6000_double_float = 1;
2773   }
2774
2775   /* If not explicitly specified via option, decide whether to generate indexed
2776      load/store instructions.  */
2777   if (TARGET_AVOID_XFORM == -1)
2778     /* Avoid indexed addressing when targeting Power6 in order to avoid
2779      the DERAT mispredict penalty.  */
2780     TARGET_AVOID_XFORM = (rs6000_cpu == PROCESSOR_POWER6 && TARGET_CMPB);
2781
2782   rs6000_init_hard_regno_mode_ok ();
2783 }
2784
2785 /* Implement targetm.vectorize.builtin_mask_for_load.  */
2786 static tree
2787 rs6000_builtin_mask_for_load (void)
2788 {
2789   if (TARGET_ALTIVEC || TARGET_VSX)
2790     return altivec_builtin_mask_for_load;
2791   else
2792     return 0;
2793 }
2794
2795 /* Implement targetm.vectorize.builtin_conversion.
2796    Returns a decl of a function that implements conversion of an integer vector
2797    into a floating-point vector, or vice-versa. TYPE is the type of the integer
2798    side of the conversion.
2799    Return NULL_TREE if it is not available.  */
2800 static tree
2801 rs6000_builtin_conversion (unsigned int tcode, tree type)
2802 {
2803   enum tree_code code = (enum tree_code) tcode;
2804
2805   switch (code)
2806     {
2807     case FIX_TRUNC_EXPR:
2808       switch (TYPE_MODE (type))
2809         {
2810         case V2DImode:
2811           if (!VECTOR_UNIT_VSX_P (V2DFmode))
2812             return NULL_TREE;
2813
2814           return TYPE_UNSIGNED (type)
2815             ? rs6000_builtin_decls[VSX_BUILTIN_XVCVDPUXDS_UNS]
2816             : rs6000_builtin_decls[VSX_BUILTIN_XVCVDPSXDS];
2817
2818         case V4SImode:
2819           if (VECTOR_UNIT_NONE_P (V4SImode) || VECTOR_UNIT_NONE_P (V4SFmode))
2820             return NULL_TREE;
2821
2822           return TYPE_UNSIGNED (type)
2823             ? rs6000_builtin_decls[VECTOR_BUILTIN_FIXUNS_V4SF_V4SI]
2824             : rs6000_builtin_decls[VECTOR_BUILTIN_FIX_V4SF_V4SI];
2825
2826         default:
2827           return NULL_TREE;
2828         }
2829
2830     case FLOAT_EXPR:
2831       switch (TYPE_MODE (type))
2832         {
2833         case V2DImode:
2834           if (!VECTOR_UNIT_VSX_P (V2DFmode))
2835             return NULL_TREE;
2836
2837           return TYPE_UNSIGNED (type)
2838             ? rs6000_builtin_decls[VSX_BUILTIN_XVCVUXDDP]
2839             : rs6000_builtin_decls[VSX_BUILTIN_XVCVSXDDP];
2840
2841         case V4SImode:
2842           if (VECTOR_UNIT_NONE_P (V4SImode) || VECTOR_UNIT_NONE_P (V4SFmode))
2843             return NULL_TREE;
2844
2845           return TYPE_UNSIGNED (type)
2846             ? rs6000_builtin_decls[VECTOR_BUILTIN_UNSFLOAT_V4SI_V4SF]
2847             : rs6000_builtin_decls[VECTOR_BUILTIN_FLOAT_V4SI_V4SF];
2848
2849         default:
2850           return NULL_TREE;
2851         }
2852
2853     default:
2854       return NULL_TREE;
2855     }
2856 }
2857
2858 /* Implement targetm.vectorize.builtin_mul_widen_even.  */
2859 static tree
2860 rs6000_builtin_mul_widen_even (tree type)
2861 {
2862   if (!TARGET_ALTIVEC)
2863     return NULL_TREE;
2864
2865   switch (TYPE_MODE (type))
2866     {
2867     case V8HImode:
2868       return TYPE_UNSIGNED (type)
2869             ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULEUH_UNS]
2870             : rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULESH];
2871
2872     case V16QImode:
2873       return TYPE_UNSIGNED (type)
2874             ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULEUB_UNS]
2875             : rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULESB];
2876     default:
2877       return NULL_TREE;
2878     }
2879 }
2880
2881 /* Implement targetm.vectorize.builtin_mul_widen_odd.  */
2882 static tree
2883 rs6000_builtin_mul_widen_odd (tree type)
2884 {
2885   if (!TARGET_ALTIVEC)
2886     return NULL_TREE;
2887
2888   switch (TYPE_MODE (type))
2889     {
2890     case V8HImode:
2891       return TYPE_UNSIGNED (type)
2892             ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOUH_UNS]
2893             : rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOSH];
2894
2895     case V16QImode:
2896       return TYPE_UNSIGNED (type)
2897             ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOUB_UNS]
2898             : rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOSB];
2899     default:
2900       return NULL_TREE;
2901     }
2902 }
2903
2904
2905 /* Return true iff, data reference of TYPE can reach vector alignment (16)
2906    after applying N number of iterations.  This routine does not determine
2907    how may iterations are required to reach desired alignment.  */
2908
2909 static bool
2910 rs6000_vector_alignment_reachable (const_tree type ATTRIBUTE_UNUSED, bool is_packed)
2911 {
2912   if (is_packed)
2913     return false;
2914
2915   if (TARGET_32BIT)
2916     {
2917       if (rs6000_alignment_flags == MASK_ALIGN_NATURAL)
2918         return true;
2919
2920       if (rs6000_alignment_flags ==  MASK_ALIGN_POWER)
2921         return true;
2922
2923       return false;
2924     }
2925   else
2926     {
2927       if (TARGET_MACHO)
2928         return false;
2929
2930       /* Assuming that all other types are naturally aligned. CHECKME!  */
2931       return true;
2932     }
2933 }
2934
2935 /* Return true if the vector misalignment factor is supported by the
2936    target.  */ 
2937 bool
2938 rs6000_builtin_support_vector_misalignment (enum machine_mode mode,
2939                                             const_tree type,
2940                                             int misalignment,
2941                                             bool is_packed)
2942 {
2943   if (TARGET_VSX)
2944     {
2945       /* Return if movmisalign pattern is not supported for this mode.  */
2946       if (optab_handler (movmisalign_optab, mode)->insn_code ==
2947           CODE_FOR_nothing)
2948         return false;
2949
2950       if (misalignment == -1)
2951         {
2952           /* misalignment factor is unknown at compile time but we know
2953              it's word aligned.  */
2954           if (rs6000_vector_alignment_reachable (type, is_packed))
2955             return true;
2956           return false;
2957         }
2958       /* VSX supports word-aligned vector.  */
2959       if (misalignment % 4 == 0)
2960         return true;
2961     }
2962   return false;
2963 }
2964
2965 /* Implement targetm.vectorize.builtin_vec_perm.  */
2966 tree
2967 rs6000_builtin_vec_perm (tree type, tree *mask_element_type)
2968 {
2969   tree inner_type = TREE_TYPE (type);
2970   bool uns_p = TYPE_UNSIGNED (inner_type);
2971   tree d;
2972
2973   *mask_element_type = unsigned_char_type_node;
2974
2975   switch (TYPE_MODE (type))
2976     {
2977     case V16QImode:
2978       d = (uns_p
2979            ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_16QI_UNS]
2980            : rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_16QI]);
2981       break;
2982
2983     case V8HImode:
2984       d = (uns_p
2985            ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_8HI_UNS]
2986            : rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_8HI]);
2987       break;
2988
2989     case V4SImode:
2990       d = (uns_p
2991            ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_4SI_UNS]
2992            : rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_4SI]);
2993       break;
2994
2995     case V4SFmode:
2996       d = rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_4SF];
2997       break;
2998
2999     case V2DFmode:
3000       if (!TARGET_ALLOW_DF_PERMUTE)
3001         return NULL_TREE;
3002
3003       d = rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_2DF];
3004       break;
3005
3006     case V2DImode:
3007       if (!TARGET_ALLOW_DF_PERMUTE)
3008         return NULL_TREE;
3009
3010       d = (uns_p
3011            ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_2DI_UNS]
3012            : rs6000_builtin_decls[ALTIVEC_BUILTIN_VPERM_2DI]);
3013       break;
3014
3015     default:
3016       return NULL_TREE;
3017     }
3018
3019   gcc_assert (d);
3020   return d;
3021 }
3022
3023 /* Handle generic options of the form -mfoo=yes/no.
3024    NAME is the option name.
3025    VALUE is the option value.
3026    FLAG is the pointer to the flag where to store a 1 or 0, depending on
3027    whether the option value is 'yes' or 'no' respectively.  */
3028 static void
3029 rs6000_parse_yes_no_option (const char *name, const char *value, int *flag)
3030 {
3031   if (value == 0)
3032     return;
3033   else if (!strcmp (value, "yes"))
3034     *flag = 1;
3035   else if (!strcmp (value, "no"))
3036     *flag = 0;
3037   else
3038     error ("unknown -m%s= option specified: '%s'", name, value);
3039 }
3040
3041 /* Validate and record the size specified with the -mtls-size option.  */
3042
3043 static void
3044 rs6000_parse_tls_size_option (void)
3045 {
3046   if (rs6000_tls_size_string == 0)
3047     return;
3048   else if (strcmp (rs6000_tls_size_string, "16") == 0)
3049     rs6000_tls_size = 16;
3050   else if (strcmp (rs6000_tls_size_string, "32") == 0)
3051     rs6000_tls_size = 32;
3052   else if (strcmp (rs6000_tls_size_string, "64") == 0)
3053     rs6000_tls_size = 64;
3054   else
3055     error ("bad value %qs for -mtls-size switch", rs6000_tls_size_string);
3056 }
3057
3058 void
3059 optimization_options (int level ATTRIBUTE_UNUSED, int size ATTRIBUTE_UNUSED)
3060 {
3061   if (DEFAULT_ABI == ABI_DARWIN)
3062     /* The Darwin libraries never set errno, so we might as well
3063        avoid calling them when that's the only reason we would.  */
3064     flag_errno_math = 0;
3065
3066   /* Double growth factor to counter reduced min jump length.  */
3067   set_param_value ("max-grow-copy-bb-insns", 16);
3068
3069   /* Enable section anchors by default.
3070      Skip section anchors for Objective C and Objective C++
3071      until front-ends fixed.  */
3072   if (!TARGET_MACHO && lang_hooks.name[4] != 'O')
3073     flag_section_anchors = 2;
3074 }
3075
3076 static enum fpu_type_t
3077 rs6000_parse_fpu_option (const char *option)
3078 {
3079   if (!strcmp("none", option)) return FPU_NONE;
3080   if (!strcmp("sp_lite", option)) return FPU_SF_LITE;
3081   if (!strcmp("dp_lite", option)) return FPU_DF_LITE;
3082   if (!strcmp("sp_full", option)) return FPU_SF_FULL;
3083   if (!strcmp("dp_full", option)) return FPU_DF_FULL;
3084   error("unknown value %s for -mfpu", option);
3085   return FPU_NONE;
3086 }
3087
3088 /* Returns a function decl for a vectorized version of the builtin function
3089    with builtin function code FN and the result vector type TYPE, or NULL_TREE
3090    if it is not available.  */
3091
3092 static tree
3093 rs6000_builtin_vectorized_function (unsigned int fn, tree type_out,
3094                                     tree type_in)
3095 {
3096   enum machine_mode in_mode, out_mode;
3097   int in_n, out_n;
3098
3099   if (TREE_CODE (type_out) != VECTOR_TYPE
3100       || TREE_CODE (type_in) != VECTOR_TYPE
3101       || !TARGET_VECTORIZE_BUILTINS)
3102     return NULL_TREE;
3103
3104   out_mode = TYPE_MODE (TREE_TYPE (type_out));
3105   out_n = TYPE_VECTOR_SUBPARTS (type_out);
3106   in_mode = TYPE_MODE (TREE_TYPE (type_in));
3107   in_n = TYPE_VECTOR_SUBPARTS (type_in);
3108
3109   switch (fn)
3110     {
3111     case BUILT_IN_COPYSIGN:
3112       if (VECTOR_UNIT_VSX_P (V2DFmode)
3113           && out_mode == DFmode && out_n == 2
3114           && in_mode == DFmode && in_n == 2)
3115         return rs6000_builtin_decls[VSX_BUILTIN_CPSGNDP];
3116       break;
3117     case BUILT_IN_COPYSIGNF:
3118       if (out_mode != SFmode || out_n != 4
3119           || in_mode != SFmode || in_n != 4)
3120         break;
3121       if (VECTOR_UNIT_VSX_P (V4SFmode))
3122         return rs6000_builtin_decls[VSX_BUILTIN_CPSGNSP];
3123       if (VECTOR_UNIT_ALTIVEC_P (V4SFmode))
3124         return rs6000_builtin_decls[ALTIVEC_BUILTIN_COPYSIGN_V4SF];
3125       break;
3126     case BUILT_IN_SQRT:
3127       if (VECTOR_UNIT_VSX_P (V2DFmode)
3128           && out_mode == DFmode && out_n == 2
3129           && in_mode == DFmode && in_n == 2)
3130         return rs6000_builtin_decls[VSX_BUILTIN_XVSQRTDP];
3131       break;
3132     case BUILT_IN_SQRTF:
3133       if (VECTOR_UNIT_VSX_P (V4SFmode)
3134           && out_mode == SFmode && out_n == 4
3135           && in_mode == SFmode && in_n == 4)
3136         return rs6000_builtin_decls[VSX_BUILTIN_XVSQRTSP];
3137       break;
3138     case BUILT_IN_CEIL:
3139       if (VECTOR_UNIT_VSX_P (V2DFmode)
3140           && out_mode == DFmode && out_n == 2
3141           && in_mode == DFmode && in_n == 2)
3142         return rs6000_builtin_decls[VSX_BUILTIN_XVRDPIP];
3143       break;
3144     case BUILT_IN_CEILF:
3145       if (out_mode != SFmode || out_n != 4
3146           || in_mode != SFmode || in_n != 4)
3147         break;
3148       if (VECTOR_UNIT_VSX_P (V4SFmode))
3149         return rs6000_builtin_decls[VSX_BUILTIN_XVRSPIP];
3150       if (VECTOR_UNIT_ALTIVEC_P (V4SFmode))
3151         return rs6000_builtin_decls[ALTIVEC_BUILTIN_VRFIP];
3152       break;
3153     case BUILT_IN_FLOOR:
3154       if (VECTOR_UNIT_VSX_P (V2DFmode)
3155           && out_mode == DFmode && out_n == 2
3156           && in_mode == DFmode && in_n == 2)
3157         return rs6000_builtin_decls[VSX_BUILTIN_XVRDPIM];
3158       break;
3159     case BUILT_IN_FLOORF:
3160       if (out_mode != SFmode || out_n != 4
3161           || in_mode != SFmode || in_n != 4)
3162         break;
3163       if (VECTOR_UNIT_VSX_P (V4SFmode))
3164         return rs6000_builtin_decls[VSX_BUILTIN_XVRSPIM];
3165       if (VECTOR_UNIT_ALTIVEC_P (V4SFmode))
3166         return rs6000_builtin_decls[ALTIVEC_BUILTIN_VRFIM];
3167       break;
3168     case BUILT_IN_TRUNC:
3169       if (VECTOR_UNIT_VSX_P (V2DFmode)
3170           && out_mode == DFmode && out_n == 2
3171           && in_mode == DFmode && in_n == 2)
3172         return rs6000_builtin_decls[VSX_BUILTIN_XVRDPIZ];
3173       break;
3174     case BUILT_IN_TRUNCF:
3175       if (out_mode != SFmode || out_n != 4
3176           || in_mode != SFmode || in_n != 4)
3177         break;
3178       if (VECTOR_UNIT_VSX_P (V4SFmode))
3179         return rs6000_builtin_decls[VSX_BUILTIN_XVRSPIZ];
3180       if (VECTOR_UNIT_ALTIVEC_P (V4SFmode))
3181         return rs6000_builtin_decls[ALTIVEC_BUILTIN_VRFIZ];
3182       break;
3183     case BUILT_IN_NEARBYINT:
3184       if (VECTOR_UNIT_VSX_P (V2DFmode)
3185           && flag_unsafe_math_optimizations
3186           && out_mode == DFmode && out_n == 2
3187           && in_mode == DFmode && in_n == 2)
3188         return rs6000_builtin_decls[VSX_BUILTIN_XVRDPI];
3189       break;
3190     case BUILT_IN_NEARBYINTF:
3191       if (VECTOR_UNIT_VSX_P (V4SFmode)
3192           && flag_unsafe_math_optimizations
3193           && out_mode == SFmode && out_n == 4
3194           && in_mode == SFmode && in_n == 4)
3195         return rs6000_builtin_decls[VSX_BUILTIN_XVRSPI];
3196       break;
3197     case BUILT_IN_RINT:
3198       if (VECTOR_UNIT_VSX_P (V2DFmode)
3199           && !flag_trapping_math
3200           && out_mode == DFmode && out_n == 2
3201           && in_mode == DFmode && in_n == 2)
3202         return rs6000_builtin_decls[VSX_BUILTIN_XVRDPIC];
3203       break;
3204     case BUILT_IN_RINTF:
3205       if (VECTOR_UNIT_VSX_P (V4SFmode)
3206           && !flag_trapping_math
3207           && out_mode == SFmode && out_n == 4
3208           && in_mode == SFmode && in_n == 4)
3209         return rs6000_builtin_decls[VSX_BUILTIN_XVRSPIC];
3210       break;
3211     default:
3212       break;
3213     }
3214   return NULL_TREE;
3215 }
3216
3217
3218 /* Implement TARGET_HANDLE_OPTION.  */
3219
3220 static bool
3221 rs6000_handle_option (size_t code, const char *arg, int value)
3222 {
3223   enum fpu_type_t fpu_type = FPU_NONE;
3224   int isel;
3225
3226   switch (code)
3227     {
3228     case OPT_mno_power:
3229       target_flags &= ~(MASK_POWER | MASK_POWER2
3230                         | MASK_MULTIPLE | MASK_STRING);
3231       target_flags_explicit |= (MASK_POWER | MASK_POWER2
3232                                 | MASK_MULTIPLE | MASK_STRING);
3233       break;
3234     case OPT_mno_powerpc:
3235       target_flags &= ~(MASK_POWERPC | MASK_PPC_GPOPT
3236                         | MASK_PPC_GFXOPT | MASK_POWERPC64);
3237       target_flags_explicit |= (MASK_POWERPC | MASK_PPC_GPOPT
3238                                 | MASK_PPC_GFXOPT | MASK_POWERPC64);
3239       break;
3240     case OPT_mfull_toc:
3241       target_flags &= ~MASK_MINIMAL_TOC;
3242       TARGET_NO_FP_IN_TOC = 0;
3243       TARGET_NO_SUM_IN_TOC = 0;
3244       target_flags_explicit |= MASK_MINIMAL_TOC;
3245 #ifdef TARGET_USES_SYSV4_OPT
3246       /* Note, V.4 no longer uses a normal TOC, so make -mfull-toc, be
3247          just the same as -mminimal-toc.  */
3248       target_flags |= MASK_MINIMAL_TOC;
3249       target_flags_explicit |= MASK_MINIMAL_TOC;
3250 #endif
3251       break;
3252
3253 #ifdef TARGET_USES_SYSV4_OPT
3254     case OPT_mtoc:
3255       /* Make -mtoc behave like -mminimal-toc.  */
3256       target_flags |= MASK_MINIMAL_TOC;
3257       target_flags_explicit |= MASK_MINIMAL_TOC;
3258       break;
3259 #endif
3260
3261 #ifdef TARGET_USES_AIX64_OPT
3262     case OPT_maix64:
3263 #else
3264     case OPT_m64:
3265 #endif
3266       target_flags |= MASK_POWERPC64 | MASK_POWERPC;
3267       target_flags |= ~target_flags_explicit & MASK_PPC_GFXOPT;
3268       target_flags_explicit |= MASK_POWERPC64 | MASK_POWERPC;
3269       break;
3270
3271 #ifdef TARGET_USES_AIX64_OPT
3272     case OPT_maix32:
3273 #else
3274     case OPT_m32:
3275 #endif
3276       target_flags &= ~MASK_POWERPC64;
3277       target_flags_explicit |= MASK_POWERPC64;
3278       break;
3279
3280     case OPT_minsert_sched_nops_:
3281       rs6000_sched_insert_nops_str = arg;
3282       break;
3283
3284     case OPT_mminimal_toc:
3285       if (value == 1)
3286         {
3287           TARGET_NO_FP_IN_TOC = 0;
3288           TARGET_NO_SUM_IN_TOC = 0;
3289         }
3290       break;
3291
3292     case OPT_mpower:
3293       if (value == 1)
3294         {
3295           target_flags |= (MASK_MULTIPLE | MASK_STRING);
3296           target_flags_explicit |= (MASK_MULTIPLE | MASK_STRING);
3297         }
3298       break;
3299
3300     case OPT_mpower2:
3301       if (value == 1)
3302         {
3303           target_flags |= (MASK_POWER | MASK_MULTIPLE | MASK_STRING);
3304           target_flags_explicit |= (MASK_POWER | MASK_MULTIPLE | MASK_STRING);
3305         }
3306       break;
3307
3308     case OPT_mpowerpc_gpopt:
3309     case OPT_mpowerpc_gfxopt:
3310       if (value == 1)
3311         {
3312           target_flags |= MASK_POWERPC;
3313           target_flags_explicit |= MASK_POWERPC;
3314         }
3315       break;
3316
3317     case OPT_maix_struct_return:
3318     case OPT_msvr4_struct_return:
3319       rs6000_explicit_options.aix_struct_ret = true;
3320       break;
3321
3322     case OPT_mvrsave:
3323       rs6000_explicit_options.vrsave = true;
3324       TARGET_ALTIVEC_VRSAVE = value;
3325       break;
3326
3327     case OPT_mvrsave_:
3328       rs6000_explicit_options.vrsave = true;
3329       rs6000_parse_yes_no_option ("vrsave", arg, &(TARGET_ALTIVEC_VRSAVE));
3330       break;
3331
3332     case OPT_misel_:
3333       target_flags_explicit |= MASK_ISEL;
3334       isel = 0;
3335       rs6000_parse_yes_no_option ("isel", arg, &isel);
3336       if (isel)
3337         target_flags |= MASK_ISEL;
3338       else
3339         target_flags &= ~MASK_ISEL;
3340       break;
3341
3342     case OPT_mspe:
3343       rs6000_explicit_options.spe = true;
3344       rs6000_spe = value;
3345       break;
3346
3347     case OPT_mspe_:
3348       rs6000_explicit_options.spe = true;
3349       rs6000_parse_yes_no_option ("spe", arg, &(rs6000_spe));
3350       break;
3351
3352     case OPT_mdebug_:
3353       rs6000_debug_name = arg;
3354       break;
3355
3356 #ifdef TARGET_USES_SYSV4_OPT
3357     case OPT_mcall_:
3358       rs6000_abi_name = arg;
3359       break;
3360
3361     case OPT_msdata_:
3362       rs6000_sdata_name = arg;
3363       break;
3364
3365     case OPT_mtls_size_:
3366       rs6000_tls_size_string = arg;
3367       break;
3368
3369     case OPT_mrelocatable:
3370       if (value == 1)
3371         {
3372           target_flags |= MASK_MINIMAL_TOC;
3373           target_flags_explicit |= MASK_MINIMAL_TOC;
3374           TARGET_NO_FP_IN_TOC = 1;
3375         }
3376       break;
3377
3378     case OPT_mrelocatable_lib:
3379       if (value == 1)
3380         {
3381           target_flags |= MASK_RELOCATABLE | MASK_MINIMAL_TOC;
3382           target_flags_explicit |= MASK_RELOCATABLE | MASK_MINIMAL_TOC;
3383           TARGET_NO_FP_IN_TOC = 1;
3384         }
3385       else
3386         {
3387           target_flags &= ~MASK_RELOCATABLE;
3388           target_flags_explicit |= MASK_RELOCATABLE;
3389         }
3390       break;
3391 #endif
3392
3393     case OPT_mabi_:
3394       if (!strcmp (arg, "altivec"))
3395         {
3396           rs6000_explicit_options.altivec_abi = true;
3397           rs6000_altivec_abi = 1;
3398
3399           /* Enabling the AltiVec ABI turns off the SPE ABI.  */
3400           rs6000_spe_abi = 0;
3401         }
3402       else if (! strcmp (arg, "no-altivec"))
3403         {
3404           rs6000_explicit_options.altivec_abi = true;
3405           rs6000_altivec_abi = 0;
3406         }
3407       else if (! strcmp (arg, "spe"))
3408         {
3409           rs6000_explicit_options.spe_abi = true;
3410           rs6000_spe_abi = 1;
3411           rs6000_altivec_abi = 0;
3412           if (!TARGET_SPE_ABI)
3413             error ("not configured for ABI: '%s'", arg);
3414         }
3415       else if (! strcmp (arg, "no-spe"))
3416         {
3417           rs6000_explicit_options.spe_abi = true;
3418           rs6000_spe_abi = 0;
3419         }
3420
3421       /* These are here for testing during development only, do not
3422          document in the manual please.  */
3423       else if (! strcmp (arg, "d64"))
3424         {
3425           rs6000_darwin64_abi = 1;
3426           warning (0, "Using darwin64 ABI");
3427         }
3428       else if (! strcmp (arg, "d32"))
3429         {
3430           rs6000_darwin64_abi = 0;
3431           warning (0, "Using old darwin ABI");
3432         }
3433
3434       else if (! strcmp (arg, "ibmlongdouble"))
3435         {
3436           rs6000_explicit_options.ieee = true;
3437           rs6000_ieeequad = 0;
3438           warning (0, "Using IBM extended precision long double");
3439         }
3440       else if (! strcmp (arg, "ieeelongdouble"))
3441         {
3442           rs6000_explicit_options.ieee = true;
3443           rs6000_ieeequad = 1;
3444           warning (0, "Using IEEE extended precision long double");
3445         }
3446
3447       else
3448         {
3449           error ("unknown ABI specified: '%s'", arg);
3450           return false;
3451         }
3452       break;
3453
3454     case OPT_mcpu_:
3455       rs6000_select[1].string = arg;
3456       break;
3457
3458     case OPT_mtune_:
3459       rs6000_select[2].string = arg;
3460       break;
3461
3462     case OPT_mtraceback_:
3463       rs6000_traceback_name = arg;
3464       break;
3465
3466     case OPT_mfloat_gprs_:
3467       rs6000_explicit_options.float_gprs = true;
3468       if (! strcmp (arg, "yes") || ! strcmp (arg, "single"))
3469         rs6000_float_gprs = 1;
3470       else if (! strcmp (arg, "double"))
3471         rs6000_float_gprs = 2;
3472       else if (! strcmp (arg, "no"))
3473         rs6000_float_gprs = 0;
3474       else
3475         {
3476           error ("invalid option for -mfloat-gprs: '%s'", arg);
3477           return false;
3478         }
3479       break;
3480
3481     case OPT_mlong_double_:
3482       rs6000_explicit_options.long_double = true;
3483       rs6000_long_double_type_size = RS6000_DEFAULT_LONG_DOUBLE_SIZE;
3484       if (value != 64 && value != 128)
3485         {
3486           error ("Unknown switch -mlong-double-%s", arg);
3487           rs6000_long_double_type_size = RS6000_DEFAULT_LONG_DOUBLE_SIZE;
3488           return false;
3489         }
3490       else
3491         rs6000_long_double_type_size = value;
3492       break;
3493
3494     case OPT_msched_costly_dep_:
3495       rs6000_sched_costly_dep_str = arg;
3496       break;
3497
3498     case OPT_malign_:
3499       rs6000_explicit_options.alignment = true;
3500       if (! strcmp (arg, "power"))
3501         {
3502           /* On 64-bit Darwin, power alignment is ABI-incompatible with
3503              some C library functions, so warn about it. The flag may be
3504              useful for performance studies from time to time though, so
3505              don't disable it entirely.  */
3506           if (DEFAULT_ABI == ABI_DARWIN && TARGET_64BIT)
3507             warning (0, "-malign-power is not supported for 64-bit Darwin;"
3508                      " it is incompatible with the installed C and C++ libraries");
3509           rs6000_alignment_flags = MASK_ALIGN_POWER;
3510         }
3511       else if (! strcmp (arg, "natural"))
3512         rs6000_alignment_flags = MASK_ALIGN_NATURAL;
3513       else
3514         {
3515           error ("unknown -malign-XXXXX option specified: '%s'", arg);
3516           return false;
3517         }
3518       break;
3519
3520     case OPT_msingle_float:
3521       if (!TARGET_SINGLE_FPU) 
3522         warning (0, "-msingle-float option equivalent to -mhard-float");
3523       /* -msingle-float implies -mno-double-float and TARGET_HARD_FLOAT. */
3524       rs6000_double_float = 0;
3525       target_flags &= ~MASK_SOFT_FLOAT;
3526       target_flags_explicit |= MASK_SOFT_FLOAT;
3527       break;
3528
3529     case OPT_mdouble_float:
3530       /* -mdouble-float implies -msingle-float and TARGET_HARD_FLOAT. */
3531       rs6000_single_float = 1;
3532       target_flags &= ~MASK_SOFT_FLOAT;
3533       target_flags_explicit |= MASK_SOFT_FLOAT;
3534       break;
3535
3536     case OPT_msimple_fpu:
3537       if (!TARGET_SINGLE_FPU) 
3538         warning (0, "-msimple-fpu option ignored");
3539       break;
3540
3541     case OPT_mhard_float:
3542       /* -mhard_float implies -msingle-float and -mdouble-float. */
3543       rs6000_single_float = rs6000_double_float = 1;
3544       break;
3545
3546     case OPT_msoft_float:
3547       /* -msoft_float implies -mnosingle-float and -mnodouble-float. */
3548       rs6000_single_float = rs6000_double_float = 0;
3549       break;
3550
3551     case OPT_mfpu_:
3552       fpu_type = rs6000_parse_fpu_option(arg);
3553       if (fpu_type != FPU_NONE) 
3554       /* If -mfpu is not none, then turn off SOFT_FLOAT, turn on HARD_FLOAT. */
3555       {
3556         target_flags &= ~MASK_SOFT_FLOAT;
3557         target_flags_explicit |= MASK_SOFT_FLOAT;
3558         rs6000_xilinx_fpu = 1;
3559         if (fpu_type == FPU_SF_LITE || fpu_type == FPU_SF_FULL) 
3560         rs6000_single_float = 1;
3561         if (fpu_type == FPU_DF_LITE || fpu_type == FPU_DF_FULL) 
3562           rs6000_single_float = rs6000_double_float = 1;
3563         if (fpu_type == FPU_SF_LITE || fpu_type == FPU_DF_LITE) 
3564           rs6000_simple_fpu = 1;
3565       }
3566       else
3567       {
3568         /* -mfpu=none is equivalent to -msoft-float */
3569         target_flags |= MASK_SOFT_FLOAT;
3570         target_flags_explicit |= MASK_SOFT_FLOAT;
3571         rs6000_single_float = rs6000_double_float = 0;
3572       }
3573       break;
3574     }
3575   return true;
3576 }
3577 \f
3578 /* Do anything needed at the start of the asm file.  */
3579
3580 static void
3581 rs6000_file_start (void)
3582 {
3583   size_t i;
3584   char buffer[80];
3585   const char *start = buffer;
3586   struct rs6000_cpu_select *ptr;
3587   const char *default_cpu = TARGET_CPU_DEFAULT;
3588   FILE *file = asm_out_file;
3589
3590   default_file_start ();
3591
3592 #ifdef TARGET_BI_ARCH
3593   if ((TARGET_DEFAULT ^ target_flags) & MASK_64BIT)
3594     default_cpu = 0;
3595 #endif
3596
3597   if (flag_verbose_asm)
3598     {
3599       sprintf (buffer, "\n%s rs6000/powerpc options:", ASM_COMMENT_START);
3600       rs6000_select[0].string = default_cpu;
3601
3602       for (i = 0; i < ARRAY_SIZE (rs6000_select); i++)
3603         {
3604           ptr = &rs6000_select[i];
3605           if (ptr->string != (char *)0 && ptr->string[0] != '\0')
3606             {
3607               fprintf (file, "%s %s%s", start, ptr->name, ptr->string);
3608               start = "";
3609             }
3610         }
3611
3612       if (PPC405_ERRATUM77)
3613         {
3614           fprintf (file, "%s PPC405CR_ERRATUM77", start);
3615           start = "";
3616         }
3617
3618 #ifdef USING_ELFOS_H
3619       switch (rs6000_sdata)
3620         {
3621         case SDATA_NONE: fprintf (file, "%s -msdata=none", start); start = ""; break;
3622         case SDATA_DATA: fprintf (file, "%s -msdata=data", start); start = ""; break;
3623         case SDATA_SYSV: fprintf (file, "%s -msdata=sysv", start); start = ""; break;
3624         case SDATA_EABI: fprintf (file, "%s -msdata=eabi", start); start = ""; break;
3625         }
3626
3627       if (rs6000_sdata && g_switch_value)
3628         {
3629           fprintf (file, "%s -G " HOST_WIDE_INT_PRINT_UNSIGNED, start,
3630                    g_switch_value);
3631           start = "";
3632         }
3633 #endif
3634
3635       if (*start == '\0')
3636         putc ('\n', file);
3637     }
3638
3639 #ifdef HAVE_AS_GNU_ATTRIBUTE
3640   if (TARGET_32BIT && DEFAULT_ABI == ABI_V4)
3641     {
3642       fprintf (file, "\t.gnu_attribute 4, %d\n",
3643                ((TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT) ? 1 
3644                 : (TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT) ? 3 
3645                 : 2));
3646       fprintf (file, "\t.gnu_attribute 8, %d\n",
3647                (TARGET_ALTIVEC_ABI ? 2
3648                 : TARGET_SPE_ABI ? 3
3649                 : 1));
3650       fprintf (file, "\t.gnu_attribute 12, %d\n",
3651                aix_struct_return ? 2 : 1);
3652
3653     }
3654 #endif
3655
3656   if (DEFAULT_ABI == ABI_AIX || (TARGET_ELF && flag_pic == 2))
3657     {
3658       switch_to_section (toc_section);
3659       switch_to_section (text_section);
3660     }
3661 }
3662
3663 \f
3664 /* Return nonzero if this function is known to have a null epilogue.  */
3665
3666 int
3667 direct_return (void)
3668 {
3669   if (reload_completed)
3670     {
3671       rs6000_stack_t *info = rs6000_stack_info ();
3672
3673       if (info->first_gp_reg_save == 32
3674           && info->first_fp_reg_save == 64
3675           && info->first_altivec_reg_save == LAST_ALTIVEC_REGNO + 1
3676           && ! info->lr_save_p
3677           && ! info->cr_save_p
3678           && info->vrsave_mask == 0
3679           && ! info->push_p)
3680         return 1;
3681     }
3682
3683   return 0;
3684 }
3685
3686 /* Return the number of instructions it takes to form a constant in an
3687    integer register.  */
3688
3689 int
3690 num_insns_constant_wide (HOST_WIDE_INT value)
3691 {
3692   /* signed constant loadable with {cal|addi} */
3693   if ((unsigned HOST_WIDE_INT) (value + 0x8000) < 0x10000)
3694     return 1;
3695
3696   /* constant loadable with {cau|addis} */
3697   else if ((value & 0xffff) == 0
3698            && (value >> 31 == -1 || value >> 31 == 0))
3699     return 1;
3700
3701 #if HOST_BITS_PER_WIDE_INT == 64
3702   else if (TARGET_POWERPC64)
3703     {
3704       HOST_WIDE_INT low  = ((value & 0xffffffff) ^ 0x80000000) - 0x80000000;
3705       HOST_WIDE_INT high = value >> 31;
3706
3707       if (high == 0 || high == -1)
3708         return 2;
3709
3710       high >>= 1;
3711
3712       if (low == 0)
3713         return num_insns_constant_wide (high) + 1;
3714       else
3715         return (num_insns_constant_wide (high)
3716                 + num_insns_constant_wide (low) + 1);
3717     }
3718 #endif
3719
3720   else
3721     return 2;
3722 }
3723
3724 int
3725 num_insns_constant (rtx op, enum machine_mode mode)
3726 {
3727   HOST_WIDE_INT low, high;
3728
3729   switch (GET_CODE (op))
3730     {
3731     case CONST_INT:
3732 #if HOST_BITS_PER_WIDE_INT == 64
3733       if ((INTVAL (op) >> 31) != 0 && (INTVAL (op) >> 31) != -1
3734           && mask64_operand (op, mode))
3735         return 2;
3736       else
3737 #endif
3738         return num_insns_constant_wide (INTVAL (op));
3739
3740       case CONST_DOUBLE:
3741         if (mode == SFmode || mode == SDmode)
3742           {
3743             long l;
3744             REAL_VALUE_TYPE rv;
3745
3746             REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
3747             if (DECIMAL_FLOAT_MODE_P (mode))
3748               REAL_VALUE_TO_TARGET_DECIMAL32 (rv, l);
3749             else
3750               REAL_VALUE_TO_TARGET_SINGLE (rv, l);
3751             return num_insns_constant_wide ((HOST_WIDE_INT) l);
3752           }
3753
3754         if (mode == VOIDmode || mode == DImode)
3755           {
3756             high = CONST_DOUBLE_HIGH (op);
3757             low  = CONST_DOUBLE_LOW (op);
3758           }
3759         else
3760           {
3761             long l[2];
3762             REAL_VALUE_TYPE rv;
3763
3764             REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
3765             if (DECIMAL_FLOAT_MODE_P (mode))
3766               REAL_VALUE_TO_TARGET_DECIMAL64 (rv, l);
3767             else
3768               REAL_VALUE_TO_TARGET_DOUBLE (rv, l);
3769             high = l[WORDS_BIG_ENDIAN == 0];
3770             low  = l[WORDS_BIG_ENDIAN != 0];
3771           }
3772
3773         if (TARGET_32BIT)
3774           return (num_insns_constant_wide (low)
3775                   + num_insns_constant_wide (high));
3776         else
3777           {
3778             if ((high == 0 && low >= 0)
3779                 || (high == -1 && low < 0))
3780               return num_insns_constant_wide (low);
3781
3782             else if (mask64_operand (op, mode))
3783               return 2;
3784
3785             else if (low == 0)
3786               return num_insns_constant_wide (high) + 1;
3787
3788             else
3789               return (num_insns_constant_wide (high)
3790                       + num_insns_constant_wide (low) + 1);
3791           }
3792
3793     default:
3794       gcc_unreachable ();
3795     }
3796 }
3797
3798 /* Interpret element ELT of the CONST_VECTOR OP as an integer value.
3799    If the mode of OP is MODE_VECTOR_INT, this simply returns the
3800    corresponding element of the vector, but for V4SFmode and V2SFmode,
3801    the corresponding "float" is interpreted as an SImode integer.  */
3802
3803 HOST_WIDE_INT
3804 const_vector_elt_as_int (rtx op, unsigned int elt)
3805 {
3806   rtx tmp = CONST_VECTOR_ELT (op, elt);
3807   if (GET_MODE (op) == V4SFmode
3808       || GET_MODE (op) == V2SFmode)
3809     tmp = gen_lowpart (SImode, tmp);
3810   return INTVAL (tmp);
3811 }
3812
3813 /* Return true if OP can be synthesized with a particular vspltisb, vspltish
3814    or vspltisw instruction.  OP is a CONST_VECTOR.  Which instruction is used
3815    depends on STEP and COPIES, one of which will be 1.  If COPIES > 1,
3816    all items are set to the same value and contain COPIES replicas of the
3817    vsplt's operand; if STEP > 1, one in STEP elements is set to the vsplt's
3818    operand and the others are set to the value of the operand's msb.  */
3819
3820 static bool
3821 vspltis_constant (rtx op, unsigned step, unsigned copies)
3822 {
3823   enum machine_mode mode = GET_MODE (op);
3824   enum machine_mode inner = GET_MODE_INNER (mode);
3825
3826   unsigned i;
3827   unsigned nunits = GET_MODE_NUNITS (mode);
3828   unsigned bitsize = GET_MODE_BITSIZE (inner);
3829   unsigned mask = GET_MODE_MASK (inner);
3830
3831   HOST_WIDE_INT val = const_vector_elt_as_int (op, nunits - 1);
3832   HOST_WIDE_INT splat_val = val;
3833   HOST_WIDE_INT msb_val = val > 0 ? 0 : -1;
3834
3835   /* Construct the value to be splatted, if possible.  If not, return 0.  */
3836   for (i = 2; i <= copies; i *= 2)
3837     {
3838       HOST_WIDE_INT small_val;
3839       bitsize /= 2;
3840       small_val = splat_val >> bitsize;
3841       mask >>= bitsize;
3842       if (splat_val != ((small_val << bitsize) | (small_val & mask)))
3843         return false;
3844       splat_val = small_val;
3845     }
3846
3847   /* Check if SPLAT_VAL can really be the operand of a vspltis[bhw].  */
3848   if (EASY_VECTOR_15 (splat_val))
3849     ;
3850
3851   /* Also check if we can splat, and then add the result to itself.  Do so if
3852      the value is positive, of if the splat instruction is using OP's mode;
3853      for splat_val < 0, the splat and the add should use the same mode.  */
3854   else if (EASY_VECTOR_15_ADD_SELF (splat_val)
3855            && (splat_val >= 0 || (step == 1 && copies == 1)))
3856     ;
3857
3858   /* Also check if are loading up the most significant bit which can be done by
3859      loading up -1 and shifting the value left by -1.  */
3860   else if (EASY_VECTOR_MSB (splat_val, inner))
3861     ;
3862
3863   else
3864     return false;
3865
3866   /* Check if VAL is present in every STEP-th element, and the
3867      other elements are filled with its most significant bit.  */
3868   for (i = 0; i < nunits - 1; ++i)
3869     {
3870       HOST_WIDE_INT desired_val;
3871       if (((i + 1) & (step - 1)) == 0)
3872         desired_val = val;
3873       else
3874         desired_val = msb_val;
3875
3876       if (desired_val != const_vector_elt_as_int (op, i))
3877         return false;
3878     }
3879
3880   return true;
3881 }
3882
3883
3884 /* Return true if OP is of the given MODE and can be synthesized
3885    with a vspltisb, vspltish or vspltisw.  */
3886
3887 bool
3888 easy_altivec_constant (rtx op, enum machine_mode mode)
3889 {
3890   unsigned step, copies;
3891
3892   if (mode == VOIDmode)
3893     mode = GET_MODE (op);
3894   else if (mode != GET_MODE (op))
3895     return false;
3896
3897   /* Start with a vspltisw.  */
3898   step = GET_MODE_NUNITS (mode) / 4;
3899   copies = 1;
3900
3901   if (vspltis_constant (op, step, copies))
3902     return true;
3903
3904   /* Then try with a vspltish.  */
3905   if (step == 1)
3906     copies <<= 1;
3907   else
3908     step >>= 1;
3909
3910   if (vspltis_constant (op, step, copies))
3911     return true;
3912
3913   /* And finally a vspltisb.  */
3914   if (step == 1)
3915     copies <<= 1;
3916   else
3917     step >>= 1;
3918
3919   if (vspltis_constant (op, step, copies))
3920     return true;
3921
3922   return false;
3923 }
3924
3925 /* Generate a VEC_DUPLICATE representing a vspltis[bhw] instruction whose
3926    result is OP.  Abort if it is not possible.  */
3927
3928 rtx
3929 gen_easy_altivec_constant (rtx op)
3930 {
3931   enum machine_mode mode = GET_MODE (op);
3932   int nunits = GET_MODE_NUNITS (mode);
3933   rtx last = CONST_VECTOR_ELT (op, nunits - 1);
3934   unsigned step = nunits / 4;
3935   unsigned copies = 1;
3936
3937   /* Start with a vspltisw.  */
3938   if (vspltis_constant (op, step, copies))
3939     return gen_rtx_VEC_DUPLICATE (V4SImode, gen_lowpart (SImode, last));
3940
3941   /* Then try with a vspltish.  */
3942   if (step == 1)
3943     copies <<= 1;
3944   else
3945     step >>= 1;
3946
3947   if (vspltis_constant (op, step, copies))
3948     return gen_rtx_VEC_DUPLICATE (V8HImode, gen_lowpart (HImode, last));
3949
3950   /* And finally a vspltisb.  */
3951   if (step == 1)
3952     copies <<= 1;
3953   else
3954     step >>= 1;
3955
3956   if (vspltis_constant (op, step, copies))
3957     return gen_rtx_VEC_DUPLICATE (V16QImode, gen_lowpart (QImode, last));
3958
3959   gcc_unreachable ();
3960 }
3961
3962 const char *
3963 output_vec_const_move (rtx *operands)
3964 {
3965   int cst, cst2;
3966   enum machine_mode mode;
3967   rtx dest, vec;
3968
3969   dest = operands[0];
3970   vec = operands[1];
3971   mode = GET_MODE (dest);
3972
3973   if (TARGET_VSX && zero_constant (vec, mode))
3974     return "xxlxor %x0,%x0,%x0";
3975
3976   if (TARGET_ALTIVEC)
3977     {
3978       rtx splat_vec;
3979       if (zero_constant (vec, mode))
3980         return "vxor %0,%0,%0";
3981
3982       splat_vec = gen_easy_altivec_constant (vec);
3983       gcc_assert (GET_CODE (splat_vec) == VEC_DUPLICATE);
3984       operands[1] = XEXP (splat_vec, 0);
3985       if (!EASY_VECTOR_15 (INTVAL (operands[1])))
3986         return "#";
3987
3988       switch (GET_MODE (splat_vec))
3989         {
3990         case V4SImode:
3991           return "vspltisw %0,%1";
3992
3993         case V8HImode:
3994           return "vspltish %0,%1";
3995
3996         case V16QImode:
3997           return "vspltisb %0,%1";
3998
3999         default:
4000           gcc_unreachable ();
4001         }