OSDN Git Service

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