OSDN Git Service

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