OSDN Git Service

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