OSDN Git Service

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