OSDN Git Service

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