OSDN Git Service

* config/rs6000/rs6000.c (rs6000_emit_epilogue): Correct
[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
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 "real.h"
31 #include "insn-config.h"
32 #include "conditions.h"
33 #include "insn-attr.h"
34 #include "flags.h"
35 #include "recog.h"
36 #include "obstack.h"
37 #include "tree.h"
38 #include "expr.h"
39 #include "optabs.h"
40 #include "except.h"
41 #include "function.h"
42 #include "output.h"
43 #include "basic-block.h"
44 #include "integrate.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 "tree-gimple.h"
56 #include "intl.h"
57 #include "params.h"
58 #include "tm-constrs.h"
59 #if TARGET_XCOFF
60 #include "xcoffout.h"  /* get declarations of xcoff_*_section_name */
61 #endif
62 #if TARGET_MACHO
63 #include "gstab.h"  /* for N_SLINE */
64 #endif
65
66 #ifndef TARGET_NO_PROTOTYPE
67 #define TARGET_NO_PROTOTYPE 0
68 #endif
69
70 #define min(A,B)        ((A) < (B) ? (A) : (B))
71 #define max(A,B)        ((A) > (B) ? (A) : (B))
72
73 /* Structure used to define the rs6000 stack */
74 typedef struct rs6000_stack {
75   int first_gp_reg_save;        /* first callee saved GP register used */
76   int first_fp_reg_save;        /* first callee saved FP register used */
77   int first_altivec_reg_save;   /* first callee saved AltiVec register used */
78   int lr_save_p;                /* true if the link reg needs to be saved */
79   int cr_save_p;                /* true if the CR reg needs to be saved */
80   unsigned int vrsave_mask;     /* mask of vec registers to save */
81   int push_p;                   /* true if we need to allocate stack space */
82   int calls_p;                  /* true if the function makes any calls */
83   int world_save_p;             /* true if we're saving *everything*:
84                                    r13-r31, cr, f14-f31, vrsave, v20-v31  */
85   enum rs6000_abi abi;          /* which ABI to use */
86   int gp_save_offset;           /* offset to save GP regs from initial SP */
87   int fp_save_offset;           /* offset to save FP regs from initial SP */
88   int altivec_save_offset;      /* offset to save AltiVec regs from initial SP */
89   int lr_save_offset;           /* offset to save LR from initial SP */
90   int cr_save_offset;           /* offset to save CR from initial SP */
91   int vrsave_save_offset;       /* offset to save VRSAVE from initial SP */
92   int spe_gp_save_offset;       /* offset to save spe 64-bit gprs  */
93   int varargs_save_offset;      /* offset to save the varargs registers */
94   int ehrd_offset;              /* offset to EH return data */
95   int reg_size;                 /* register size (4 or 8) */
96   HOST_WIDE_INT vars_size;      /* variable save area size */
97   int parm_size;                /* outgoing parameter size */
98   int save_size;                /* save area size */
99   int fixed_size;               /* fixed size of stack frame */
100   int gp_size;                  /* size of saved GP registers */
101   int fp_size;                  /* size of saved FP registers */
102   int altivec_size;             /* size of saved AltiVec registers */
103   int cr_size;                  /* size to hold CR if not in save_size */
104   int vrsave_size;              /* size to hold VRSAVE if not in save_size */
105   int altivec_padding_size;     /* size of altivec alignment padding if
106                                    not in save_size */
107   int spe_gp_size;              /* size of 64-bit GPR save size for SPE */
108   int spe_padding_size;
109   HOST_WIDE_INT total_size;     /* total bytes allocated for stack */
110   int spe_64bit_regs_used;
111 } rs6000_stack_t;
112
113 /* A C structure for machine-specific, per-function data.
114    This is added to the cfun structure.  */
115 typedef struct machine_function GTY(())
116 {
117   /* Flags if __builtin_return_address (n) with n >= 1 was used.  */
118   int ra_needs_full_frame;
119   /* Some local-dynamic symbol.  */
120   const char *some_ld_name;
121   /* Whether the instruction chain has been scanned already.  */
122   int insn_chain_scanned_p;
123   /* Flags if __builtin_return_address (0) was used.  */
124   int ra_need_lr;
125   /* Offset from virtual_stack_vars_rtx to the start of the ABI_V4
126      varargs save area.  */
127   HOST_WIDE_INT varargs_save_offset;
128 } machine_function;
129
130 /* Target cpu type */
131
132 enum processor_type rs6000_cpu;
133 struct rs6000_cpu_select rs6000_select[3] =
134 {
135   /* switch             name,                   tune    arch */
136   { (const char *)0,    "--with-cpu=",          1,      1 },
137   { (const char *)0,    "-mcpu=",               1,      1 },
138   { (const char *)0,    "-mtune=",              1,      0 },
139 };
140
141 static GTY(()) bool rs6000_cell_dont_microcode;
142
143 /* Always emit branch hint bits.  */
144 static GTY(()) bool rs6000_always_hint;
145
146 /* Schedule instructions for group formation.  */
147 static GTY(()) bool rs6000_sched_groups;
148
149 /* Align branch targets.  */
150 static GTY(()) bool rs6000_align_branch_targets;
151
152 /* Support for -msched-costly-dep option.  */
153 const char *rs6000_sched_costly_dep_str;
154 enum rs6000_dependence_cost rs6000_sched_costly_dep;
155
156 /* Support for -minsert-sched-nops option.  */
157 const char *rs6000_sched_insert_nops_str;
158 enum rs6000_nop_insertion rs6000_sched_insert_nops;
159
160 /* Support targetm.vectorize.builtin_mask_for_load.  */
161 static GTY(()) tree altivec_builtin_mask_for_load;
162
163 /* Size of long double.  */
164 int rs6000_long_double_type_size;
165
166 /* IEEE quad extended precision long double. */
167 int rs6000_ieeequad;
168
169 /* Whether -mabi=altivec has appeared.  */
170 int rs6000_altivec_abi;
171
172 /* Nonzero if we want SPE ABI extensions.  */
173 int rs6000_spe_abi;
174
175 /* Nonzero if floating point operations are done in the GPRs.  */
176 int rs6000_float_gprs = 0;
177
178 /* Nonzero if we want Darwin's struct-by-value-in-regs ABI.  */
179 int rs6000_darwin64_abi;
180
181 /* Set to nonzero once AIX common-mode calls have been defined.  */
182 static GTY(()) int common_mode_defined;
183
184 /* Save information from a "cmpxx" operation until the branch or scc is
185    emitted.  */
186 rtx rs6000_compare_op0, rs6000_compare_op1;
187 int rs6000_compare_fp_p;
188
189 /* Label number of label created for -mrelocatable, to call to so we can
190    get the address of the GOT section */
191 int rs6000_pic_labelno;
192
193 #ifdef USING_ELFOS_H
194 /* Which abi to adhere to */
195 const char *rs6000_abi_name;
196
197 /* Semantics of the small data area */
198 enum rs6000_sdata_type rs6000_sdata = SDATA_DATA;
199
200 /* Which small data model to use */
201 const char *rs6000_sdata_name = (char *)0;
202
203 /* Counter for labels which are to be placed in .fixup.  */
204 int fixuplabelno = 0;
205 #endif
206
207 /* Bit size of immediate TLS offsets and string from which it is decoded.  */
208 int rs6000_tls_size = 32;
209 const char *rs6000_tls_size_string;
210
211 /* ABI enumeration available for subtarget to use.  */
212 enum rs6000_abi rs6000_current_abi;
213
214 /* Whether to use variant of AIX ABI for PowerPC64 Linux.  */
215 int dot_symbols;
216
217 /* Debug flags */
218 const char *rs6000_debug_name;
219 int rs6000_debug_stack;         /* debug stack applications */
220 int rs6000_debug_arg;           /* debug argument handling */
221
222 /* Value is TRUE if register/mode pair is acceptable.  */
223 bool rs6000_hard_regno_mode_ok_p[NUM_MACHINE_MODES][FIRST_PSEUDO_REGISTER];
224
225 /* Built in types.  */
226
227 tree rs6000_builtin_types[RS6000_BTI_MAX];
228 tree rs6000_builtin_decls[RS6000_BUILTIN_COUNT];
229
230 const char *rs6000_traceback_name;
231 static enum {
232   traceback_default = 0,
233   traceback_none,
234   traceback_part,
235   traceback_full
236 } rs6000_traceback;
237
238 /* Flag to say the TOC is initialized */
239 int toc_initialized;
240 char toc_label_name[10];
241
242 /* Cached value of rs6000_variable_issue. This is cached in
243    rs6000_variable_issue hook and returned from rs6000_sched_reorder2.  */
244 static short cached_can_issue_more;
245
246 static GTY(()) section *read_only_data_section;
247 static GTY(()) section *private_data_section;
248 static GTY(()) section *read_only_private_data_section;
249 static GTY(()) section *sdata2_section;
250 static GTY(()) section *toc_section;
251
252 /* Control alignment for fields within structures.  */
253 /* String from -malign-XXXXX.  */
254 int rs6000_alignment_flags;
255
256 /* True for any options that were explicitly set.  */
257 struct {
258   bool aix_struct_ret;          /* True if -maix-struct-ret was used.  */
259   bool alignment;               /* True if -malign- was used.  */
260   bool abi;                     /* True if -mabi=spe/nospe was used.  */
261   bool spe;                     /* True if -mspe= was used.  */
262   bool float_gprs;              /* True if -mfloat-gprs= was used.  */
263   bool isel;                    /* True if -misel was used. */
264   bool long_double;             /* True if -mlong-double- was used.  */
265   bool ieee;                    /* True if -mabi=ieee/ibmlongdouble used.  */
266 } rs6000_explicit_options;
267
268 struct builtin_description
269 {
270   /* mask is not const because we're going to alter it below.  This
271      nonsense will go away when we rewrite the -march infrastructure
272      to give us more target flag bits.  */
273   unsigned int mask;
274   const enum insn_code icode;
275   const char *const name;
276   const enum rs6000_builtins code;
277 };
278 \f
279 /* Target cpu costs.  */
280
281 struct processor_costs {
282   const int mulsi;        /* cost of SImode multiplication.  */
283   const int mulsi_const;  /* cost of SImode multiplication by constant.  */
284   const int mulsi_const9; /* cost of SImode mult by short constant.  */
285   const int muldi;        /* cost of DImode multiplication.  */
286   const int divsi;        /* cost of SImode division.  */
287   const int divdi;        /* cost of DImode division.  */
288   const int fp;           /* cost of simple SFmode and DFmode insns.  */
289   const int dmul;         /* cost of DFmode multiplication (and fmadd).  */
290   const int sdiv;         /* cost of SFmode division (fdivs).  */
291   const int ddiv;         /* cost of DFmode division (fdiv).  */
292   const int cache_line_size;    /* cache line size in bytes. */
293   const int l1_cache_size;      /* size of l1 cache, in kilobytes.  */
294   const int l2_cache_size;      /* size of l2 cache, in kilobytes.  */
295   const int simultaneous_prefetches; /* number of parallel prefetch
296                                         operations.  */
297 };
298
299 const struct processor_costs *rs6000_cost;
300
301 /* Processor costs (relative to an add) */
302
303 /* Instruction size costs on 32bit processors.  */
304 static const
305 struct processor_costs size32_cost = {
306   COSTS_N_INSNS (1),    /* mulsi */
307   COSTS_N_INSNS (1),    /* mulsi_const */
308   COSTS_N_INSNS (1),    /* mulsi_const9 */
309   COSTS_N_INSNS (1),    /* muldi */
310   COSTS_N_INSNS (1),    /* divsi */
311   COSTS_N_INSNS (1),    /* divdi */
312   COSTS_N_INSNS (1),    /* fp */
313   COSTS_N_INSNS (1),    /* dmul */
314   COSTS_N_INSNS (1),    /* sdiv */
315   COSTS_N_INSNS (1),    /* ddiv */
316   32,
317   0,
318   0,
319   0,
320 };
321
322 /* Instruction size costs on 64bit processors.  */
323 static const
324 struct processor_costs size64_cost = {
325   COSTS_N_INSNS (1),    /* mulsi */
326   COSTS_N_INSNS (1),    /* mulsi_const */
327   COSTS_N_INSNS (1),    /* mulsi_const9 */
328   COSTS_N_INSNS (1),    /* muldi */
329   COSTS_N_INSNS (1),    /* divsi */
330   COSTS_N_INSNS (1),    /* divdi */
331   COSTS_N_INSNS (1),    /* fp */
332   COSTS_N_INSNS (1),    /* dmul */
333   COSTS_N_INSNS (1),    /* sdiv */
334   COSTS_N_INSNS (1),    /* ddiv */
335   128,
336   0,
337   0,
338   0,
339 };
340
341 /* Instruction costs on RIOS1 processors.  */
342 static const
343 struct processor_costs rios1_cost = {
344   COSTS_N_INSNS (5),    /* mulsi */
345   COSTS_N_INSNS (4),    /* mulsi_const */
346   COSTS_N_INSNS (3),    /* mulsi_const9 */
347   COSTS_N_INSNS (5),    /* muldi */
348   COSTS_N_INSNS (19),   /* divsi */
349   COSTS_N_INSNS (19),   /* divdi */
350   COSTS_N_INSNS (2),    /* fp */
351   COSTS_N_INSNS (2),    /* dmul */
352   COSTS_N_INSNS (19),   /* sdiv */
353   COSTS_N_INSNS (19),   /* ddiv */
354   128,
355   64,                   /* l1 cache */
356   512,                  /* l2 cache */
357   0,                    /* streams */
358 };
359
360 /* Instruction costs on RIOS2 processors.  */
361 static const
362 struct processor_costs rios2_cost = {
363   COSTS_N_INSNS (2),    /* mulsi */
364   COSTS_N_INSNS (2),    /* mulsi_const */
365   COSTS_N_INSNS (2),    /* mulsi_const9 */
366   COSTS_N_INSNS (2),    /* muldi */
367   COSTS_N_INSNS (13),   /* divsi */
368   COSTS_N_INSNS (13),   /* divdi */
369   COSTS_N_INSNS (2),    /* fp */
370   COSTS_N_INSNS (2),    /* dmul */
371   COSTS_N_INSNS (17),   /* sdiv */
372   COSTS_N_INSNS (17),   /* ddiv */
373   256,
374   256,                  /* l1 cache */
375   1024,                 /* l2 cache */
376   0,                    /* streams */
377 };
378
379 /* Instruction costs on RS64A processors.  */
380 static const
381 struct processor_costs rs64a_cost = {
382   COSTS_N_INSNS (20),   /* mulsi */
383   COSTS_N_INSNS (12),   /* mulsi_const */
384   COSTS_N_INSNS (8),    /* mulsi_const9 */
385   COSTS_N_INSNS (34),   /* muldi */
386   COSTS_N_INSNS (65),   /* divsi */
387   COSTS_N_INSNS (67),   /* divdi */
388   COSTS_N_INSNS (4),    /* fp */
389   COSTS_N_INSNS (4),    /* dmul */
390   COSTS_N_INSNS (31),   /* sdiv */
391   COSTS_N_INSNS (31),   /* ddiv */
392   128,
393   128,                  /* l1 cache */
394   2048,                 /* l2 cache */
395   1,                    /* streams */
396 };
397
398 /* Instruction costs on MPCCORE processors.  */
399 static const
400 struct processor_costs mpccore_cost = {
401   COSTS_N_INSNS (2),    /* mulsi */
402   COSTS_N_INSNS (2),    /* mulsi_const */
403   COSTS_N_INSNS (2),    /* mulsi_const9 */
404   COSTS_N_INSNS (2),    /* muldi */
405   COSTS_N_INSNS (6),    /* divsi */
406   COSTS_N_INSNS (6),    /* divdi */
407   COSTS_N_INSNS (4),    /* fp */
408   COSTS_N_INSNS (5),    /* dmul */
409   COSTS_N_INSNS (10),   /* sdiv */
410   COSTS_N_INSNS (17),   /* ddiv */
411   32,
412   4,                    /* l1 cache */
413   16,                   /* l2 cache */
414   1,                    /* streams */
415 };
416
417 /* Instruction costs on PPC403 processors.  */
418 static const
419 struct processor_costs ppc403_cost = {
420   COSTS_N_INSNS (4),    /* mulsi */
421   COSTS_N_INSNS (4),    /* mulsi_const */
422   COSTS_N_INSNS (4),    /* mulsi_const9 */
423   COSTS_N_INSNS (4),    /* muldi */
424   COSTS_N_INSNS (33),   /* divsi */
425   COSTS_N_INSNS (33),   /* divdi */
426   COSTS_N_INSNS (11),   /* fp */
427   COSTS_N_INSNS (11),   /* dmul */
428   COSTS_N_INSNS (11),   /* sdiv */
429   COSTS_N_INSNS (11),   /* ddiv */
430   32,
431   4,                    /* l1 cache */
432   16,                   /* l2 cache */
433   1,                    /* streams */
434 };
435
436 /* Instruction costs on PPC405 processors.  */
437 static const
438 struct processor_costs ppc405_cost = {
439   COSTS_N_INSNS (5),    /* mulsi */
440   COSTS_N_INSNS (4),    /* mulsi_const */
441   COSTS_N_INSNS (3),    /* mulsi_const9 */
442   COSTS_N_INSNS (5),    /* muldi */
443   COSTS_N_INSNS (35),   /* divsi */
444   COSTS_N_INSNS (35),   /* divdi */
445   COSTS_N_INSNS (11),   /* fp */
446   COSTS_N_INSNS (11),   /* dmul */
447   COSTS_N_INSNS (11),   /* sdiv */
448   COSTS_N_INSNS (11),   /* ddiv */
449   32,
450   16,                   /* l1 cache */
451   128,                  /* l2 cache */
452   1,                    /* streams */
453 };
454
455 /* Instruction costs on PPC440 processors.  */
456 static const
457 struct processor_costs ppc440_cost = {
458   COSTS_N_INSNS (3),    /* mulsi */
459   COSTS_N_INSNS (2),    /* mulsi_const */
460   COSTS_N_INSNS (2),    /* mulsi_const9 */
461   COSTS_N_INSNS (3),    /* muldi */
462   COSTS_N_INSNS (34),   /* divsi */
463   COSTS_N_INSNS (34),   /* divdi */
464   COSTS_N_INSNS (5),    /* fp */
465   COSTS_N_INSNS (5),    /* dmul */
466   COSTS_N_INSNS (19),   /* sdiv */
467   COSTS_N_INSNS (33),   /* ddiv */
468   32,
469   32,                   /* l1 cache */
470   256,                  /* l2 cache */
471   1,                    /* streams */
472 };
473
474 /* Instruction costs on PPC601 processors.  */
475 static const
476 struct processor_costs ppc601_cost = {
477   COSTS_N_INSNS (5),    /* mulsi */
478   COSTS_N_INSNS (5),    /* mulsi_const */
479   COSTS_N_INSNS (5),    /* mulsi_const9 */
480   COSTS_N_INSNS (5),    /* muldi */
481   COSTS_N_INSNS (36),   /* divsi */
482   COSTS_N_INSNS (36),   /* divdi */
483   COSTS_N_INSNS (4),    /* fp */
484   COSTS_N_INSNS (5),    /* dmul */
485   COSTS_N_INSNS (17),   /* sdiv */
486   COSTS_N_INSNS (31),   /* ddiv */
487   32,
488   32,                   /* l1 cache */
489   256,                  /* l2 cache */
490   1,                    /* streams */
491 };
492
493 /* Instruction costs on PPC603 processors.  */
494 static const
495 struct processor_costs ppc603_cost = {
496   COSTS_N_INSNS (5),    /* mulsi */
497   COSTS_N_INSNS (3),    /* mulsi_const */
498   COSTS_N_INSNS (2),    /* mulsi_const9 */
499   COSTS_N_INSNS (5),    /* muldi */
500   COSTS_N_INSNS (37),   /* divsi */
501   COSTS_N_INSNS (37),   /* divdi */
502   COSTS_N_INSNS (3),    /* fp */
503   COSTS_N_INSNS (4),    /* dmul */
504   COSTS_N_INSNS (18),   /* sdiv */
505   COSTS_N_INSNS (33),   /* ddiv */
506   32,
507   8,                    /* l1 cache */
508   64,                   /* l2 cache */
509   1,                    /* streams */
510 };
511
512 /* Instruction costs on PPC604 processors.  */
513 static const
514 struct processor_costs ppc604_cost = {
515   COSTS_N_INSNS (4),    /* mulsi */
516   COSTS_N_INSNS (4),    /* mulsi_const */
517   COSTS_N_INSNS (4),    /* mulsi_const9 */
518   COSTS_N_INSNS (4),    /* muldi */
519   COSTS_N_INSNS (20),   /* divsi */
520   COSTS_N_INSNS (20),   /* divdi */
521   COSTS_N_INSNS (3),    /* fp */
522   COSTS_N_INSNS (3),    /* dmul */
523   COSTS_N_INSNS (18),   /* sdiv */
524   COSTS_N_INSNS (32),   /* ddiv */
525   32,
526   16,                   /* l1 cache */
527   512,                  /* l2 cache */
528   1,                    /* streams */
529 };
530
531 /* Instruction costs on PPC604e processors.  */
532 static const
533 struct processor_costs ppc604e_cost = {
534   COSTS_N_INSNS (2),    /* mulsi */
535   COSTS_N_INSNS (2),    /* mulsi_const */
536   COSTS_N_INSNS (2),    /* mulsi_const9 */
537   COSTS_N_INSNS (2),    /* muldi */
538   COSTS_N_INSNS (20),   /* divsi */
539   COSTS_N_INSNS (20),   /* divdi */
540   COSTS_N_INSNS (3),    /* fp */
541   COSTS_N_INSNS (3),    /* dmul */
542   COSTS_N_INSNS (18),   /* sdiv */
543   COSTS_N_INSNS (32),   /* ddiv */
544   32,
545   32,                   /* l1 cache */
546   1024,                 /* l2 cache */
547   1,                    /* streams */
548 };
549
550 /* Instruction costs on PPC620 processors.  */
551 static const
552 struct processor_costs ppc620_cost = {
553   COSTS_N_INSNS (5),    /* mulsi */
554   COSTS_N_INSNS (4),    /* mulsi_const */
555   COSTS_N_INSNS (3),    /* mulsi_const9 */
556   COSTS_N_INSNS (7),    /* muldi */
557   COSTS_N_INSNS (21),   /* divsi */
558   COSTS_N_INSNS (37),   /* divdi */
559   COSTS_N_INSNS (3),    /* fp */
560   COSTS_N_INSNS (3),    /* dmul */
561   COSTS_N_INSNS (18),   /* sdiv */
562   COSTS_N_INSNS (32),   /* ddiv */
563   128,
564   32,                   /* l1 cache */
565   1024,                 /* l2 cache */
566   1,                    /* streams */
567 };
568
569 /* Instruction costs on PPC630 processors.  */
570 static const
571 struct processor_costs ppc630_cost = {
572   COSTS_N_INSNS (5),    /* mulsi */
573   COSTS_N_INSNS (4),    /* mulsi_const */
574   COSTS_N_INSNS (3),    /* mulsi_const9 */
575   COSTS_N_INSNS (7),    /* muldi */
576   COSTS_N_INSNS (21),   /* divsi */
577   COSTS_N_INSNS (37),   /* divdi */
578   COSTS_N_INSNS (3),    /* fp */
579   COSTS_N_INSNS (3),    /* dmul */
580   COSTS_N_INSNS (17),   /* sdiv */
581   COSTS_N_INSNS (21),   /* ddiv */
582   128,
583   64,                   /* l1 cache */
584   1024,                 /* l2 cache */
585   1,                    /* streams */
586 };
587
588 /* Instruction costs on Cell processor.  */
589 /* COSTS_N_INSNS (1) ~ one add.  */
590 static const
591 struct processor_costs ppccell_cost = {
592   COSTS_N_INSNS (9/2)+2,    /* mulsi */
593   COSTS_N_INSNS (6/2),    /* mulsi_const */
594   COSTS_N_INSNS (6/2),    /* mulsi_const9 */
595   COSTS_N_INSNS (15/2)+2,   /* muldi */
596   COSTS_N_INSNS (38/2),   /* divsi */
597   COSTS_N_INSNS (70/2),   /* divdi */
598   COSTS_N_INSNS (10/2),   /* fp */
599   COSTS_N_INSNS (10/2),   /* dmul */
600   COSTS_N_INSNS (74/2),   /* sdiv */
601   COSTS_N_INSNS (74/2),   /* ddiv */
602   128,
603   32,                   /* l1 cache */
604   512,                  /* l2 cache */
605   6,                    /* streams */
606 };
607
608 /* Instruction costs on PPC750 and PPC7400 processors.  */
609 static const
610 struct processor_costs ppc750_cost = {
611   COSTS_N_INSNS (5),    /* mulsi */
612   COSTS_N_INSNS (3),    /* mulsi_const */
613   COSTS_N_INSNS (2),    /* mulsi_const9 */
614   COSTS_N_INSNS (5),    /* muldi */
615   COSTS_N_INSNS (17),   /* divsi */
616   COSTS_N_INSNS (17),   /* divdi */
617   COSTS_N_INSNS (3),    /* fp */
618   COSTS_N_INSNS (3),    /* dmul */
619   COSTS_N_INSNS (17),   /* sdiv */
620   COSTS_N_INSNS (31),   /* ddiv */
621   32,
622   32,                   /* l1 cache */
623   512,                  /* l2 cache */
624   1,                    /* streams */
625 };
626
627 /* Instruction costs on PPC7450 processors.  */
628 static const
629 struct processor_costs ppc7450_cost = {
630   COSTS_N_INSNS (4),    /* mulsi */
631   COSTS_N_INSNS (3),    /* mulsi_const */
632   COSTS_N_INSNS (3),    /* mulsi_const9 */
633   COSTS_N_INSNS (4),    /* muldi */
634   COSTS_N_INSNS (23),   /* divsi */
635   COSTS_N_INSNS (23),   /* divdi */
636   COSTS_N_INSNS (5),    /* fp */
637   COSTS_N_INSNS (5),    /* dmul */
638   COSTS_N_INSNS (21),   /* sdiv */
639   COSTS_N_INSNS (35),   /* ddiv */
640   32,
641   32,                   /* l1 cache */
642   1024,                 /* l2 cache */
643   1,                    /* streams */
644 };
645
646 /* Instruction costs on PPC8540 processors.  */
647 static const
648 struct processor_costs ppc8540_cost = {
649   COSTS_N_INSNS (4),    /* mulsi */
650   COSTS_N_INSNS (4),    /* mulsi_const */
651   COSTS_N_INSNS (4),    /* mulsi_const9 */
652   COSTS_N_INSNS (4),    /* muldi */
653   COSTS_N_INSNS (19),   /* divsi */
654   COSTS_N_INSNS (19),   /* divdi */
655   COSTS_N_INSNS (4),    /* fp */
656   COSTS_N_INSNS (4),    /* dmul */
657   COSTS_N_INSNS (29),   /* sdiv */
658   COSTS_N_INSNS (29),   /* ddiv */
659   32,
660   32,                   /* l1 cache */
661   256,                  /* l2 cache */
662   1,                    /* prefetch streams /*/
663 };
664
665 /* Instruction costs on POWER4 and POWER5 processors.  */
666 static const
667 struct processor_costs power4_cost = {
668   COSTS_N_INSNS (3),    /* mulsi */
669   COSTS_N_INSNS (2),    /* mulsi_const */
670   COSTS_N_INSNS (2),    /* mulsi_const9 */
671   COSTS_N_INSNS (4),    /* muldi */
672   COSTS_N_INSNS (18),   /* divsi */
673   COSTS_N_INSNS (34),   /* divdi */
674   COSTS_N_INSNS (3),    /* fp */
675   COSTS_N_INSNS (3),    /* dmul */
676   COSTS_N_INSNS (17),   /* sdiv */
677   COSTS_N_INSNS (17),   /* ddiv */
678   128,
679   32,                   /* l1 cache */
680   1024,                 /* l2 cache */
681   8,                    /* prefetch streams /*/
682 };
683
684 /* Instruction costs on POWER6 processors.  */
685 static const
686 struct processor_costs power6_cost = {
687   COSTS_N_INSNS (8),    /* mulsi */
688   COSTS_N_INSNS (8),    /* mulsi_const */
689   COSTS_N_INSNS (8),    /* mulsi_const9 */
690   COSTS_N_INSNS (8),    /* muldi */
691   COSTS_N_INSNS (22),   /* divsi */
692   COSTS_N_INSNS (28),   /* divdi */
693   COSTS_N_INSNS (3),    /* fp */
694   COSTS_N_INSNS (3),    /* dmul */
695   COSTS_N_INSNS (13),   /* sdiv */
696   COSTS_N_INSNS (16),   /* ddiv */
697   128,
698   64,                   /* l1 cache */
699   2048,                 /* l2 cache */
700   16,                   /* prefetch streams */
701 };
702
703 \f
704 static bool rs6000_function_ok_for_sibcall (tree, tree);
705 static const char *rs6000_invalid_within_doloop (const_rtx);
706 static rtx rs6000_generate_compare (enum rtx_code);
707 static void rs6000_emit_stack_tie (void);
708 static void rs6000_frame_related (rtx, rtx, HOST_WIDE_INT, rtx, rtx);
709 static rtx spe_synthesize_frame_save (rtx);
710 static bool spe_func_has_64bit_regs_p (void);
711 static void emit_frame_save (rtx, rtx, enum machine_mode, unsigned int,
712                              int, HOST_WIDE_INT);
713 static rtx gen_frame_mem_offset (enum machine_mode, rtx, int);
714 static void rs6000_emit_allocate_stack (HOST_WIDE_INT, int);
715 static unsigned rs6000_hash_constant (rtx);
716 static unsigned toc_hash_function (const void *);
717 static int toc_hash_eq (const void *, const void *);
718 static int constant_pool_expr_1 (rtx, int *, int *);
719 static bool constant_pool_expr_p (rtx);
720 static bool legitimate_small_data_p (enum machine_mode, rtx);
721 static bool legitimate_lo_sum_address_p (enum machine_mode, rtx, int);
722 static struct machine_function * rs6000_init_machine_status (void);
723 static bool rs6000_assemble_integer (rtx, unsigned int, int);
724 static bool no_global_regs_above (int);
725 #ifdef HAVE_GAS_HIDDEN
726 static void rs6000_assemble_visibility (tree, int);
727 #endif
728 static int rs6000_ra_ever_killed (void);
729 static tree rs6000_handle_longcall_attribute (tree *, tree, tree, int, bool *);
730 static tree rs6000_handle_altivec_attribute (tree *, tree, tree, int, bool *);
731 static bool rs6000_ms_bitfield_layout_p (const_tree);
732 static tree rs6000_handle_struct_attribute (tree *, tree, tree, int, bool *);
733 static void rs6000_eliminate_indexed_memrefs (rtx operands[2]);
734 static const char *rs6000_mangle_type (const_tree);
735 extern const struct attribute_spec rs6000_attribute_table[];
736 static void rs6000_set_default_type_attributes (tree);
737 static bool rs6000_reg_live_or_pic_offset_p (int);
738 static void rs6000_output_function_prologue (FILE *, HOST_WIDE_INT);
739 static void rs6000_output_function_epilogue (FILE *, HOST_WIDE_INT);
740 static void rs6000_output_mi_thunk (FILE *, tree, HOST_WIDE_INT, HOST_WIDE_INT,
741                                     tree);
742 static rtx rs6000_emit_set_long_const (rtx, HOST_WIDE_INT, HOST_WIDE_INT);
743 static bool rs6000_return_in_memory (const_tree, const_tree);
744 static void rs6000_file_start (void);
745 #if TARGET_ELF
746 static int rs6000_elf_reloc_rw_mask (void);
747 static void rs6000_elf_asm_out_constructor (rtx, int);
748 static void rs6000_elf_asm_out_destructor (rtx, int);
749 static void rs6000_elf_end_indicate_exec_stack (void) ATTRIBUTE_UNUSED;
750 static void rs6000_elf_asm_init_sections (void);
751 static section *rs6000_elf_select_rtx_section (enum machine_mode, rtx,
752                                                unsigned HOST_WIDE_INT);
753 static void rs6000_elf_encode_section_info (tree, rtx, int)
754      ATTRIBUTE_UNUSED;
755 #endif
756 static bool rs6000_use_blocks_for_constant_p (enum machine_mode, const_rtx);
757 #if TARGET_XCOFF
758 static void rs6000_xcoff_asm_output_anchor (rtx);
759 static void rs6000_xcoff_asm_globalize_label (FILE *, const char *);
760 static void rs6000_xcoff_asm_init_sections (void);
761 static int rs6000_xcoff_reloc_rw_mask (void);
762 static void rs6000_xcoff_asm_named_section (const char *, unsigned int, tree);
763 static section *rs6000_xcoff_select_section (tree, int,
764                                              unsigned HOST_WIDE_INT);
765 static void rs6000_xcoff_unique_section (tree, int);
766 static section *rs6000_xcoff_select_rtx_section
767   (enum machine_mode, rtx, unsigned HOST_WIDE_INT);
768 static const char * rs6000_xcoff_strip_name_encoding (const char *);
769 static unsigned int rs6000_xcoff_section_type_flags (tree, const char *, int);
770 static void rs6000_xcoff_file_start (void);
771 static void rs6000_xcoff_file_end (void);
772 #endif
773 static int rs6000_variable_issue (FILE *, int, rtx, int);
774 static bool rs6000_rtx_costs (rtx, int, int, int *);
775 static int rs6000_adjust_cost (rtx, rtx, rtx, int);
776 static void rs6000_sched_init (FILE *, int, int);
777 static bool is_microcoded_insn (rtx);
778 static bool is_nonpipeline_insn (rtx);
779 static bool is_cracked_insn (rtx);
780 static bool is_branch_slot_insn (rtx);
781 static bool is_load_insn (rtx);
782 static rtx get_store_dest (rtx pat);
783 static bool is_store_insn (rtx);
784 static bool set_to_load_agen (rtx,rtx);
785 static bool adjacent_mem_locations (rtx,rtx);
786 static int rs6000_adjust_priority (rtx, int);
787 static int rs6000_issue_rate (void);
788 static bool rs6000_is_costly_dependence (dep_t, int, int);
789 static rtx get_next_active_insn (rtx, rtx);
790 static bool insn_terminates_group_p (rtx , enum group_termination);
791 static bool insn_must_be_first_in_group (rtx);
792 static bool insn_must_be_last_in_group (rtx);
793 static bool is_costly_group (rtx *, rtx);
794 static int force_new_group (int, FILE *, rtx *, rtx, bool *, int, int *);
795 static int redefine_groups (FILE *, int, rtx, rtx);
796 static int pad_groups (FILE *, int, rtx, rtx);
797 static void rs6000_sched_finish (FILE *, int);
798 static int rs6000_sched_reorder (FILE *, int, rtx *, int *, int);
799 static int rs6000_sched_reorder2 (FILE *, int, rtx *, int *, int);
800 static int rs6000_use_sched_lookahead (void);
801 static int rs6000_use_sched_lookahead_guard (rtx);
802 static tree rs6000_builtin_reciprocal (unsigned int, bool, bool);
803 static tree rs6000_builtin_mask_for_load (void);
804 static tree rs6000_builtin_mul_widen_even (tree);
805 static tree rs6000_builtin_mul_widen_odd (tree);
806 static tree rs6000_builtin_conversion (enum tree_code, tree);
807
808 static void def_builtin (int, const char *, tree, int);
809 static bool rs6000_vector_alignment_reachable (const_tree, bool);
810 static void rs6000_init_builtins (void);
811 static rtx rs6000_expand_unop_builtin (enum insn_code, tree, rtx);
812 static rtx rs6000_expand_binop_builtin (enum insn_code, tree, rtx);
813 static rtx rs6000_expand_ternop_builtin (enum insn_code, tree, rtx);
814 static rtx rs6000_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
815 static void altivec_init_builtins (void);
816 static void rs6000_common_init_builtins (void);
817 static void rs6000_init_libfuncs (void);
818
819 static void paired_init_builtins (void);
820 static rtx paired_expand_builtin (tree, rtx, bool *);
821 static rtx paired_expand_lv_builtin (enum insn_code, tree, rtx);
822 static rtx paired_expand_stv_builtin (enum insn_code, tree);
823 static rtx paired_expand_predicate_builtin (enum insn_code, tree, rtx);
824
825 static void enable_mask_for_builtins (struct builtin_description *, int,
826                                       enum rs6000_builtins,
827                                       enum rs6000_builtins);
828 static tree build_opaque_vector_type (tree, int);
829 static void spe_init_builtins (void);
830 static rtx spe_expand_builtin (tree, rtx, bool *);
831 static rtx spe_expand_stv_builtin (enum insn_code, tree);
832 static rtx spe_expand_predicate_builtin (enum insn_code, tree, rtx);
833 static rtx spe_expand_evsel_builtin (enum insn_code, tree, rtx);
834 static int rs6000_emit_int_cmove (rtx, rtx, rtx, rtx);
835 static rs6000_stack_t *rs6000_stack_info (void);
836 static void debug_stack_info (rs6000_stack_t *);
837
838 static rtx altivec_expand_builtin (tree, rtx, bool *);
839 static rtx altivec_expand_ld_builtin (tree, rtx, bool *);
840 static rtx altivec_expand_st_builtin (tree, rtx, bool *);
841 static rtx altivec_expand_dst_builtin (tree, rtx, bool *);
842 static rtx altivec_expand_abs_builtin (enum insn_code, tree, rtx);
843 static rtx altivec_expand_predicate_builtin (enum insn_code,
844                                              const char *, tree, rtx);
845 static rtx altivec_expand_lv_builtin (enum insn_code, tree, rtx);
846 static rtx altivec_expand_stv_builtin (enum insn_code, tree);
847 static rtx altivec_expand_vec_init_builtin (tree, tree, rtx);
848 static rtx altivec_expand_vec_set_builtin (tree);
849 static rtx altivec_expand_vec_ext_builtin (tree, rtx);
850 static int get_element_number (tree, tree);
851 static bool rs6000_handle_option (size_t, const char *, int);
852 static void rs6000_parse_tls_size_option (void);
853 static void rs6000_parse_yes_no_option (const char *, const char *, int *);
854 static int first_altivec_reg_to_save (void);
855 static unsigned int compute_vrsave_mask (void);
856 static void compute_save_world_info (rs6000_stack_t *info_ptr);
857 static void is_altivec_return_reg (rtx, void *);
858 static rtx generate_set_vrsave (rtx, rs6000_stack_t *, int);
859 int easy_vector_constant (rtx, enum machine_mode);
860 static bool rs6000_is_opaque_type (const_tree);
861 static rtx rs6000_dwarf_register_span (rtx);
862 static void rs6000_init_dwarf_reg_sizes_extra (tree);
863 static rtx rs6000_legitimize_tls_address (rtx, enum tls_model);
864 static void rs6000_output_dwarf_dtprel (FILE *, int, rtx) ATTRIBUTE_UNUSED;
865 static rtx rs6000_tls_get_addr (void);
866 static rtx rs6000_got_sym (void);
867 static int rs6000_tls_symbol_ref_1 (rtx *, void *);
868 static const char *rs6000_get_some_local_dynamic_name (void);
869 static int rs6000_get_some_local_dynamic_name_1 (rtx *, void *);
870 static rtx rs6000_complex_function_value (enum machine_mode);
871 static rtx rs6000_spe_function_arg (CUMULATIVE_ARGS *,
872                                     enum machine_mode, tree);
873 static void rs6000_darwin64_record_arg_advance_flush (CUMULATIVE_ARGS *,
874                                                       HOST_WIDE_INT);
875 static void rs6000_darwin64_record_arg_advance_recurse (CUMULATIVE_ARGS *,
876                                                         tree, HOST_WIDE_INT);
877 static void rs6000_darwin64_record_arg_flush (CUMULATIVE_ARGS *,
878                                               HOST_WIDE_INT,
879                                               rtx[], int *);
880 static void rs6000_darwin64_record_arg_recurse (CUMULATIVE_ARGS *,
881                                                 const_tree, HOST_WIDE_INT,
882                                                 rtx[], int *);
883 static rtx rs6000_darwin64_record_arg (CUMULATIVE_ARGS *, const_tree, int, bool);
884 static rtx rs6000_mixed_function_arg (enum machine_mode, tree, int);
885 static void rs6000_move_block_from_reg (int regno, rtx x, int nregs);
886 static void setup_incoming_varargs (CUMULATIVE_ARGS *,
887                                     enum machine_mode, tree,
888                                     int *, int);
889 static bool rs6000_pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode,
890                                       const_tree, bool);
891 static int rs6000_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode,
892                                      tree, bool);
893 static const char *invalid_arg_for_unprototyped_fn (const_tree, const_tree, const_tree);
894 #if TARGET_MACHO
895 static void macho_branch_islands (void);
896 static int no_previous_def (tree function_name);
897 static tree get_prev_label (tree function_name);
898 static void rs6000_darwin_file_start (void);
899 #endif
900
901 static tree rs6000_build_builtin_va_list (void);
902 static tree rs6000_gimplify_va_arg (tree, tree, tree *, tree *);
903 static bool rs6000_must_pass_in_stack (enum machine_mode, const_tree);
904 static bool rs6000_scalar_mode_supported_p (enum machine_mode);
905 static bool rs6000_vector_mode_supported_p (enum machine_mode);
906 static int get_vec_cmp_insn (enum rtx_code, enum machine_mode,
907                              enum machine_mode);
908 static rtx rs6000_emit_vector_compare (enum rtx_code, rtx, rtx,
909                                        enum machine_mode);
910 static int get_vsel_insn (enum machine_mode);
911 static void rs6000_emit_vector_select (rtx, rtx, rtx, rtx);
912 static tree rs6000_stack_protect_fail (void);
913
914 const int INSN_NOT_AVAILABLE = -1;
915 static enum machine_mode rs6000_eh_return_filter_mode (void);
916
917 /* Hash table stuff for keeping track of TOC entries.  */
918
919 struct toc_hash_struct GTY(())
920 {
921   /* `key' will satisfy CONSTANT_P; in fact, it will satisfy
922      ASM_OUTPUT_SPECIAL_POOL_ENTRY_P.  */
923   rtx key;
924   enum machine_mode key_mode;
925   int labelno;
926 };
927
928 static GTY ((param_is (struct toc_hash_struct))) htab_t toc_hash_table;
929 \f
930 /* Default register names.  */
931 char rs6000_reg_names[][8] =
932 {
933       "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",
934       "8",  "9", "10", "11", "12", "13", "14", "15",
935      "16", "17", "18", "19", "20", "21", "22", "23",
936      "24", "25", "26", "27", "28", "29", "30", "31",
937       "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",
938       "8",  "9", "10", "11", "12", "13", "14", "15",
939      "16", "17", "18", "19", "20", "21", "22", "23",
940      "24", "25", "26", "27", "28", "29", "30", "31",
941      "mq", "lr", "ctr","ap",
942       "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",
943       "xer",
944       /* AltiVec registers.  */
945       "0",  "1",  "2",  "3",  "4",  "5",  "6", "7",
946       "8",  "9",  "10", "11", "12", "13", "14", "15",
947       "16", "17", "18", "19", "20", "21", "22", "23",
948       "24", "25", "26", "27", "28", "29", "30", "31",
949       "vrsave", "vscr",
950       /* SPE registers.  */
951       "spe_acc", "spefscr",
952       /* Soft frame pointer.  */
953       "sfp"
954 };
955
956 #ifdef TARGET_REGNAMES
957 static const char alt_reg_names[][8] =
958 {
959    "%r0",   "%r1",  "%r2",  "%r3",  "%r4",  "%r5",  "%r6",  "%r7",
960    "%r8",   "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15",
961   "%r16",  "%r17", "%r18", "%r19", "%r20", "%r21", "%r22", "%r23",
962   "%r24",  "%r25", "%r26", "%r27", "%r28", "%r29", "%r30", "%r31",
963    "%f0",   "%f1",  "%f2",  "%f3",  "%f4",  "%f5",  "%f6",  "%f7",
964    "%f8",   "%f9", "%f10", "%f11", "%f12", "%f13", "%f14", "%f15",
965   "%f16",  "%f17", "%f18", "%f19", "%f20", "%f21", "%f22", "%f23",
966   "%f24",  "%f25", "%f26", "%f27", "%f28", "%f29", "%f30", "%f31",
967     "mq",    "lr",  "ctr",   "ap",
968   "%cr0",  "%cr1", "%cr2", "%cr3", "%cr4", "%cr5", "%cr6", "%cr7",
969    "xer",
970   /* AltiVec registers.  */
971    "%v0",  "%v1",  "%v2",  "%v3",  "%v4",  "%v5",  "%v6", "%v7",
972    "%v8",  "%v9", "%v10", "%v11", "%v12", "%v13", "%v14", "%v15",
973   "%v16", "%v17", "%v18", "%v19", "%v20", "%v21", "%v22", "%v23",
974   "%v24", "%v25", "%v26", "%v27", "%v28", "%v29", "%v30", "%v31",
975   "vrsave", "vscr",
976   /* SPE registers.  */
977   "spe_acc", "spefscr",
978   /* Soft frame pointer.  */
979   "sfp"
980 };
981 #endif
982 \f
983 #ifndef MASK_STRICT_ALIGN
984 #define MASK_STRICT_ALIGN 0
985 #endif
986 #ifndef TARGET_PROFILE_KERNEL
987 #define TARGET_PROFILE_KERNEL 0
988 #endif
989
990 /* The VRSAVE bitmask puts bit %v0 as the most significant bit.  */
991 #define ALTIVEC_REG_BIT(REGNO) (0x80000000 >> ((REGNO) - FIRST_ALTIVEC_REGNO))
992 \f
993 /* Initialize the GCC target structure.  */
994 #undef TARGET_ATTRIBUTE_TABLE
995 #define TARGET_ATTRIBUTE_TABLE rs6000_attribute_table
996 #undef TARGET_SET_DEFAULT_TYPE_ATTRIBUTES
997 #define TARGET_SET_DEFAULT_TYPE_ATTRIBUTES rs6000_set_default_type_attributes
998
999 #undef TARGET_ASM_ALIGNED_DI_OP
1000 #define TARGET_ASM_ALIGNED_DI_OP DOUBLE_INT_ASM_OP
1001
1002 /* Default unaligned ops are only provided for ELF.  Find the ops needed
1003    for non-ELF systems.  */
1004 #ifndef OBJECT_FORMAT_ELF
1005 #if TARGET_XCOFF
1006 /* For XCOFF.  rs6000_assemble_integer will handle unaligned DIs on
1007    64-bit targets.  */
1008 #undef TARGET_ASM_UNALIGNED_HI_OP
1009 #define TARGET_ASM_UNALIGNED_HI_OP "\t.vbyte\t2,"
1010 #undef TARGET_ASM_UNALIGNED_SI_OP
1011 #define TARGET_ASM_UNALIGNED_SI_OP "\t.vbyte\t4,"
1012 #undef TARGET_ASM_UNALIGNED_DI_OP
1013 #define TARGET_ASM_UNALIGNED_DI_OP "\t.vbyte\t8,"
1014 #else
1015 /* For Darwin.  */
1016 #undef TARGET_ASM_UNALIGNED_HI_OP
1017 #define TARGET_ASM_UNALIGNED_HI_OP "\t.short\t"
1018 #undef TARGET_ASM_UNALIGNED_SI_OP
1019 #define TARGET_ASM_UNALIGNED_SI_OP "\t.long\t"
1020 #undef TARGET_ASM_UNALIGNED_DI_OP
1021 #define TARGET_ASM_UNALIGNED_DI_OP "\t.quad\t"
1022 #undef TARGET_ASM_ALIGNED_DI_OP
1023 #define TARGET_ASM_ALIGNED_DI_OP "\t.quad\t"
1024 #endif
1025 #endif
1026
1027 /* This hook deals with fixups for relocatable code and DI-mode objects
1028    in 64-bit code.  */
1029 #undef TARGET_ASM_INTEGER
1030 #define TARGET_ASM_INTEGER rs6000_assemble_integer
1031
1032 #ifdef HAVE_GAS_HIDDEN
1033 #undef TARGET_ASM_ASSEMBLE_VISIBILITY
1034 #define TARGET_ASM_ASSEMBLE_VISIBILITY rs6000_assemble_visibility
1035 #endif
1036
1037 #undef TARGET_HAVE_TLS
1038 #define TARGET_HAVE_TLS HAVE_AS_TLS
1039
1040 #undef TARGET_CANNOT_FORCE_CONST_MEM
1041 #define TARGET_CANNOT_FORCE_CONST_MEM rs6000_tls_referenced_p
1042
1043 #undef TARGET_ASM_FUNCTION_PROLOGUE
1044 #define TARGET_ASM_FUNCTION_PROLOGUE rs6000_output_function_prologue
1045 #undef TARGET_ASM_FUNCTION_EPILOGUE
1046 #define TARGET_ASM_FUNCTION_EPILOGUE rs6000_output_function_epilogue
1047
1048 #undef  TARGET_SCHED_VARIABLE_ISSUE
1049 #define TARGET_SCHED_VARIABLE_ISSUE rs6000_variable_issue
1050
1051 #undef TARGET_SCHED_ISSUE_RATE
1052 #define TARGET_SCHED_ISSUE_RATE rs6000_issue_rate
1053 #undef TARGET_SCHED_ADJUST_COST
1054 #define TARGET_SCHED_ADJUST_COST rs6000_adjust_cost
1055 #undef TARGET_SCHED_ADJUST_PRIORITY
1056 #define TARGET_SCHED_ADJUST_PRIORITY rs6000_adjust_priority
1057 #undef TARGET_SCHED_IS_COSTLY_DEPENDENCE
1058 #define TARGET_SCHED_IS_COSTLY_DEPENDENCE rs6000_is_costly_dependence
1059 #undef TARGET_SCHED_INIT
1060 #define TARGET_SCHED_INIT rs6000_sched_init
1061 #undef TARGET_SCHED_FINISH
1062 #define TARGET_SCHED_FINISH rs6000_sched_finish
1063 #undef TARGET_SCHED_REORDER
1064 #define TARGET_SCHED_REORDER rs6000_sched_reorder
1065 #undef TARGET_SCHED_REORDER2
1066 #define TARGET_SCHED_REORDER2 rs6000_sched_reorder2
1067
1068 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
1069 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD rs6000_use_sched_lookahead
1070
1071 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD
1072 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD rs6000_use_sched_lookahead_guard
1073
1074 #undef TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD
1075 #define TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD rs6000_builtin_mask_for_load
1076 #undef TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_EVEN
1077 #define TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_EVEN rs6000_builtin_mul_widen_even
1078 #undef TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_ODD
1079 #define TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_ODD rs6000_builtin_mul_widen_odd
1080 #undef TARGET_VECTORIZE_BUILTIN_CONVERSION
1081 #define TARGET_VECTORIZE_BUILTIN_CONVERSION rs6000_builtin_conversion
1082
1083 #undef TARGET_VECTOR_ALIGNMENT_REACHABLE
1084 #define TARGET_VECTOR_ALIGNMENT_REACHABLE rs6000_vector_alignment_reachable
1085
1086 #undef TARGET_INIT_BUILTINS
1087 #define TARGET_INIT_BUILTINS rs6000_init_builtins
1088
1089 #undef TARGET_EXPAND_BUILTIN
1090 #define TARGET_EXPAND_BUILTIN rs6000_expand_builtin
1091
1092 #undef TARGET_MANGLE_TYPE
1093 #define TARGET_MANGLE_TYPE rs6000_mangle_type
1094
1095 #undef TARGET_INIT_LIBFUNCS
1096 #define TARGET_INIT_LIBFUNCS rs6000_init_libfuncs
1097
1098 #if TARGET_MACHO
1099 #undef TARGET_BINDS_LOCAL_P
1100 #define TARGET_BINDS_LOCAL_P darwin_binds_local_p
1101 #endif
1102
1103 #undef TARGET_MS_BITFIELD_LAYOUT_P
1104 #define TARGET_MS_BITFIELD_LAYOUT_P rs6000_ms_bitfield_layout_p
1105
1106 #undef TARGET_ASM_OUTPUT_MI_THUNK
1107 #define TARGET_ASM_OUTPUT_MI_THUNK rs6000_output_mi_thunk
1108
1109 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
1110 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK hook_bool_const_tree_hwi_hwi_const_tree_true
1111
1112 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
1113 #define TARGET_FUNCTION_OK_FOR_SIBCALL rs6000_function_ok_for_sibcall
1114
1115 #undef TARGET_INVALID_WITHIN_DOLOOP
1116 #define TARGET_INVALID_WITHIN_DOLOOP rs6000_invalid_within_doloop
1117
1118 #undef TARGET_RTX_COSTS
1119 #define TARGET_RTX_COSTS rs6000_rtx_costs
1120 #undef TARGET_ADDRESS_COST
1121 #define TARGET_ADDRESS_COST hook_int_rtx_0
1122
1123 #undef TARGET_VECTOR_OPAQUE_P
1124 #define TARGET_VECTOR_OPAQUE_P rs6000_is_opaque_type
1125
1126 #undef TARGET_DWARF_REGISTER_SPAN
1127 #define TARGET_DWARF_REGISTER_SPAN rs6000_dwarf_register_span
1128
1129 #undef TARGET_INIT_DWARF_REG_SIZES_EXTRA
1130 #define TARGET_INIT_DWARF_REG_SIZES_EXTRA rs6000_init_dwarf_reg_sizes_extra
1131
1132 /* On rs6000, function arguments are promoted, as are function return
1133    values.  */
1134 #undef TARGET_PROMOTE_FUNCTION_ARGS
1135 #define TARGET_PROMOTE_FUNCTION_ARGS hook_bool_const_tree_true
1136 #undef TARGET_PROMOTE_FUNCTION_RETURN
1137 #define TARGET_PROMOTE_FUNCTION_RETURN hook_bool_const_tree_true
1138
1139 #undef TARGET_RETURN_IN_MEMORY
1140 #define TARGET_RETURN_IN_MEMORY rs6000_return_in_memory
1141
1142 #undef TARGET_SETUP_INCOMING_VARARGS
1143 #define TARGET_SETUP_INCOMING_VARARGS setup_incoming_varargs
1144
1145 /* Always strict argument naming on rs6000.  */
1146 #undef TARGET_STRICT_ARGUMENT_NAMING
1147 #define TARGET_STRICT_ARGUMENT_NAMING hook_bool_CUMULATIVE_ARGS_true
1148 #undef TARGET_PRETEND_OUTGOING_VARARGS_NAMED
1149 #define TARGET_PRETEND_OUTGOING_VARARGS_NAMED hook_bool_CUMULATIVE_ARGS_true
1150 #undef TARGET_SPLIT_COMPLEX_ARG
1151 #define TARGET_SPLIT_COMPLEX_ARG hook_bool_const_tree_true
1152 #undef TARGET_MUST_PASS_IN_STACK
1153 #define TARGET_MUST_PASS_IN_STACK rs6000_must_pass_in_stack
1154 #undef TARGET_PASS_BY_REFERENCE
1155 #define TARGET_PASS_BY_REFERENCE rs6000_pass_by_reference
1156 #undef TARGET_ARG_PARTIAL_BYTES
1157 #define TARGET_ARG_PARTIAL_BYTES rs6000_arg_partial_bytes
1158
1159 #undef TARGET_BUILD_BUILTIN_VA_LIST
1160 #define TARGET_BUILD_BUILTIN_VA_LIST rs6000_build_builtin_va_list
1161
1162 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
1163 #define TARGET_GIMPLIFY_VA_ARG_EXPR rs6000_gimplify_va_arg
1164
1165 #undef TARGET_EH_RETURN_FILTER_MODE
1166 #define TARGET_EH_RETURN_FILTER_MODE rs6000_eh_return_filter_mode
1167
1168 #undef TARGET_SCALAR_MODE_SUPPORTED_P
1169 #define TARGET_SCALAR_MODE_SUPPORTED_P rs6000_scalar_mode_supported_p
1170
1171 #undef TARGET_VECTOR_MODE_SUPPORTED_P
1172 #define TARGET_VECTOR_MODE_SUPPORTED_P rs6000_vector_mode_supported_p
1173
1174 #undef TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN
1175 #define TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN invalid_arg_for_unprototyped_fn
1176
1177 #undef TARGET_HANDLE_OPTION
1178 #define TARGET_HANDLE_OPTION rs6000_handle_option
1179
1180 #undef TARGET_DEFAULT_TARGET_FLAGS
1181 #define TARGET_DEFAULT_TARGET_FLAGS \
1182   (TARGET_DEFAULT)
1183
1184 #undef TARGET_STACK_PROTECT_FAIL
1185 #define TARGET_STACK_PROTECT_FAIL rs6000_stack_protect_fail
1186
1187 /* MPC604EUM 3.5.2 Weak Consistency between Multiple Processors
1188    The PowerPC architecture requires only weak consistency among
1189    processors--that is, memory accesses between processors need not be
1190    sequentially consistent and memory accesses among processors can occur
1191    in any order. The ability to order memory accesses weakly provides
1192    opportunities for more efficient use of the system bus. Unless a
1193    dependency exists, the 604e allows read operations to precede store
1194    operations.  */
1195 #undef TARGET_RELAXED_ORDERING
1196 #define TARGET_RELAXED_ORDERING true
1197
1198 #ifdef HAVE_AS_TLS
1199 #undef TARGET_ASM_OUTPUT_DWARF_DTPREL
1200 #define TARGET_ASM_OUTPUT_DWARF_DTPREL rs6000_output_dwarf_dtprel
1201 #endif
1202
1203 /* Use a 32-bit anchor range.  This leads to sequences like:
1204
1205         addis   tmp,anchor,high
1206         add     dest,tmp,low
1207
1208    where tmp itself acts as an anchor, and can be shared between
1209    accesses to the same 64k page.  */
1210 #undef TARGET_MIN_ANCHOR_OFFSET
1211 #define TARGET_MIN_ANCHOR_OFFSET -0x7fffffff - 1
1212 #undef TARGET_MAX_ANCHOR_OFFSET
1213 #define TARGET_MAX_ANCHOR_OFFSET 0x7fffffff
1214 #undef TARGET_USE_BLOCKS_FOR_CONSTANT_P
1215 #define TARGET_USE_BLOCKS_FOR_CONSTANT_P rs6000_use_blocks_for_constant_p
1216
1217 #undef TARGET_BUILTIN_RECIPROCAL
1218 #define TARGET_BUILTIN_RECIPROCAL rs6000_builtin_reciprocal
1219
1220 struct gcc_target targetm = TARGET_INITIALIZER;
1221 \f
1222
1223 /* Value is 1 if hard register REGNO can hold a value of machine-mode
1224    MODE.  */
1225 static int
1226 rs6000_hard_regno_mode_ok (int regno, enum machine_mode mode)
1227 {
1228   /* The GPRs can hold any mode, but values bigger than one register
1229      cannot go past R31.  */
1230   if (INT_REGNO_P (regno))
1231     return INT_REGNO_P (regno + HARD_REGNO_NREGS (regno, mode) - 1);
1232
1233   /* The float registers can only hold floating modes and DImode.
1234      This excludes the 32-bit decimal float mode for now.  */
1235   if (FP_REGNO_P (regno))
1236     return
1237       ((SCALAR_FLOAT_MODE_P (mode)
1238        && (mode != TDmode || (regno % 2) == 0)
1239        && mode != SDmode
1240        && FP_REGNO_P (regno + HARD_REGNO_NREGS (regno, mode) - 1))
1241       || (GET_MODE_CLASS (mode) == MODE_INT
1242           && GET_MODE_SIZE (mode) == UNITS_PER_FP_WORD)
1243       || (PAIRED_SIMD_REGNO_P (regno) && TARGET_PAIRED_FLOAT
1244            && PAIRED_VECTOR_MODE (mode)));
1245
1246   /* The CR register can only hold CC modes.  */
1247   if (CR_REGNO_P (regno))
1248     return GET_MODE_CLASS (mode) == MODE_CC;
1249
1250   if (XER_REGNO_P (regno))
1251     return mode == PSImode;
1252
1253   /* AltiVec only in AldyVec registers.  */
1254   if (ALTIVEC_REGNO_P (regno))
1255     return ALTIVEC_VECTOR_MODE (mode);
1256
1257   /* ...but GPRs can hold SIMD data on the SPE in one register.  */
1258   if (SPE_SIMD_REGNO_P (regno) && TARGET_SPE && SPE_VECTOR_MODE (mode))
1259     return 1;
1260
1261   /* We cannot put TImode anywhere except general register and it must be
1262      able to fit within the register set.  */
1263
1264   return GET_MODE_SIZE (mode) <= UNITS_PER_WORD;
1265 }
1266
1267 /* Initialize rs6000_hard_regno_mode_ok_p table.  */
1268 static void
1269 rs6000_init_hard_regno_mode_ok (void)
1270 {
1271   int r, m;
1272
1273   for (r = 0; r < FIRST_PSEUDO_REGISTER; ++r)
1274     for (m = 0; m < NUM_MACHINE_MODES; ++m)
1275       if (rs6000_hard_regno_mode_ok (r, m))
1276         rs6000_hard_regno_mode_ok_p[m][r] = true;
1277 }
1278
1279 #if TARGET_MACHO
1280 /* The Darwin version of SUBTARGET_OVERRIDE_OPTIONS.  */
1281
1282 static void
1283 darwin_rs6000_override_options (void)
1284 {
1285   /* The Darwin ABI always includes AltiVec, can't be (validly) turned
1286      off.  */
1287   rs6000_altivec_abi = 1;
1288   TARGET_ALTIVEC_VRSAVE = 1;
1289   if (DEFAULT_ABI == ABI_DARWIN)
1290   {
1291     if (MACHO_DYNAMIC_NO_PIC_P)
1292       {
1293         if (flag_pic)
1294             warning (0, "-mdynamic-no-pic overrides -fpic or -fPIC");
1295         flag_pic = 0;
1296       }
1297     else if (flag_pic == 1)
1298       {
1299         flag_pic = 2;
1300       }
1301   }
1302   if (TARGET_64BIT && ! TARGET_POWERPC64)
1303     {
1304       target_flags |= MASK_POWERPC64;
1305       warning (0, "-m64 requires PowerPC64 architecture, enabling");
1306     }
1307   if (flag_mkernel)
1308     {
1309       rs6000_default_long_calls = 1;
1310       target_flags |= MASK_SOFT_FLOAT;
1311     }
1312
1313   /* Make -m64 imply -maltivec.  Darwin's 64-bit ABI includes
1314      Altivec.  */
1315   if (!flag_mkernel && !flag_apple_kext
1316       && TARGET_64BIT
1317       && ! (target_flags_explicit & MASK_ALTIVEC))
1318     target_flags |= MASK_ALTIVEC;
1319
1320   /* Unless the user (not the configurer) has explicitly overridden
1321      it with -mcpu=G3 or -mno-altivec, then 10.5+ targets default to
1322      G4 unless targetting the kernel.  */
1323   if (!flag_mkernel
1324       && !flag_apple_kext
1325       && strverscmp (darwin_macosx_version_min, "10.5") >= 0
1326       && ! (target_flags_explicit & MASK_ALTIVEC)
1327       && ! rs6000_select[1].string)
1328     {
1329       target_flags |= MASK_ALTIVEC;
1330     }
1331 }
1332 #endif
1333
1334 /* If not otherwise specified by a target, make 'long double' equivalent to
1335    'double'.  */
1336
1337 #ifndef RS6000_DEFAULT_LONG_DOUBLE_SIZE
1338 #define RS6000_DEFAULT_LONG_DOUBLE_SIZE 64
1339 #endif
1340
1341 /* Override command line options.  Mostly we process the processor
1342    type and sometimes adjust other TARGET_ options.  */
1343
1344 void
1345 rs6000_override_options (const char *default_cpu)
1346 {
1347   size_t i, j;
1348   struct rs6000_cpu_select *ptr;
1349   int set_masks;
1350
1351   /* Simplifications for entries below.  */
1352
1353   enum {
1354     POWERPC_BASE_MASK = MASK_POWERPC | MASK_NEW_MNEMONICS,
1355     POWERPC_7400_MASK = POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_ALTIVEC
1356   };
1357
1358   /* This table occasionally claims that a processor does not support
1359      a particular feature even though it does, but the feature is slower
1360      than the alternative.  Thus, it shouldn't be relied on as a
1361      complete description of the processor's support.
1362
1363      Please keep this list in order, and don't forget to update the
1364      documentation in invoke.texi when adding a new processor or
1365      flag.  */
1366   static struct ptt
1367     {
1368       const char *const name;           /* Canonical processor name.  */
1369       const enum processor_type processor; /* Processor type enum value.  */
1370       const int target_enable;  /* Target flags to enable.  */
1371     } const processor_target_table[]
1372       = {{"401", PROCESSOR_PPC403, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1373          {"403", PROCESSOR_PPC403,
1374           POWERPC_BASE_MASK | MASK_SOFT_FLOAT | MASK_STRICT_ALIGN},
1375          {"405", PROCESSOR_PPC405,
1376           POWERPC_BASE_MASK | MASK_SOFT_FLOAT | MASK_MULHW | MASK_DLMZB},
1377          {"405fp", PROCESSOR_PPC405,
1378           POWERPC_BASE_MASK | MASK_MULHW | MASK_DLMZB},
1379          {"440", PROCESSOR_PPC440,
1380           POWERPC_BASE_MASK | MASK_SOFT_FLOAT | MASK_MULHW | MASK_DLMZB},
1381          {"440fp", PROCESSOR_PPC440,
1382           POWERPC_BASE_MASK | MASK_MULHW | MASK_DLMZB},
1383          {"505", PROCESSOR_MPCCORE, POWERPC_BASE_MASK},
1384          {"601", PROCESSOR_PPC601,
1385           MASK_POWER | POWERPC_BASE_MASK | MASK_MULTIPLE | MASK_STRING},
1386          {"602", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1387          {"603", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1388          {"603e", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1389          {"604", PROCESSOR_PPC604, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1390          {"604e", PROCESSOR_PPC604e, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1391          {"620", PROCESSOR_PPC620,
1392           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
1393          {"630", PROCESSOR_PPC630,
1394           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
1395          {"740", PROCESSOR_PPC750, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1396          {"7400", PROCESSOR_PPC7400, POWERPC_7400_MASK},
1397          {"7450", PROCESSOR_PPC7450, POWERPC_7400_MASK},
1398          {"750", PROCESSOR_PPC750, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1399          {"801", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1400          {"821", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1401          {"823", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1402          {"8540", PROCESSOR_PPC8540, POWERPC_BASE_MASK | MASK_STRICT_ALIGN},
1403          /* 8548 has a dummy entry for now.  */
1404          {"8548", PROCESSOR_PPC8540, POWERPC_BASE_MASK | MASK_STRICT_ALIGN},
1405          {"860", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1406          {"970", PROCESSOR_POWER4,
1407           POWERPC_7400_MASK | MASK_PPC_GPOPT | MASK_MFCRF | MASK_POWERPC64},
1408          {"cell", PROCESSOR_CELL,
1409           POWERPC_7400_MASK  | MASK_PPC_GPOPT | MASK_MFCRF | MASK_POWERPC64},
1410          {"common", PROCESSOR_COMMON, MASK_NEW_MNEMONICS},
1411          {"ec603e", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1412          {"G3", PROCESSOR_PPC750, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1413          {"G4",  PROCESSOR_PPC7450, POWERPC_7400_MASK},
1414          {"G5", PROCESSOR_POWER4,
1415           POWERPC_7400_MASK | MASK_PPC_GPOPT | MASK_MFCRF | MASK_POWERPC64},
1416          {"power", PROCESSOR_POWER, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
1417          {"power2", PROCESSOR_POWER,
1418           MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING},
1419          {"power3", PROCESSOR_PPC630,
1420           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
1421          {"power4", PROCESSOR_POWER4,
1422           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_MFCRF | MASK_POWERPC64},
1423          {"power5", PROCESSOR_POWER5,
1424           POWERPC_BASE_MASK | MASK_POWERPC64 | MASK_PPC_GFXOPT
1425           | MASK_MFCRF | MASK_POPCNTB},
1426          {"power5+", PROCESSOR_POWER5,
1427           POWERPC_BASE_MASK | MASK_POWERPC64 | MASK_PPC_GFXOPT
1428           | MASK_MFCRF | MASK_POPCNTB | MASK_FPRND},
1429          {"power6", PROCESSOR_POWER6,
1430           POWERPC_7400_MASK | MASK_POWERPC64 | MASK_MFCRF | MASK_POPCNTB
1431           | MASK_FPRND | MASK_CMPB | MASK_DFP },
1432          {"power6x", PROCESSOR_POWER6,
1433           POWERPC_7400_MASK | MASK_POWERPC64 | MASK_MFCRF | MASK_POPCNTB
1434           | MASK_FPRND | MASK_CMPB | MASK_MFPGPR | MASK_DFP },
1435          {"powerpc", PROCESSOR_POWERPC, POWERPC_BASE_MASK},
1436          {"powerpc64", PROCESSOR_POWERPC64,
1437           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
1438          {"rios", PROCESSOR_RIOS1, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
1439          {"rios1", PROCESSOR_RIOS1, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
1440          {"rios2", PROCESSOR_RIOS2,
1441           MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING},
1442          {"rsc", PROCESSOR_PPC601, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
1443          {"rsc1", PROCESSOR_PPC601, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
1444          {"rs64", PROCESSOR_RS64A,
1445           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64}
1446       };
1447
1448   const size_t ptt_size = ARRAY_SIZE (processor_target_table);
1449
1450   /* Some OSs don't support saving the high part of 64-bit registers on
1451      context switch.  Other OSs don't support saving Altivec registers.
1452      On those OSs, we don't touch the MASK_POWERPC64 or MASK_ALTIVEC
1453      settings; if the user wants either, the user must explicitly specify
1454      them and we won't interfere with the user's specification.  */
1455
1456   enum {
1457     POWER_MASKS = MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING,
1458     POWERPC_MASKS = (POWERPC_BASE_MASK | MASK_PPC_GPOPT | MASK_STRICT_ALIGN
1459                      | MASK_PPC_GFXOPT | MASK_POWERPC64 | MASK_ALTIVEC
1460                      | MASK_MFCRF | MASK_POPCNTB | MASK_FPRND | MASK_MULHW
1461                      | MASK_DLMZB | MASK_CMPB | MASK_MFPGPR | MASK_DFP)
1462   };
1463
1464   rs6000_init_hard_regno_mode_ok ();
1465
1466   set_masks = POWER_MASKS | POWERPC_MASKS | MASK_SOFT_FLOAT;
1467 #ifdef OS_MISSING_POWERPC64
1468   if (OS_MISSING_POWERPC64)
1469     set_masks &= ~MASK_POWERPC64;
1470 #endif
1471 #ifdef OS_MISSING_ALTIVEC
1472   if (OS_MISSING_ALTIVEC)
1473     set_masks &= ~MASK_ALTIVEC;
1474 #endif
1475
1476   /* Don't override by the processor default if given explicitly.  */
1477   set_masks &= ~target_flags_explicit;
1478
1479   /* Identify the processor type.  */
1480   rs6000_select[0].string = default_cpu;
1481   rs6000_cpu = TARGET_POWERPC64 ? PROCESSOR_DEFAULT64 : PROCESSOR_DEFAULT;
1482
1483   for (i = 0; i < ARRAY_SIZE (rs6000_select); i++)
1484     {
1485       ptr = &rs6000_select[i];
1486       if (ptr->string != (char *)0 && ptr->string[0] != '\0')
1487         {
1488           for (j = 0; j < ptt_size; j++)
1489             if (! strcmp (ptr->string, processor_target_table[j].name))
1490               {
1491                 if (ptr->set_tune_p)
1492                   rs6000_cpu = processor_target_table[j].processor;
1493
1494                 if (ptr->set_arch_p)
1495                   {
1496                     target_flags &= ~set_masks;
1497                     target_flags |= (processor_target_table[j].target_enable
1498                                      & set_masks);
1499                   }
1500                 break;
1501               }
1502
1503           if (j == ptt_size)
1504             error ("bad value (%s) for %s switch", ptr->string, ptr->name);
1505         }
1506     }
1507
1508   if (TARGET_E500)
1509     rs6000_isel = 1;
1510
1511   /* If we are optimizing big endian systems for space, use the load/store
1512      multiple and string instructions.  */
1513   if (BYTES_BIG_ENDIAN && optimize_size)
1514     target_flags |= ~target_flags_explicit & (MASK_MULTIPLE | MASK_STRING);
1515
1516   /* Don't allow -mmultiple or -mstring on little endian systems
1517      unless the cpu is a 750, because the hardware doesn't support the
1518      instructions used in little endian mode, and causes an alignment
1519      trap.  The 750 does not cause an alignment trap (except when the
1520      target is unaligned).  */
1521
1522   if (!BYTES_BIG_ENDIAN && rs6000_cpu != PROCESSOR_PPC750)
1523     {
1524       if (TARGET_MULTIPLE)
1525         {
1526           target_flags &= ~MASK_MULTIPLE;
1527           if ((target_flags_explicit & MASK_MULTIPLE) != 0)
1528             warning (0, "-mmultiple is not supported on little endian systems");
1529         }
1530
1531       if (TARGET_STRING)
1532         {
1533           target_flags &= ~MASK_STRING;
1534           if ((target_flags_explicit & MASK_STRING) != 0)
1535             warning (0, "-mstring is not supported on little endian systems");
1536         }
1537     }
1538
1539   /* Set debug flags */
1540   if (rs6000_debug_name)
1541     {
1542       if (! strcmp (rs6000_debug_name, "all"))
1543         rs6000_debug_stack = rs6000_debug_arg = 1;
1544       else if (! strcmp (rs6000_debug_name, "stack"))
1545         rs6000_debug_stack = 1;
1546       else if (! strcmp (rs6000_debug_name, "arg"))
1547         rs6000_debug_arg = 1;
1548       else
1549         error ("unknown -mdebug-%s switch", rs6000_debug_name);
1550     }
1551
1552   if (rs6000_traceback_name)
1553     {
1554       if (! strncmp (rs6000_traceback_name, "full", 4))
1555         rs6000_traceback = traceback_full;
1556       else if (! strncmp (rs6000_traceback_name, "part", 4))
1557         rs6000_traceback = traceback_part;
1558       else if (! strncmp (rs6000_traceback_name, "no", 2))
1559         rs6000_traceback = traceback_none;
1560       else
1561         error ("unknown -mtraceback arg %qs; expecting %<full%>, %<partial%> or %<none%>",
1562                rs6000_traceback_name);
1563     }
1564
1565   if (!rs6000_explicit_options.long_double)
1566     rs6000_long_double_type_size = RS6000_DEFAULT_LONG_DOUBLE_SIZE;
1567
1568 #ifndef POWERPC_LINUX
1569   if (!rs6000_explicit_options.ieee)
1570     rs6000_ieeequad = 1;
1571 #endif
1572
1573   /* Set Altivec ABI as default for powerpc64 linux.  */
1574   if (TARGET_ELF && TARGET_64BIT)
1575     {
1576       rs6000_altivec_abi = 1;
1577       TARGET_ALTIVEC_VRSAVE = 1;
1578     }
1579
1580   /* Set the Darwin64 ABI as default for 64-bit Darwin.  */
1581   if (DEFAULT_ABI == ABI_DARWIN && TARGET_64BIT)
1582     {
1583       rs6000_darwin64_abi = 1;
1584 #if TARGET_MACHO
1585       darwin_one_byte_bool = 1;
1586 #endif
1587       /* Default to natural alignment, for better performance.  */
1588       rs6000_alignment_flags = MASK_ALIGN_NATURAL;
1589     }
1590
1591   /* Place FP constants in the constant pool instead of TOC
1592      if section anchors enabled.  */
1593   if (flag_section_anchors)
1594     TARGET_NO_FP_IN_TOC = 1;
1595
1596   /* Handle -mtls-size option.  */
1597   rs6000_parse_tls_size_option ();
1598
1599 #ifdef SUBTARGET_OVERRIDE_OPTIONS
1600   SUBTARGET_OVERRIDE_OPTIONS;
1601 #endif
1602 #ifdef SUBSUBTARGET_OVERRIDE_OPTIONS
1603   SUBSUBTARGET_OVERRIDE_OPTIONS;
1604 #endif
1605 #ifdef SUB3TARGET_OVERRIDE_OPTIONS
1606   SUB3TARGET_OVERRIDE_OPTIONS;
1607 #endif
1608
1609   if (TARGET_E500)
1610     {
1611       /* The e500 does not have string instructions, and we set
1612          MASK_STRING above when optimizing for size.  */
1613       if ((target_flags & MASK_STRING) != 0)
1614         target_flags = target_flags & ~MASK_STRING;
1615     }
1616   else if (rs6000_select[1].string != NULL)
1617     {
1618       /* For the powerpc-eabispe configuration, we set all these by
1619          default, so let's unset them if we manually set another
1620          CPU that is not the E500.  */
1621       if (!rs6000_explicit_options.abi)
1622         rs6000_spe_abi = 0;
1623       if (!rs6000_explicit_options.spe)
1624         rs6000_spe = 0;
1625       if (!rs6000_explicit_options.float_gprs)
1626         rs6000_float_gprs = 0;
1627       if (!rs6000_explicit_options.isel)
1628         rs6000_isel = 0;
1629     }
1630
1631   /* Detect invalid option combinations with E500.  */
1632   CHECK_E500_OPTIONS;
1633
1634   rs6000_always_hint = (rs6000_cpu != PROCESSOR_POWER4
1635                         && rs6000_cpu != PROCESSOR_POWER5
1636                         && rs6000_cpu != PROCESSOR_POWER6
1637                         && rs6000_cpu != PROCESSOR_CELL);
1638   rs6000_sched_groups = (rs6000_cpu == PROCESSOR_POWER4
1639                          || rs6000_cpu == PROCESSOR_POWER5);
1640   rs6000_align_branch_targets = (rs6000_cpu == PROCESSOR_POWER4
1641                                  || rs6000_cpu == PROCESSOR_POWER5
1642                                  || rs6000_cpu == PROCESSOR_POWER6);
1643
1644   rs6000_sched_restricted_insns_priority
1645     = (rs6000_sched_groups ? 1 : 0);
1646
1647   /* Handle -msched-costly-dep option.  */
1648   rs6000_sched_costly_dep
1649     = (rs6000_sched_groups ? store_to_load_dep_costly : no_dep_costly);
1650
1651   if (rs6000_sched_costly_dep_str)
1652     {
1653       if (! strcmp (rs6000_sched_costly_dep_str, "no"))
1654         rs6000_sched_costly_dep = no_dep_costly;
1655       else if (! strcmp (rs6000_sched_costly_dep_str, "all"))
1656         rs6000_sched_costly_dep = all_deps_costly;
1657       else if (! strcmp (rs6000_sched_costly_dep_str, "true_store_to_load"))
1658         rs6000_sched_costly_dep = true_store_to_load_dep_costly;
1659       else if (! strcmp (rs6000_sched_costly_dep_str, "store_to_load"))
1660         rs6000_sched_costly_dep = store_to_load_dep_costly;
1661       else
1662         rs6000_sched_costly_dep = atoi (rs6000_sched_costly_dep_str);
1663     }
1664
1665   /* Handle -minsert-sched-nops option.  */
1666   rs6000_sched_insert_nops
1667     = (rs6000_sched_groups ? sched_finish_regroup_exact : sched_finish_none);
1668
1669   if (rs6000_sched_insert_nops_str)
1670     {
1671       if (! strcmp (rs6000_sched_insert_nops_str, "no"))
1672         rs6000_sched_insert_nops = sched_finish_none;
1673       else if (! strcmp (rs6000_sched_insert_nops_str, "pad"))
1674         rs6000_sched_insert_nops = sched_finish_pad_groups;
1675       else if (! strcmp (rs6000_sched_insert_nops_str, "regroup_exact"))
1676         rs6000_sched_insert_nops = sched_finish_regroup_exact;
1677       else
1678         rs6000_sched_insert_nops = atoi (rs6000_sched_insert_nops_str);
1679     }
1680
1681 #ifdef TARGET_REGNAMES
1682   /* If the user desires alternate register names, copy in the
1683      alternate names now.  */
1684   if (TARGET_REGNAMES)
1685     memcpy (rs6000_reg_names, alt_reg_names, sizeof (rs6000_reg_names));
1686 #endif
1687
1688   /* Set aix_struct_return last, after the ABI is determined.
1689      If -maix-struct-return or -msvr4-struct-return was explicitly
1690      used, don't override with the ABI default.  */
1691   if (!rs6000_explicit_options.aix_struct_ret)
1692     aix_struct_return = (DEFAULT_ABI != ABI_V4 || DRAFT_V4_STRUCT_RET);
1693
1694   if (TARGET_LONG_DOUBLE_128 && !TARGET_IEEEQUAD)
1695     REAL_MODE_FORMAT (TFmode) = &ibm_extended_format;
1696
1697   if (TARGET_TOC)
1698     ASM_GENERATE_INTERNAL_LABEL (toc_label_name, "LCTOC", 1);
1699
1700   /* We can only guarantee the availability of DI pseudo-ops when
1701      assembling for 64-bit targets.  */
1702   if (!TARGET_64BIT)
1703     {
1704       targetm.asm_out.aligned_op.di = NULL;
1705       targetm.asm_out.unaligned_op.di = NULL;
1706     }
1707
1708   /* Set branch target alignment, if not optimizing for size.  */
1709   if (!optimize_size)
1710     {
1711       /* Cell wants to be aligned 8byte for dual issue. */
1712       if (rs6000_cpu == PROCESSOR_CELL)
1713         {
1714           if (align_functions <= 0)
1715             align_functions = 8;
1716           if (align_jumps <= 0)
1717             align_jumps = 8;
1718           if (align_loops <= 0)
1719             align_loops = 8;
1720         }
1721       if (rs6000_align_branch_targets)
1722         {
1723           if (align_functions <= 0)
1724             align_functions = 16;
1725           if (align_jumps <= 0)
1726             align_jumps = 16;
1727           if (align_loops <= 0)
1728             align_loops = 16;
1729         }
1730       if (align_jumps_max_skip <= 0)
1731         align_jumps_max_skip = 15;
1732       if (align_loops_max_skip <= 0)
1733         align_loops_max_skip = 15;
1734     }
1735
1736   /* Arrange to save and restore machine status around nested functions.  */
1737   init_machine_status = rs6000_init_machine_status;
1738
1739   /* We should always be splitting complex arguments, but we can't break
1740      Linux and Darwin ABIs at the moment.  For now, only AIX is fixed.  */
1741   if (DEFAULT_ABI != ABI_AIX)
1742     targetm.calls.split_complex_arg = NULL;
1743
1744   /* Initialize rs6000_cost with the appropriate target costs.  */
1745   if (optimize_size)
1746     rs6000_cost = TARGET_POWERPC64 ? &size64_cost : &size32_cost;
1747   else
1748     switch (rs6000_cpu)
1749       {
1750       case PROCESSOR_RIOS1:
1751         rs6000_cost = &rios1_cost;
1752         break;
1753
1754       case PROCESSOR_RIOS2:
1755         rs6000_cost = &rios2_cost;
1756         break;
1757
1758       case PROCESSOR_RS64A:
1759         rs6000_cost = &rs64a_cost;
1760         break;
1761
1762       case PROCESSOR_MPCCORE:
1763         rs6000_cost = &mpccore_cost;
1764         break;
1765
1766       case PROCESSOR_PPC403:
1767         rs6000_cost = &ppc403_cost;
1768         break;
1769
1770       case PROCESSOR_PPC405:
1771         rs6000_cost = &ppc405_cost;
1772         break;
1773
1774       case PROCESSOR_PPC440:
1775         rs6000_cost = &ppc440_cost;
1776         break;
1777
1778       case PROCESSOR_PPC601:
1779         rs6000_cost = &ppc601_cost;
1780         break;
1781
1782       case PROCESSOR_PPC603:
1783         rs6000_cost = &ppc603_cost;
1784         break;
1785
1786       case PROCESSOR_PPC604:
1787         rs6000_cost = &ppc604_cost;
1788         break;
1789
1790       case PROCESSOR_PPC604e:
1791         rs6000_cost = &ppc604e_cost;
1792         break;
1793
1794       case PROCESSOR_PPC620:
1795         rs6000_cost = &ppc620_cost;
1796         break;
1797
1798       case PROCESSOR_PPC630:
1799         rs6000_cost = &ppc630_cost;
1800         break;
1801
1802       case PROCESSOR_CELL:
1803         rs6000_cost = &ppccell_cost;
1804         break;
1805
1806       case PROCESSOR_PPC750:
1807       case PROCESSOR_PPC7400:
1808         rs6000_cost = &ppc750_cost;
1809         break;
1810
1811       case PROCESSOR_PPC7450:
1812         rs6000_cost = &ppc7450_cost;
1813         break;
1814
1815       case PROCESSOR_PPC8540:
1816         rs6000_cost = &ppc8540_cost;
1817         break;
1818
1819       case PROCESSOR_POWER4:
1820       case PROCESSOR_POWER5:
1821         rs6000_cost = &power4_cost;
1822         break;
1823
1824       case PROCESSOR_POWER6:
1825         rs6000_cost = &power6_cost;
1826         break;
1827
1828       default:
1829         gcc_unreachable ();
1830       }
1831
1832   if (!PARAM_SET_P (PARAM_SIMULTANEOUS_PREFETCHES))
1833     set_param_value ("simultaneous-prefetches",
1834                      rs6000_cost->simultaneous_prefetches);
1835   if (!PARAM_SET_P (PARAM_L1_CACHE_SIZE))
1836     set_param_value ("l1-cache-size", rs6000_cost->l1_cache_size);
1837   if (!PARAM_SET_P (PARAM_L1_CACHE_LINE_SIZE))
1838     set_param_value ("l1-cache-line-size", rs6000_cost->cache_line_size);
1839   if (!PARAM_SET_P (PARAM_L2_CACHE_SIZE))
1840     set_param_value ("l2-cache-size", rs6000_cost->l2_cache_size);
1841 }
1842
1843 /* Implement targetm.vectorize.builtin_mask_for_load.  */
1844 static tree
1845 rs6000_builtin_mask_for_load (void)
1846 {
1847   if (TARGET_ALTIVEC)
1848     return altivec_builtin_mask_for_load;
1849   else
1850     return 0;
1851 }
1852
1853 /* Implement targetm.vectorize.builtin_conversion.  */
1854 static tree
1855 rs6000_builtin_conversion (enum tree_code code, tree type)
1856 {
1857   if (!TARGET_ALTIVEC)
1858     return NULL_TREE;
1859
1860   switch (code)
1861     {
1862     case FLOAT_EXPR:
1863       switch (TYPE_MODE (type))
1864         {
1865         case V4SImode:
1866           return TYPE_UNSIGNED (type) ?
1867             rs6000_builtin_decls[ALTIVEC_BUILTIN_VCFUX] :
1868             rs6000_builtin_decls[ALTIVEC_BUILTIN_VCFSX];
1869         default:
1870           return NULL_TREE;
1871         }
1872     default:
1873       return NULL_TREE;
1874     }
1875 }
1876
1877 /* Implement targetm.vectorize.builtin_mul_widen_even.  */
1878 static tree
1879 rs6000_builtin_mul_widen_even (tree type)
1880 {
1881   if (!TARGET_ALTIVEC)
1882     return NULL_TREE;
1883
1884   switch (TYPE_MODE (type))
1885     {
1886     case V8HImode:
1887       return TYPE_UNSIGNED (type) ?
1888             rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULEUH] :
1889             rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULESH];
1890
1891     case V16QImode:
1892       return TYPE_UNSIGNED (type) ?
1893             rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULEUB] :
1894             rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULESB];
1895     default:
1896       return NULL_TREE;
1897     }
1898 }
1899
1900 /* Implement targetm.vectorize.builtin_mul_widen_odd.  */
1901 static tree
1902 rs6000_builtin_mul_widen_odd (tree type)
1903 {
1904   if (!TARGET_ALTIVEC)
1905     return NULL_TREE;
1906
1907   switch (TYPE_MODE (type))
1908     {
1909     case V8HImode:
1910       return TYPE_UNSIGNED (type) ?
1911             rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOUH] :
1912             rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOSH];
1913
1914     case V16QImode:
1915       return TYPE_UNSIGNED (type) ?
1916             rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOUB] :
1917             rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOSB];
1918     default:
1919       return NULL_TREE;
1920     }
1921 }
1922
1923
1924 /* Return true iff, data reference of TYPE can reach vector alignment (16)
1925    after applying N number of iterations.  This routine does not determine
1926    how may iterations are required to reach desired alignment.  */
1927
1928 static bool
1929 rs6000_vector_alignment_reachable (const_tree type ATTRIBUTE_UNUSED, bool is_packed)
1930 {
1931   if (is_packed)
1932     return false;
1933
1934   if (TARGET_32BIT)
1935     {
1936       if (rs6000_alignment_flags == MASK_ALIGN_NATURAL)
1937         return true;
1938
1939       if (rs6000_alignment_flags ==  MASK_ALIGN_POWER)
1940         return true;
1941
1942       return false;
1943     }
1944   else
1945     {
1946       if (TARGET_MACHO)
1947         return false;
1948
1949       /* Assuming that all other types are naturally aligned. CHECKME!  */
1950       return true;
1951     }
1952 }
1953
1954 /* Handle generic options of the form -mfoo=yes/no.
1955    NAME is the option name.
1956    VALUE is the option value.
1957    FLAG is the pointer to the flag where to store a 1 or 0, depending on
1958    whether the option value is 'yes' or 'no' respectively.  */
1959 static void
1960 rs6000_parse_yes_no_option (const char *name, const char *value, int *flag)
1961 {
1962   if (value == 0)
1963     return;
1964   else if (!strcmp (value, "yes"))
1965     *flag = 1;
1966   else if (!strcmp (value, "no"))
1967     *flag = 0;
1968   else
1969     error ("unknown -m%s= option specified: '%s'", name, value);
1970 }
1971
1972 /* Validate and record the size specified with the -mtls-size option.  */
1973
1974 static void
1975 rs6000_parse_tls_size_option (void)
1976 {
1977   if (rs6000_tls_size_string == 0)
1978     return;
1979   else if (strcmp (rs6000_tls_size_string, "16") == 0)
1980     rs6000_tls_size = 16;
1981   else if (strcmp (rs6000_tls_size_string, "32") == 0)
1982     rs6000_tls_size = 32;
1983   else if (strcmp (rs6000_tls_size_string, "64") == 0)
1984     rs6000_tls_size = 64;
1985   else
1986     error ("bad value %qs for -mtls-size switch", rs6000_tls_size_string);
1987 }
1988
1989 void
1990 optimization_options (int level ATTRIBUTE_UNUSED, int size ATTRIBUTE_UNUSED)
1991 {
1992   if (DEFAULT_ABI == ABI_DARWIN)
1993     /* The Darwin libraries never set errno, so we might as well
1994        avoid calling them when that's the only reason we would.  */
1995     flag_errno_math = 0;
1996
1997   /* Double growth factor to counter reduced min jump length.  */
1998   set_param_value ("max-grow-copy-bb-insns", 16);
1999
2000   /* Enable section anchors by default.
2001      Skip section anchors for Objective C and Objective C++
2002      until front-ends fixed.  */
2003   if (!TARGET_MACHO && lang_hooks.name[4] != 'O')
2004     flag_section_anchors = 1;
2005 }
2006
2007 /* Implement TARGET_HANDLE_OPTION.  */
2008
2009 static bool
2010 rs6000_handle_option (size_t code, const char *arg, int value)
2011 {
2012   switch (code)
2013     {
2014     case OPT_mno_power:
2015       target_flags &= ~(MASK_POWER | MASK_POWER2
2016                         | MASK_MULTIPLE | MASK_STRING);
2017       target_flags_explicit |= (MASK_POWER | MASK_POWER2
2018                                 | MASK_MULTIPLE | MASK_STRING);
2019       break;
2020     case OPT_mno_powerpc:
2021       target_flags &= ~(MASK_POWERPC | MASK_PPC_GPOPT
2022                         | MASK_PPC_GFXOPT | MASK_POWERPC64);
2023       target_flags_explicit |= (MASK_POWERPC | MASK_PPC_GPOPT
2024                                 | MASK_PPC_GFXOPT | MASK_POWERPC64);
2025       break;
2026     case OPT_mfull_toc:
2027       target_flags &= ~MASK_MINIMAL_TOC;
2028       TARGET_NO_FP_IN_TOC = 0;
2029       TARGET_NO_SUM_IN_TOC = 0;
2030       target_flags_explicit |= MASK_MINIMAL_TOC;
2031 #ifdef TARGET_USES_SYSV4_OPT
2032       /* Note, V.4 no longer uses a normal TOC, so make -mfull-toc, be
2033          just the same as -mminimal-toc.  */
2034       target_flags |= MASK_MINIMAL_TOC;
2035       target_flags_explicit |= MASK_MINIMAL_TOC;
2036 #endif
2037       break;
2038
2039 #ifdef TARGET_USES_SYSV4_OPT
2040     case OPT_mtoc:
2041       /* Make -mtoc behave like -mminimal-toc.  */
2042       target_flags |= MASK_MINIMAL_TOC;
2043       target_flags_explicit |= MASK_MINIMAL_TOC;
2044       break;
2045 #endif
2046
2047 #ifdef TARGET_USES_AIX64_OPT
2048     case OPT_maix64:
2049 #else
2050     case OPT_m64:
2051 #endif
2052       target_flags |= MASK_POWERPC64 | MASK_POWERPC;
2053       target_flags |= ~target_flags_explicit & MASK_PPC_GFXOPT;
2054       target_flags_explicit |= MASK_POWERPC64 | MASK_POWERPC;
2055       break;
2056
2057 #ifdef TARGET_USES_AIX64_OPT
2058     case OPT_maix32:
2059 #else
2060     case OPT_m32:
2061 #endif
2062       target_flags &= ~MASK_POWERPC64;
2063       target_flags_explicit |= MASK_POWERPC64;
2064       break;
2065
2066     case OPT_minsert_sched_nops_:
2067       rs6000_sched_insert_nops_str = arg;
2068       break;
2069
2070     case OPT_mminimal_toc:
2071       if (value == 1)
2072         {
2073           TARGET_NO_FP_IN_TOC = 0;
2074           TARGET_NO_SUM_IN_TOC = 0;
2075         }
2076       break;
2077
2078     case OPT_mpower:
2079       if (value == 1)
2080         {
2081           target_flags |= (MASK_MULTIPLE | MASK_STRING);
2082           target_flags_explicit |= (MASK_MULTIPLE | MASK_STRING);
2083         }
2084       break;
2085
2086     case OPT_mpower2:
2087       if (value == 1)
2088         {
2089           target_flags |= (MASK_POWER | MASK_MULTIPLE | MASK_STRING);
2090           target_flags_explicit |= (MASK_POWER | MASK_MULTIPLE | MASK_STRING);
2091         }
2092       break;
2093
2094     case OPT_mpowerpc_gpopt:
2095     case OPT_mpowerpc_gfxopt:
2096       if (value == 1)
2097         {
2098           target_flags |= MASK_POWERPC;
2099           target_flags_explicit |= MASK_POWERPC;
2100         }
2101       break;
2102
2103     case OPT_maix_struct_return:
2104     case OPT_msvr4_struct_return:
2105       rs6000_explicit_options.aix_struct_ret = true;
2106       break;
2107
2108     case OPT_mvrsave_:
2109       rs6000_parse_yes_no_option ("vrsave", arg, &(TARGET_ALTIVEC_VRSAVE));
2110       break;
2111
2112     case OPT_misel_:
2113       rs6000_explicit_options.isel = true;
2114       rs6000_parse_yes_no_option ("isel", arg, &(rs6000_isel));
2115       break;
2116
2117     case OPT_mspe_:
2118       rs6000_explicit_options.spe = true;
2119       rs6000_parse_yes_no_option ("spe", arg, &(rs6000_spe));
2120       break;
2121
2122     case OPT_mdebug_:
2123       rs6000_debug_name = arg;
2124       break;
2125
2126 #ifdef TARGET_USES_SYSV4_OPT
2127     case OPT_mcall_:
2128       rs6000_abi_name = arg;
2129       break;
2130
2131     case OPT_msdata_:
2132       rs6000_sdata_name = arg;
2133       break;
2134
2135     case OPT_mtls_size_:
2136       rs6000_tls_size_string = arg;
2137       break;
2138
2139     case OPT_mrelocatable:
2140       if (value == 1)
2141         {
2142           target_flags |= MASK_MINIMAL_TOC;
2143           target_flags_explicit |= MASK_MINIMAL_TOC;
2144           TARGET_NO_FP_IN_TOC = 1;
2145         }
2146       break;
2147
2148     case OPT_mrelocatable_lib:
2149       if (value == 1)
2150         {
2151           target_flags |= MASK_RELOCATABLE | MASK_MINIMAL_TOC;
2152           target_flags_explicit |= MASK_RELOCATABLE | MASK_MINIMAL_TOC;
2153           TARGET_NO_FP_IN_TOC = 1;
2154         }
2155       else
2156         {
2157           target_flags &= ~MASK_RELOCATABLE;
2158           target_flags_explicit |= MASK_RELOCATABLE;
2159         }
2160       break;
2161 #endif
2162
2163     case OPT_mabi_:
2164       if (!strcmp (arg, "altivec"))
2165         {
2166           rs6000_explicit_options.abi = true;
2167           rs6000_altivec_abi = 1;
2168           rs6000_spe_abi = 0;
2169         }
2170       else if (! strcmp (arg, "no-altivec"))
2171         {
2172           /* ??? Don't set rs6000_explicit_options.abi here, to allow
2173              the default for rs6000_spe_abi to be chosen later.  */
2174           rs6000_altivec_abi = 0;
2175         }
2176       else if (! strcmp (arg, "spe"))
2177         {
2178           rs6000_explicit_options.abi = true;
2179           rs6000_spe_abi = 1;
2180           rs6000_altivec_abi = 0;
2181           if (!TARGET_SPE_ABI)
2182             error ("not configured for ABI: '%s'", arg);
2183         }
2184       else if (! strcmp (arg, "no-spe"))
2185         {
2186           rs6000_explicit_options.abi = true;
2187           rs6000_spe_abi = 0;
2188         }
2189
2190       /* These are here for testing during development only, do not
2191          document in the manual please.  */
2192       else if (! strcmp (arg, "d64"))
2193         {
2194           rs6000_darwin64_abi = 1;
2195           warning (0, "Using darwin64 ABI");
2196         }
2197       else if (! strcmp (arg, "d32"))
2198         {
2199           rs6000_darwin64_abi = 0;
2200           warning (0, "Using old darwin ABI");
2201         }
2202
2203       else if (! strcmp (arg, "ibmlongdouble"))
2204         {
2205           rs6000_explicit_options.ieee = true;
2206           rs6000_ieeequad = 0;
2207           warning (0, "Using IBM extended precision long double");
2208         }
2209       else if (! strcmp (arg, "ieeelongdouble"))
2210         {
2211           rs6000_explicit_options.ieee = true;
2212           rs6000_ieeequad = 1;
2213           warning (0, "Using IEEE extended precision long double");
2214         }
2215
2216       else
2217         {
2218           error ("unknown ABI specified: '%s'", arg);
2219           return false;
2220         }
2221       break;
2222
2223     case OPT_mcpu_:
2224       rs6000_select[1].string = arg;
2225       break;
2226
2227     case OPT_mtune_:
2228       rs6000_select[2].string = arg;
2229       break;
2230
2231     case OPT_mtraceback_:
2232       rs6000_traceback_name = arg;
2233       break;
2234
2235     case OPT_mfloat_gprs_:
2236       rs6000_explicit_options.float_gprs = true;
2237       if (! strcmp (arg, "yes") || ! strcmp (arg, "single"))
2238         rs6000_float_gprs = 1;
2239       else if (! strcmp (arg, "double"))
2240         rs6000_float_gprs = 2;
2241       else if (! strcmp (arg, "no"))
2242         rs6000_float_gprs = 0;
2243       else
2244         {
2245           error ("invalid option for -mfloat-gprs: '%s'", arg);
2246           return false;
2247         }
2248       break;
2249
2250     case OPT_mlong_double_:
2251       rs6000_explicit_options.long_double = true;
2252       rs6000_long_double_type_size = RS6000_DEFAULT_LONG_DOUBLE_SIZE;
2253       if (value != 64 && value != 128)
2254         {
2255           error ("Unknown switch -mlong-double-%s", arg);
2256           rs6000_long_double_type_size = RS6000_DEFAULT_LONG_DOUBLE_SIZE;
2257           return false;
2258         }
2259       else
2260         rs6000_long_double_type_size = value;
2261       break;
2262
2263     case OPT_msched_costly_dep_:
2264       rs6000_sched_costly_dep_str = arg;
2265       break;
2266
2267     case OPT_malign_:
2268       rs6000_explicit_options.alignment = true;
2269       if (! strcmp (arg, "power"))
2270         {
2271           /* On 64-bit Darwin, power alignment is ABI-incompatible with
2272              some C library functions, so warn about it. The flag may be
2273              useful for performance studies from time to time though, so
2274              don't disable it entirely.  */
2275           if (DEFAULT_ABI == ABI_DARWIN && TARGET_64BIT)
2276             warning (0, "-malign-power is not supported for 64-bit Darwin;"
2277                      " it is incompatible with the installed C and C++ libraries");
2278           rs6000_alignment_flags = MASK_ALIGN_POWER;
2279         }
2280       else if (! strcmp (arg, "natural"))
2281         rs6000_alignment_flags = MASK_ALIGN_NATURAL;
2282       else
2283         {
2284           error ("unknown -malign-XXXXX option specified: '%s'", arg);
2285           return false;
2286         }
2287       break;
2288     }
2289   return true;
2290 }
2291 \f
2292 /* Do anything needed at the start of the asm file.  */
2293
2294 static void
2295 rs6000_file_start (void)
2296 {
2297   size_t i;
2298   char buffer[80];
2299   const char *start = buffer;
2300   struct rs6000_cpu_select *ptr;
2301   const char *default_cpu = TARGET_CPU_DEFAULT;
2302   FILE *file = asm_out_file;
2303
2304   default_file_start ();
2305
2306 #ifdef TARGET_BI_ARCH
2307   if ((TARGET_DEFAULT ^ target_flags) & MASK_64BIT)
2308     default_cpu = 0;
2309 #endif
2310
2311   if (flag_verbose_asm)
2312     {
2313       sprintf (buffer, "\n%s rs6000/powerpc options:", ASM_COMMENT_START);
2314       rs6000_select[0].string = default_cpu;
2315
2316       for (i = 0; i < ARRAY_SIZE (rs6000_select); i++)
2317         {
2318           ptr = &rs6000_select[i];
2319           if (ptr->string != (char *)0 && ptr->string[0] != '\0')
2320             {
2321               fprintf (file, "%s %s%s", start, ptr->name, ptr->string);
2322               start = "";
2323             }
2324         }
2325
2326       if (PPC405_ERRATUM77)
2327         {
2328           fprintf (file, "%s PPC405CR_ERRATUM77", start);
2329           start = "";
2330         }
2331
2332 #ifdef USING_ELFOS_H
2333       switch (rs6000_sdata)
2334         {
2335         case SDATA_NONE: fprintf (file, "%s -msdata=none", start); start = ""; break;
2336         case SDATA_DATA: fprintf (file, "%s -msdata=data", start); start = ""; break;
2337         case SDATA_SYSV: fprintf (file, "%s -msdata=sysv", start); start = ""; break;
2338         case SDATA_EABI: fprintf (file, "%s -msdata=eabi", start); start = ""; break;
2339         }
2340
2341       if (rs6000_sdata && g_switch_value)
2342         {
2343           fprintf (file, "%s -G " HOST_WIDE_INT_PRINT_UNSIGNED, start,
2344                    g_switch_value);
2345           start = "";
2346         }
2347 #endif
2348
2349       if (*start == '\0')
2350         putc ('\n', file);
2351     }
2352
2353 #ifdef HAVE_AS_GNU_ATTRIBUTE
2354   if (TARGET_32BIT && DEFAULT_ABI == ABI_V4)
2355     {
2356       fprintf (file, "\t.gnu_attribute 4, %d\n",
2357                (TARGET_HARD_FLOAT && TARGET_FPRS) ? 1 : 2);
2358       fprintf (file, "\t.gnu_attribute 8, %d\n",
2359                (TARGET_ALTIVEC_ABI ? 2
2360                 : TARGET_SPE_ABI ? 3
2361                 : 1));
2362     }
2363 #endif
2364
2365   if (DEFAULT_ABI == ABI_AIX || (TARGET_ELF && flag_pic == 2))
2366     {
2367       switch_to_section (toc_section);
2368       switch_to_section (text_section);
2369     }
2370 }
2371
2372 \f
2373 /* Return nonzero if this function is known to have a null epilogue.  */
2374
2375 int
2376 direct_return (void)
2377 {
2378   if (reload_completed)
2379     {
2380       rs6000_stack_t *info = rs6000_stack_info ();
2381
2382       if (info->first_gp_reg_save == 32
2383           && info->first_fp_reg_save == 64
2384           && info->first_altivec_reg_save == LAST_ALTIVEC_REGNO + 1
2385           && ! info->lr_save_p
2386           && ! info->cr_save_p
2387           && info->vrsave_mask == 0
2388           && ! info->push_p)
2389         return 1;
2390     }
2391
2392   return 0;
2393 }
2394
2395 /* Return the number of instructions it takes to form a constant in an
2396    integer register.  */
2397
2398 int
2399 num_insns_constant_wide (HOST_WIDE_INT value)
2400 {
2401   /* signed constant loadable with {cal|addi} */
2402   if ((unsigned HOST_WIDE_INT) (value + 0x8000) < 0x10000)
2403     return 1;
2404
2405   /* constant loadable with {cau|addis} */
2406   else if ((value & 0xffff) == 0
2407            && (value >> 31 == -1 || value >> 31 == 0))
2408     return 1;
2409
2410 #if HOST_BITS_PER_WIDE_INT == 64
2411   else if (TARGET_POWERPC64)
2412     {
2413       HOST_WIDE_INT low  = ((value & 0xffffffff) ^ 0x80000000) - 0x80000000;
2414       HOST_WIDE_INT high = value >> 31;
2415
2416       if (high == 0 || high == -1)
2417         return 2;
2418
2419       high >>= 1;
2420
2421       if (low == 0)
2422         return num_insns_constant_wide (high) + 1;
2423       else
2424         return (num_insns_constant_wide (high)
2425                 + num_insns_constant_wide (low) + 1);
2426     }
2427 #endif
2428
2429   else
2430     return 2;
2431 }
2432
2433 int
2434 num_insns_constant (rtx op, enum machine_mode mode)
2435 {
2436   HOST_WIDE_INT low, high;
2437
2438   switch (GET_CODE (op))
2439     {
2440     case CONST_INT:
2441 #if HOST_BITS_PER_WIDE_INT == 64
2442       if ((INTVAL (op) >> 31) != 0 && (INTVAL (op) >> 31) != -1
2443           && mask64_operand (op, mode))
2444         return 2;
2445       else
2446 #endif
2447         return num_insns_constant_wide (INTVAL (op));
2448
2449       case CONST_DOUBLE:
2450         if (mode == SFmode)
2451           {
2452             long l;
2453             REAL_VALUE_TYPE rv;
2454
2455             REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
2456             REAL_VALUE_TO_TARGET_SINGLE (rv, l);
2457             return num_insns_constant_wide ((HOST_WIDE_INT) l);
2458           }
2459
2460         if (mode == VOIDmode || mode == DImode)
2461           {
2462             high = CONST_DOUBLE_HIGH (op);
2463             low  = CONST_DOUBLE_LOW (op);
2464           }
2465         else
2466           {
2467             long l[2];
2468             REAL_VALUE_TYPE rv;
2469
2470             REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
2471             if (DECIMAL_FLOAT_MODE_P (mode))
2472               REAL_VALUE_TO_TARGET_DECIMAL64 (rv, l);
2473             else
2474               REAL_VALUE_TO_TARGET_DOUBLE (rv, l);
2475             high = l[WORDS_BIG_ENDIAN == 0];
2476             low  = l[WORDS_BIG_ENDIAN != 0];
2477           }
2478
2479         if (TARGET_32BIT)
2480           return (num_insns_constant_wide (low)
2481                   + num_insns_constant_wide (high));
2482         else
2483           {
2484             if ((high == 0 && low >= 0)
2485                 || (high == -1 && low < 0))
2486               return num_insns_constant_wide (low);
2487
2488             else if (mask64_operand (op, mode))
2489               return 2;
2490
2491             else if (low == 0)
2492               return num_insns_constant_wide (high) + 1;
2493
2494             else
2495               return (num_insns_constant_wide (high)
2496                       + num_insns_constant_wide (low) + 1);
2497           }
2498
2499     default:
2500       gcc_unreachable ();
2501     }
2502 }
2503
2504 /* Interpret element ELT of the CONST_VECTOR OP as an integer value.
2505    If the mode of OP is MODE_VECTOR_INT, this simply returns the
2506    corresponding element of the vector, but for V4SFmode and V2SFmode,
2507    the corresponding "float" is interpreted as an SImode integer.  */
2508
2509 static HOST_WIDE_INT
2510 const_vector_elt_as_int (rtx op, unsigned int elt)
2511 {
2512   rtx tmp = CONST_VECTOR_ELT (op, elt);
2513   if (GET_MODE (op) == V4SFmode
2514       || GET_MODE (op) == V2SFmode)
2515     tmp = gen_lowpart (SImode, tmp);
2516   return INTVAL (tmp);
2517 }
2518
2519 /* Return true if OP can be synthesized with a particular vspltisb, vspltish
2520    or vspltisw instruction.  OP is a CONST_VECTOR.  Which instruction is used
2521    depends on STEP and COPIES, one of which will be 1.  If COPIES > 1,
2522    all items are set to the same value and contain COPIES replicas of the
2523    vsplt's operand; if STEP > 1, one in STEP elements is set to the vsplt's
2524    operand and the others are set to the value of the operand's msb.  */
2525
2526 static bool
2527 vspltis_constant (rtx op, unsigned step, unsigned copies)
2528 {
2529   enum machine_mode mode = GET_MODE (op);
2530   enum machine_mode inner = GET_MODE_INNER (mode);
2531
2532   unsigned i;
2533   unsigned nunits = GET_MODE_NUNITS (mode);
2534   unsigned bitsize = GET_MODE_BITSIZE (inner);
2535   unsigned mask = GET_MODE_MASK (inner);
2536
2537   HOST_WIDE_INT val = const_vector_elt_as_int (op, nunits - 1);
2538   HOST_WIDE_INT splat_val = val;
2539   HOST_WIDE_INT msb_val = val > 0 ? 0 : -1;
2540
2541   /* Construct the value to be splatted, if possible.  If not, return 0.  */
2542   for (i = 2; i <= copies; i *= 2)
2543     {
2544       HOST_WIDE_INT small_val;
2545       bitsize /= 2;
2546       small_val = splat_val >> bitsize;
2547       mask >>= bitsize;
2548       if (splat_val != ((small_val << bitsize) | (small_val & mask)))
2549         return false;
2550       splat_val = small_val;
2551     }
2552
2553   /* Check if SPLAT_VAL can really be the operand of a vspltis[bhw].  */
2554   if (EASY_VECTOR_15 (splat_val))
2555     ;
2556
2557   /* Also check if we can splat, and then add the result to itself.  Do so if
2558      the value is positive, of if the splat instruction is using OP's mode;
2559      for splat_val < 0, the splat and the add should use the same mode.  */
2560   else if (EASY_VECTOR_15_ADD_SELF (splat_val)
2561            && (splat_val >= 0 || (step == 1 && copies == 1)))
2562     ;
2563
2564   else
2565     return false;
2566
2567   /* Check if VAL is present in every STEP-th element, and the
2568      other elements are filled with its most significant bit.  */
2569   for (i = 0; i < nunits - 1; ++i)
2570     {
2571       HOST_WIDE_INT desired_val;
2572       if (((i + 1) & (step - 1)) == 0)
2573         desired_val = val;
2574       else
2575         desired_val = msb_val;
2576
2577       if (desired_val != const_vector_elt_as_int (op, i))
2578         return false;
2579     }
2580
2581   return true;
2582 }
2583
2584
2585 /* Return true if OP is of the given MODE and can be synthesized
2586    with a vspltisb, vspltish or vspltisw.  */
2587
2588 bool
2589 easy_altivec_constant (rtx op, enum machine_mode mode)
2590 {
2591   unsigned step, copies;
2592
2593   if (mode == VOIDmode)
2594     mode = GET_MODE (op);
2595   else if (mode != GET_MODE (op))
2596     return false;
2597
2598   /* Start with a vspltisw.  */
2599   step = GET_MODE_NUNITS (mode) / 4;
2600   copies = 1;
2601
2602   if (vspltis_constant (op, step, copies))
2603     return true;
2604
2605   /* Then try with a vspltish.  */
2606   if (step == 1)
2607     copies <<= 1;
2608   else
2609     step >>= 1;
2610
2611   if (vspltis_constant (op, step, copies))
2612     return true;
2613
2614   /* And finally a vspltisb.  */
2615   if (step == 1)
2616     copies <<= 1;
2617   else
2618     step >>= 1;
2619
2620   if (vspltis_constant (op, step, copies))
2621     return true;
2622
2623   return false;
2624 }
2625
2626 /* Generate a VEC_DUPLICATE representing a vspltis[bhw] instruction whose
2627    result is OP.  Abort if it is not possible.  */
2628
2629 rtx
2630 gen_easy_altivec_constant (rtx op)
2631 {
2632   enum machine_mode mode = GET_MODE (op);
2633   int nunits = GET_MODE_NUNITS (mode);
2634   rtx last = CONST_VECTOR_ELT (op, nunits - 1);
2635   unsigned step = nunits / 4;
2636   unsigned copies = 1;
2637
2638   /* Start with a vspltisw.  */
2639   if (vspltis_constant (op, step, copies))
2640     return gen_rtx_VEC_DUPLICATE (V4SImode, gen_lowpart (SImode, last));
2641
2642   /* Then try with a vspltish.  */
2643   if (step == 1)
2644     copies <<= 1;
2645   else
2646     step >>= 1;
2647
2648   if (vspltis_constant (op, step, copies))
2649     return gen_rtx_VEC_DUPLICATE (V8HImode, gen_lowpart (HImode, last));
2650
2651   /* And finally a vspltisb.  */
2652   if (step == 1)
2653     copies <<= 1;
2654   else
2655     step >>= 1;
2656
2657   if (vspltis_constant (op, step, copies))
2658     return gen_rtx_VEC_DUPLICATE (V16QImode, gen_lowpart (QImode, last));
2659
2660   gcc_unreachable ();
2661 }
2662
2663 const char *
2664 output_vec_const_move (rtx *operands)
2665 {
2666   int cst, cst2;
2667   enum machine_mode mode;
2668   rtx dest, vec;
2669
2670   dest = operands[0];
2671   vec = operands[1];
2672   mode = GET_MODE (dest);
2673
2674   if (TARGET_ALTIVEC)
2675     {
2676       rtx splat_vec;
2677       if (zero_constant (vec, mode))
2678         return "vxor %0,%0,%0";
2679
2680       splat_vec = gen_easy_altivec_constant (vec);
2681       gcc_assert (GET_CODE (splat_vec) == VEC_DUPLICATE);
2682       operands[1] = XEXP (splat_vec, 0);
2683       if (!EASY_VECTOR_15 (INTVAL (operands[1])))
2684         return "#";
2685
2686       switch (GET_MODE (splat_vec))
2687         {
2688         case V4SImode:
2689           return "vspltisw %0,%1";
2690
2691         case V8HImode:
2692           return "vspltish %0,%1";
2693
2694         case V16QImode:
2695           return "vspltisb %0,%1";
2696
2697         default:
2698           gcc_unreachable ();
2699         }
2700     }
2701
2702   gcc_assert (TARGET_SPE);
2703
2704   /* Vector constant 0 is handled as a splitter of V2SI, and in the
2705      pattern of V1DI, V4HI, and V2SF.
2706
2707      FIXME: We should probably return # and add post reload
2708      splitters for these, but this way is so easy ;-).  */
2709   cst = INTVAL (CONST_VECTOR_ELT (vec, 0));
2710   cst2 = INTVAL (CONST_VECTOR_ELT (vec, 1));
2711   operands[1] = CONST_VECTOR_ELT (vec, 0);
2712   operands[2] = CONST_VECTOR_ELT (vec, 1);
2713   if (cst == cst2)
2714     return "li %0,%1\n\tevmergelo %0,%0,%0";
2715   else
2716     return "li %0,%1\n\tevmergelo %0,%0,%0\n\tli %0,%2";
2717 }
2718
2719 /* Initialize TARGET of vector PAIRED to VALS.  */
2720
2721 void
2722 paired_expand_vector_init (rtx target, rtx vals)
2723 {
2724   enum machine_mode mode = GET_MODE (target);
2725   int n_elts = GET_MODE_NUNITS (mode);
2726   int n_var = 0;
2727   rtx x, new, tmp, constant_op, op1, op2;
2728   int i;
2729
2730   for (i = 0; i < n_elts; ++i)
2731     {
2732       x = XVECEXP (vals, 0, i);
2733       if (!CONSTANT_P (x))
2734         ++n_var;
2735     }
2736   if (n_var == 0)
2737     {
2738       /* Load from constant pool.  */
2739       emit_move_insn (target, gen_rtx_CONST_VECTOR (mode, XVEC (vals, 0)));
2740       return;
2741     }
2742
2743   if (n_var == 2)
2744     {
2745       /* The vector is initialized only with non-constants.  */
2746       new = gen_rtx_VEC_CONCAT (V2SFmode, XVECEXP (vals, 0, 0),
2747                                 XVECEXP (vals, 0, 1));
2748
2749       emit_move_insn (target, new);
2750       return;
2751     }
2752   
2753   /* One field is non-constant and the other one is a constant.  Load the
2754      constant from the constant pool and use ps_merge instruction to
2755      construct the whole vector.  */
2756   op1 = XVECEXP (vals, 0, 0);
2757   op2 = XVECEXP (vals, 0, 1);
2758
2759   constant_op = (CONSTANT_P (op1)) ? op1 : op2;
2760
2761   tmp = gen_reg_rtx (GET_MODE (constant_op));
2762   emit_move_insn (tmp, constant_op);
2763
2764   if (CONSTANT_P (op1))
2765     new = gen_rtx_VEC_CONCAT (V2SFmode, tmp, op2);
2766   else
2767     new = gen_rtx_VEC_CONCAT (V2SFmode, op1, tmp);
2768
2769   emit_move_insn (target, new);
2770 }
2771
2772 /* Initialize vector TARGET to VALS.  */
2773
2774 void
2775 rs6000_expand_vector_init (rtx target, rtx vals)
2776 {
2777   enum machine_mode mode = GET_MODE (target);
2778   enum machine_mode inner_mode = GET_MODE_INNER (mode);
2779   int n_elts = GET_MODE_NUNITS (mode);
2780   int n_var = 0, one_var = -1;
2781   bool all_same = true, all_const_zero = true;
2782   rtx x, mem;
2783   int i;
2784
2785   for (i = 0; i < n_elts; ++i)
2786     {
2787       x = XVECEXP (vals, 0, i);
2788       if (!CONSTANT_P (x))
2789         ++n_var, one_var = i;
2790       else if (x != CONST0_RTX (inner_mode))
2791         all_const_zero = false;
2792
2793       if (i > 0 && !rtx_equal_p (x, XVECEXP (vals, 0, 0)))
2794         all_same = false;
2795     }
2796
2797   if (n_var == 0)
2798     {
2799       if (mode != V4SFmode && all_const_zero)
2800         {
2801           /* Zero register.  */
2802           emit_insn (gen_rtx_SET (VOIDmode, target,
2803                                   gen_rtx_XOR (mode, target, target)));
2804           return;
2805         }
2806       else if (mode != V4SFmode && easy_vector_constant (vals, mode))
2807         {
2808           /* Splat immediate.  */
2809           emit_insn (gen_rtx_SET (VOIDmode, target, vals));
2810           return;
2811         }
2812       else if (all_same)
2813         ;       /* Splat vector element.  */
2814       else
2815         {
2816           /* Load from constant pool.  */
2817           emit_move_insn (target, gen_rtx_CONST_VECTOR (mode, XVEC (vals, 0)));
2818           return;
2819         }
2820     }
2821
2822   /* Store value to stack temp.  Load vector element.  Splat.  */
2823   if (all_same)
2824     {
2825       mem = assign_stack_temp (mode, GET_MODE_SIZE (inner_mode), 0);
2826       emit_move_insn (adjust_address_nv (mem, inner_mode, 0),
2827                       XVECEXP (vals, 0, 0));
2828       x = gen_rtx_UNSPEC (VOIDmode,
2829                           gen_rtvec (1, const0_rtx), UNSPEC_LVE);
2830       emit_insn (gen_rtx_PARALLEL (VOIDmode,
2831                                    gen_rtvec (2,
2832                                               gen_rtx_SET (VOIDmode,
2833                                                            target, mem),
2834                                               x)));
2835       x = gen_rtx_VEC_SELECT (inner_mode, target,
2836                               gen_rtx_PARALLEL (VOIDmode,
2837                                                 gen_rtvec (1, const0_rtx)));
2838       emit_insn (gen_rtx_SET (VOIDmode, target,
2839                               gen_rtx_VEC_DUPLICATE (mode, x)));
2840       return;
2841     }
2842
2843   /* One field is non-constant.  Load constant then overwrite
2844      varying field.  */
2845   if (n_var == 1)
2846     {
2847       rtx copy = copy_rtx (vals);
2848
2849       /* Load constant part of vector, substitute neighboring value for
2850          varying element.  */
2851       XVECEXP (copy, 0, one_var) = XVECEXP (vals, 0, (one_var + 1) % n_elts);
2852       rs6000_expand_vector_init (target, copy);
2853
2854       /* Insert variable.  */
2855       rs6000_expand_vector_set (target, XVECEXP (vals, 0, one_var), one_var);
2856       return;
2857     }
2858
2859   /* Construct the vector in memory one field at a time
2860      and load the whole vector.  */
2861   mem = assign_stack_temp (mode, GET_MODE_SIZE (mode), 0);
2862   for (i = 0; i < n_elts; i++)
2863     emit_move_insn (adjust_address_nv (mem, inner_mode,
2864                                     i * GET_MODE_SIZE (inner_mode)),
2865                     XVECEXP (vals, 0, i));
2866   emit_move_insn (target, mem);
2867 }
2868
2869 /* Set field ELT of TARGET to VAL.  */
2870
2871 void
2872 rs6000_expand_vector_set (rtx target, rtx val, int elt)
2873 {
2874   enum machine_mode mode = GET_MODE (target);
2875   enum machine_mode inner_mode = GET_MODE_INNER (mode);
2876   rtx reg = gen_reg_rtx (mode);
2877   rtx mask, mem, x;
2878   int width = GET_MODE_SIZE (inner_mode);
2879   int i;
2880
2881   /* Load single variable value.  */
2882   mem = assign_stack_temp (mode, GET_MODE_SIZE (inner_mode), 0);
2883   emit_move_insn (adjust_address_nv (mem, inner_mode, 0), val);
2884   x = gen_rtx_UNSPEC (VOIDmode,
2885                       gen_rtvec (1, const0_rtx), UNSPEC_LVE);
2886   emit_insn (gen_rtx_PARALLEL (VOIDmode,
2887                                gen_rtvec (2,
2888                                           gen_rtx_SET (VOIDmode,
2889                                                        reg, mem),
2890                                           x)));
2891
2892   /* Linear sequence.  */
2893   mask = gen_rtx_PARALLEL (V16QImode, rtvec_alloc (16));
2894   for (i = 0; i < 16; ++i)
2895     XVECEXP (mask, 0, i) = GEN_INT (i);
2896
2897   /* Set permute mask to insert element into target.  */
2898   for (i = 0; i < width; ++i)
2899     XVECEXP (mask, 0, elt*width + i)
2900       = GEN_INT (i + 0x10);
2901   x = gen_rtx_CONST_VECTOR (V16QImode, XVEC (mask, 0));
2902   x = gen_rtx_UNSPEC (mode,
2903                       gen_rtvec (3, target, reg,
2904                                  force_reg (V16QImode, x)),
2905                       UNSPEC_VPERM);
2906   emit_insn (gen_rtx_SET (VOIDmode, target, x));
2907 }
2908
2909 /* Extract field ELT from VEC into TARGET.  */
2910
2911 void
2912 rs6000_expand_vector_extract (rtx target, rtx vec, int elt)
2913 {
2914   enum machine_mode mode = GET_MODE (vec);
2915   enum machine_mode inner_mode = GET_MODE_INNER (mode);
2916   rtx mem, x;
2917
2918   /* Allocate mode-sized buffer.  */
2919   mem = assign_stack_temp (mode, GET_MODE_SIZE (mode), 0);
2920
2921   /* Add offset to field within buffer matching vector element.  */
2922   mem = adjust_address_nv (mem, mode, elt * GET_MODE_SIZE (inner_mode));
2923
2924   /* Store single field into mode-sized buffer.  */
2925   x = gen_rtx_UNSPEC (VOIDmode,
2926                       gen_rtvec (1, const0_rtx), UNSPEC_STVE);
2927   emit_insn (gen_rtx_PARALLEL (VOIDmode,
2928                                gen_rtvec (2,
2929                                           gen_rtx_SET (VOIDmode,
2930                                                        mem, vec),
2931                                           x)));
2932   emit_move_insn (target, adjust_address_nv (mem, inner_mode, 0));
2933 }
2934
2935 /* Generates shifts and masks for a pair of rldicl or rldicr insns to
2936    implement ANDing by the mask IN.  */
2937 void
2938 build_mask64_2_operands (rtx in, rtx *out)
2939 {
2940 #if HOST_BITS_PER_WIDE_INT >= 64
2941   unsigned HOST_WIDE_INT c, lsb, m1, m2;
2942   int shift;
2943
2944   gcc_assert (GET_CODE (in) == CONST_INT);
2945
2946   c = INTVAL (in);
2947   if (c & 1)
2948     {
2949       /* Assume c initially something like 0x00fff000000fffff.  The idea
2950          is to rotate the word so that the middle ^^^^^^ group of zeros
2951          is at the MS end and can be cleared with an rldicl mask.  We then
2952          rotate back and clear off the MS    ^^ group of zeros with a
2953          second rldicl.  */
2954       c = ~c;                   /*   c == 0xff000ffffff00000 */
2955       lsb = c & -c;             /* lsb == 0x0000000000100000 */
2956       m1 = -lsb;                /*  m1 == 0xfffffffffff00000 */
2957       c = ~c;                   /*   c == 0x00fff000000fffff */
2958       c &= -lsb;                /*   c == 0x00fff00000000000 */
2959       lsb = c & -c;             /* lsb == 0x0000100000000000 */
2960       c = ~c;                   /*   c == 0xff000fffffffffff */
2961       c &= -lsb;                /*   c == 0xff00000000000000 */
2962       shift = 0;
2963       while ((lsb >>= 1) != 0)
2964         shift++;                /* shift == 44 on exit from loop */
2965       m1 <<= 64 - shift;        /*  m1 == 0xffffff0000000000 */
2966       m1 = ~m1;                 /*  m1 == 0x000000ffffffffff */
2967       m2 = ~c;                  /*  m2 == 0x00ffffffffffffff */
2968     }
2969   else
2970     {
2971       /* Assume c initially something like 0xff000f0000000000.  The idea
2972          is to rotate the word so that the     ^^^  middle group of zeros
2973          is at the LS end and can be cleared with an rldicr mask.  We then
2974          rotate back and clear off the LS group of ^^^^^^^^^^ zeros with
2975          a second rldicr.  */
2976       lsb = c & -c;             /* lsb == 0x0000010000000000 */
2977       m2 = -lsb;                /*  m2 == 0xffffff0000000000 */
2978       c = ~c;                   /*   c == 0x00fff0ffffffffff */
2979       c &= -lsb;                /*   c == 0x00fff00000000000 */
2980       lsb = c & -c;             /* lsb == 0x0000100000000000 */
2981       c = ~c;                   /*   c == 0xff000fffffffffff */
2982       c &= -lsb;                /*   c == 0xff00000000000000 */
2983       shift = 0;
2984       while ((lsb >>= 1) != 0)
2985         shift++;                /* shift == 44 on exit from loop */
2986       m1 = ~c;                  /*  m1 == 0x00ffffffffffffff */
2987       m1 >>= shift;             /*  m1 == 0x0000000000000fff */
2988       m1 = ~m1;                 /*  m1 == 0xfffffffffffff000 */
2989     }
2990
2991   /* Note that when we only have two 0->1 and 1->0 transitions, one of the
2992      masks will be all 1's.  We are guaranteed more than one transition.  */
2993   out[0] = GEN_INT (64 - shift);
2994   out[1] = GEN_INT (m1);
2995   out[2] = GEN_INT (shift);
2996   out[3] = GEN_INT (m2);
2997 #else
2998   (void)in;
2999   (void)out;
3000   gcc_unreachable ();
3001 #endif
3002 }
3003
3004 /* Return TRUE if OP is an invalid SUBREG operation on the e500.  */
3005
3006 bool
3007 invalid_e500_subreg (rtx op, enum machine_mode mode)
3008 {
3009   if (TARGET_E500_DOUBLE)
3010     {
3011       /* Reject (subreg:SI (reg:DF)); likewise with subreg:DI or
3012          subreg:TI and reg:TF.  */
3013       if (GET_CODE (op) == SUBREG
3014           && (mode == SImode || mode == DImode || mode == TImode)
3015           && REG_P (SUBREG_REG (op))
3016           && (GET_MODE (SUBREG_REG (op)) == DFmode
3017               || GET_MODE (SUBREG_REG (op)) == TFmode))
3018         return true;
3019
3020       /* Reject (subreg:DF (reg:DI)); likewise with subreg:TF and
3021          reg:TI.  */
3022       if (GET_CODE (op) == SUBREG
3023           && (mode == DFmode || mode == TFmode)
3024           && REG_P (SUBREG_REG (op))
3025           && (GET_MODE (SUBREG_REG (op)) == DImode
3026               || GET_MODE (SUBREG_REG (op)) == TImode))
3027         return true;
3028     }
3029
3030   if (TARGET_SPE
3031       && GET_CODE (op) == SUBREG
3032       && mode == SImode
3033       && REG_P (SUBREG_REG (op))
3034       && SPE_VECTOR_MODE (GET_MODE (SUBREG_REG (op))))
3035     return true;
3036
3037   return false;
3038 }
3039
3040 /* AIX increases natural record alignment to doubleword if the first
3041    field is an FP double while the FP fields remain word aligned.  */
3042
3043 unsigned int
3044 rs6000_special_round_type_align (tree type, unsigned int computed,
3045                                  unsigned int specified)
3046 {
3047   unsigned int align = MAX (computed, specified);
3048   tree field = TYPE_FIELDS (type);
3049
3050   /* Skip all non field decls */
3051   while (field != NULL && TREE_CODE (field) != FIELD_DECL)
3052     field = TREE_CHAIN (field);
3053
3054   if (field != NULL && field != type)
3055     {
3056       type = TREE_TYPE (field);
3057       while (TREE_CODE (type) == ARRAY_TYPE)
3058         type = TREE_TYPE (type);
3059
3060       if (type != error_mark_node && TYPE_MODE (type) == DFmode)
3061         align = MAX (align, 64);
3062     }
3063
3064   return align;
3065 }
3066
3067 /* Darwin increases record alignment to the natural alignment of
3068    the first field.  */
3069
3070 unsigned int
3071 darwin_rs6000_special_round_type_align (tree type, unsigned int computed,
3072                                         unsigned int specified)
3073 {
3074   unsigned int align = MAX (computed, specified);
3075
3076   if (TYPE_PACKED (type))
3077     return align;
3078
3079   /* Find the first field, looking down into aggregates.  */
3080   do {
3081     tree field = TYPE_FIELDS (type);
3082     /* Skip all non field decls */
3083     while (field != NULL && TREE_CODE (field) != FIELD_DECL)
3084       field = TREE_CHAIN (field);
3085     if (! field)
3086       break;
3087     type = TREE_TYPE (field);
3088     while (TREE_CODE (type) == ARRAY_TYPE)
3089       type = TREE_TYPE (type);
3090   } while (AGGREGATE_TYPE_P (type));
3091
3092   if (! AGGREGATE_TYPE_P (type) && type != error_mark_node)
3093     align = MAX (align, TYPE_ALIGN (type));
3094
3095   return align;
3096 }
3097
3098 /* Return 1 for an operand in small memory on V.4/eabi.  */
3099
3100 int
3101 small_data_operand (rtx op ATTRIBUTE_UNUSED,
3102                     enum machine_mode mode ATTRIBUTE_UNUSED)
3103 {
3104 #if TARGET_ELF
3105   rtx sym_ref;
3106
3107   if (rs6000_sdata == SDATA_NONE || rs6000_sdata == SDATA_DATA)
3108     return 0;
3109
3110   if (DEFAULT_ABI != ABI_V4)
3111     return 0;
3112
3113   if (GET_CODE (op) == SYMBOL_REF)
3114     sym_ref = op;
3115
3116   else if (GET_CODE (op) != CONST
3117            || GET_CODE (XEXP (op, 0)) != PLUS
3118            || GET_CODE (XEXP (XEXP (op, 0), 0)) != SYMBOL_REF
3119            || GET_CODE (XEXP (XEXP (op, 0), 1)) != CONST_INT)
3120     return 0;
3121
3122   else
3123     {
3124       rtx sum = XEXP (op, 0);
3125       HOST_WIDE_INT summand;
3126
3127       /* We have to be careful here, because it is the referenced address
3128          that must be 32k from _SDA_BASE_, not just the symbol.  */
3129       summand = INTVAL (XEXP (sum, 1));
3130       if (summand < 0 || (unsigned HOST_WIDE_INT) summand > g_switch_value)
3131         return 0;
3132
3133       sym_ref = XEXP (sum, 0);
3134     }
3135
3136   return SYMBOL_REF_SMALL_P (sym_ref);
3137 #else
3138   return 0;
3139 #endif
3140 }
3141
3142 /* Return true if either operand is a general purpose register.  */
3143
3144 bool
3145 gpr_or_gpr_p (rtx op0, rtx op1)
3146 {
3147   return ((REG_P (op0) && INT_REGNO_P (REGNO (op0)))
3148           || (REG_P (op1) && INT_REGNO_P (REGNO (op1))));
3149 }
3150
3151 \f
3152 /* Subroutines of rs6000_legitimize_address and rs6000_legitimate_address.  */
3153
3154 static int
3155 constant_pool_expr_1 (rtx op, int *have_sym, int *have_toc)
3156 {
3157   switch (GET_CODE (op))
3158     {
3159     case SYMBOL_REF:
3160       if (RS6000_SYMBOL_REF_TLS_P (op))
3161         return 0;
3162       else if (CONSTANT_POOL_ADDRESS_P (op))
3163         {
3164           if (ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (get_pool_constant (op), Pmode))
3165             {
3166               *have_sym = 1;
3167               return 1;
3168             }
3169           else
3170             return 0;
3171         }
3172       else if (! strcmp (XSTR (op, 0), toc_label_name))
3173         {
3174           *have_toc = 1;
3175           return 1;
3176         }
3177       else
3178         return 0;
3179     case PLUS:
3180     case MINUS:
3181       return (constant_pool_expr_1 (XEXP (op, 0), have_sym, have_toc)
3182               && constant_pool_expr_1 (XEXP (op, 1), have_sym, have_toc));
3183     case CONST:
3184       return constant_pool_expr_1 (XEXP (op, 0), have_sym, have_toc);
3185     case CONST_INT:
3186       return 1;
3187     default:
3188       return 0;
3189     }
3190 }
3191
3192 static bool
3193 constant_pool_expr_p (rtx op)
3194 {
3195   int have_sym = 0;
3196   int have_toc = 0;
3197   return constant_pool_expr_1 (op, &have_sym, &have_toc) && have_sym;
3198 }
3199
3200 bool
3201 toc_relative_expr_p (rtx op)
3202 {
3203   int have_sym = 0;
3204   int have_toc = 0;
3205   return constant_pool_expr_1 (op, &have_sym, &have_toc) && have_toc;
3206 }
3207
3208 bool
3209 legitimate_constant_pool_address_p (rtx x)
3210 {
3211   return (TARGET_TOC
3212           && GET_CODE (x) == PLUS
3213           && GET_CODE (XEXP (x, 0)) == REG
3214           && (TARGET_MINIMAL_TOC || REGNO (XEXP (x, 0)) == TOC_REGISTER)
3215           && constant_pool_expr_p (XEXP (x, 1)));
3216 }
3217
3218 static bool
3219 legitimate_small_data_p (enum machine_mode mode, rtx x)
3220 {
3221   return (DEFAULT_ABI == ABI_V4
3222           && !flag_pic && !TARGET_TOC
3223           && (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == CONST)
3224           && small_data_operand (x, mode));
3225 }
3226
3227 /* SPE offset addressing is limited to 5-bits worth of double words.  */
3228 #define SPE_CONST_OFFSET_OK(x) (((x) & ~0xf8) == 0)
3229
3230 bool
3231 rs6000_legitimate_offset_address_p (enum machine_mode mode, rtx x, int strict)
3232 {
3233   unsigned HOST_WIDE_INT offset, extra;
3234
3235   if (GET_CODE (x) != PLUS)
3236     return false;
3237   if (GET_CODE (XEXP (x, 0)) != REG)
3238     return false;
3239   if (!INT_REG_OK_FOR_BASE_P (XEXP (x, 0), strict))
3240     return false;
3241   if (legitimate_constant_pool_address_p (x))
3242     return true;
3243   if (GET_CODE (XEXP (x, 1)) != CONST_INT)
3244     return false;
3245
3246   offset = INTVAL (XEXP (x, 1));
3247   extra = 0;
3248   switch (mode)
3249     {
3250     case V16QImode:
3251     case V8HImode:
3252     case V4SFmode:
3253     case V4SImode:
3254       /* AltiVec vector modes.  Only reg+reg addressing is valid and
3255          constant offset zero should not occur due to canonicalization.
3256          Allow any offset when not strict before reload.  */
3257       return !strict;
3258
3259     case V4HImode:
3260     case V2SImode:
3261     case V1DImode:
3262     case V2SFmode:
3263        /* Paired vector modes.  Only reg+reg addressing is valid and
3264          constant offset zero should not occur due to canonicalization.
3265          Allow any offset when not strict before reload.  */
3266       if (TARGET_PAIRED_FLOAT)
3267         return !strict;
3268       /* SPE vector modes.  */
3269       return SPE_CONST_OFFSET_OK (offset);
3270
3271     case DFmode:
3272     case DDmode:
3273       if (TARGET_E500_DOUBLE)
3274         return SPE_CONST_OFFSET_OK (offset);
3275
3276     case DImode:
3277       /* On e500v2, we may have:
3278
3279            (subreg:DF (mem:DI (plus (reg) (const_int))) 0).
3280
3281          Which gets addressed with evldd instructions.  */
3282       if (TARGET_E500_DOUBLE)
3283         return SPE_CONST_OFFSET_OK (offset);
3284
3285       if (mode == DFmode || mode == DDmode || !TARGET_POWERPC64)
3286         extra = 4;
3287       else if (offset & 3)
3288         return false;
3289       break;
3290
3291     case TFmode:
3292       if (TARGET_E500_DOUBLE)
3293         return (SPE_CONST_OFFSET_OK (offset)
3294                 && SPE_CONST_OFFSET_OK (offset + 8));
3295
3296     case TImode:
3297     case TDmode:
3298       if (mode == TFmode || mode == TDmode || !TARGET_POWERPC64)
3299         extra = 12;
3300       else if (offset & 3)
3301         return false;
3302       else
3303         extra = 8;
3304       break;
3305
3306     default:
3307       break;
3308     }
3309
3310   offset += 0x8000;
3311   return (offset < 0x10000) && (offset + extra < 0x10000);
3312 }
3313
3314 bool
3315 legitimate_indexed_address_p (rtx x, int strict)
3316 {
3317   rtx op0, op1;
3318
3319   if (GET_CODE (x) != PLUS)
3320     return false;
3321
3322   op0 = XEXP (x, 0);
3323   op1 = XEXP (x, 1);
3324
3325   /* Recognize the rtl generated by reload which we know will later be
3326      replaced with proper base and index regs.  */
3327   if (!strict
3328       && reload_in_progress
3329       && (REG_P (op0) || GET_CODE (op0) == PLUS)
3330       && REG_P (op1))
3331     return true;
3332
3333   return (REG_P (op0) && REG_P (op1)
3334           && ((INT_REG_OK_FOR_BASE_P (op0, strict)
3335                && INT_REG_OK_FOR_INDEX_P (op1, strict))
3336               || (INT_REG_OK_FOR_BASE_P (op1, strict)
3337                   && INT_REG_OK_FOR_INDEX_P (op0, strict))));
3338 }
3339
3340 inline bool
3341 legitimate_indirect_address_p (rtx x, int strict)
3342 {
3343   return GET_CODE (x) == REG && INT_REG_OK_FOR_BASE_P (x, strict);
3344 }
3345
3346 bool
3347 macho_lo_sum_memory_operand (rtx x, enum machine_mode mode)
3348 {
3349   if (!TARGET_MACHO || !flag_pic
3350       || mode != SImode || GET_CODE (x) != MEM)
3351     return false;
3352   x = XEXP (x, 0);
3353
3354   if (GET_CODE (x) != LO_SUM)
3355     return false;
3356   if (GET_CODE (XEXP (x, 0)) != REG)
3357     return false;
3358   if (!INT_REG_OK_FOR_BASE_P (XEXP (x, 0), 0))
3359     return false;
3360   x = XEXP (x, 1);
3361
3362   return CONSTANT_P (x);
3363 }
3364
3365 static bool
3366 legitimate_lo_sum_address_p (enum machine_mode mode, rtx x, int strict)
3367 {
3368   if (GET_CODE (x) != LO_SUM)
3369     return false;
3370   if (GET_CODE (XEXP (x, 0)) != REG)
3371     return false;
3372   if (!INT_REG_OK_FOR_BASE_P (XEXP (x, 0), strict))
3373     return false;
3374   /* Restrict addressing for DI because of our SUBREG hackery.  */
3375   if (TARGET_E500_DOUBLE && (mode == DFmode || mode == TFmode
3376                              || mode == DImode))
3377     return false;
3378   x = XEXP (x, 1);
3379
3380   if (TARGET_ELF || TARGET_MACHO)
3381     {
3382       if (DEFAULT_ABI != ABI_AIX && DEFAULT_ABI != ABI_DARWIN && flag_pic)
3383         return false;
3384       if (TARGET_TOC)
3385         return false;
3386       if (GET_MODE_NUNITS (mode) != 1)
3387         return false;
3388       if (GET_MODE_BITSIZE (mode) > 64
3389           || (GET_MODE_BITSIZE (mode) > 32 && !TARGET_POWERPC64
3390               && !(TARGET_HARD_FLOAT && TARGET_FPRS && mode == DFmode)))
3391         return false;
3392
3393       return CONSTANT_P (x);
3394     }
3395
3396   return false;
3397 }
3398
3399
3400 /* Try machine-dependent ways of modifying an illegitimate address
3401    to be legitimate.  If we find one, return the new, valid address.
3402    This is used from only one place: `memory_address' in explow.c.
3403
3404    OLDX is the address as it was before break_out_memory_refs was
3405    called.  In some cases it is useful to look at this to decide what
3406    needs to be done.
3407
3408    MODE is passed so that this function can use GO_IF_LEGITIMATE_ADDRESS.
3409
3410    It is always safe for this function to do nothing.  It exists to
3411    recognize opportunities to optimize the output.
3412
3413    On RS/6000, first check for the sum of a register with a constant
3414    integer that is out of range.  If so, generate code to add the
3415    constant with the low-order 16 bits masked to the register and force
3416    this result into another register (this can be done with `cau').
3417    Then generate an address of REG+(CONST&0xffff), allowing for the
3418    possibility of bit 16 being a one.
3419
3420    Then check for the sum of a register and something not constant, try to
3421    load the other things into a register and return the sum.  */
3422
3423 rtx
3424 rs6000_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
3425                            enum machine_mode mode)
3426 {
3427   if (GET_CODE (x) == SYMBOL_REF)
3428     {
3429       enum tls_model model = SYMBOL_REF_TLS_MODEL (x);
3430       if (model != 0)
3431         return rs6000_legitimize_tls_address (x, model);
3432     }
3433
3434   if (GET_CODE (x) == PLUS
3435       && GET_CODE (XEXP (x, 0)) == REG
3436       && GET_CODE (XEXP (x, 1)) == CONST_INT
3437       && (unsigned HOST_WIDE_INT) (INTVAL (XEXP (x, 1)) + 0x8000) >= 0x10000
3438       && !(SPE_VECTOR_MODE (mode)
3439            || (TARGET_E500_DOUBLE && (mode == DFmode || mode == TFmode
3440                                       || mode == DImode))))
3441     {
3442       HOST_WIDE_INT high_int, low_int;
3443       rtx sum;
3444       low_int = ((INTVAL (XEXP (x, 1)) & 0xffff) ^ 0x8000) - 0x8000;
3445       high_int = INTVAL (XEXP (x, 1)) - low_int;
3446       sum = force_operand (gen_rtx_PLUS (Pmode, XEXP (x, 0),
3447                                          GEN_INT (high_int)), 0);
3448       return gen_rtx_PLUS (Pmode, sum, GEN_INT (low_int));
3449     }
3450   else if (GET_CODE (x) == PLUS
3451            && GET_CODE (XEXP (x, 0)) == REG
3452            && GET_CODE (XEXP (x, 1)) != CONST_INT