OSDN Git Service

5ada791b7dc5a7ab23ff1da4a35adf746afa9d38
[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_mask_for_load (void);
803 static tree rs6000_builtin_mul_widen_even (tree);
804 static tree rs6000_builtin_mul_widen_odd (tree);
805 static tree rs6000_builtin_conversion (enum tree_code, tree);
806
807 static void def_builtin (int, const char *, tree, int);
808 static bool rs6000_vector_alignment_reachable (const_tree, bool);
809 static void rs6000_init_builtins (void);
810 static rtx rs6000_expand_unop_builtin (enum insn_code, tree, rtx);
811 static rtx rs6000_expand_binop_builtin (enum insn_code, tree, rtx);
812 static rtx rs6000_expand_ternop_builtin (enum insn_code, tree, rtx);
813 static rtx rs6000_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
814 static void altivec_init_builtins (void);
815 static void rs6000_common_init_builtins (void);
816 static void rs6000_init_libfuncs (void);
817
818 static void paired_init_builtins (void);
819 static rtx paired_expand_builtin (tree, rtx, bool *);
820 static rtx paired_expand_lv_builtin (enum insn_code, tree, rtx);
821 static rtx paired_expand_stv_builtin (enum insn_code, tree);
822 static rtx paired_expand_predicate_builtin (enum insn_code, tree, rtx);
823
824 static void enable_mask_for_builtins (struct builtin_description *, int,
825                                       enum rs6000_builtins,
826                                       enum rs6000_builtins);
827 static tree build_opaque_vector_type (tree, int);
828 static void spe_init_builtins (void);
829 static rtx spe_expand_builtin (tree, rtx, bool *);
830 static rtx spe_expand_stv_builtin (enum insn_code, tree);
831 static rtx spe_expand_predicate_builtin (enum insn_code, tree, rtx);
832 static rtx spe_expand_evsel_builtin (enum insn_code, tree, rtx);
833 static int rs6000_emit_int_cmove (rtx, rtx, rtx, rtx);
834 static rs6000_stack_t *rs6000_stack_info (void);
835 static void debug_stack_info (rs6000_stack_t *);
836
837 static rtx altivec_expand_builtin (tree, rtx, bool *);
838 static rtx altivec_expand_ld_builtin (tree, rtx, bool *);
839 static rtx altivec_expand_st_builtin (tree, rtx, bool *);
840 static rtx altivec_expand_dst_builtin (tree, rtx, bool *);
841 static rtx altivec_expand_abs_builtin (enum insn_code, tree, rtx);
842 static rtx altivec_expand_predicate_builtin (enum insn_code,
843                                              const char *, tree, rtx);
844 static rtx altivec_expand_lv_builtin (enum insn_code, tree, rtx);
845 static rtx altivec_expand_stv_builtin (enum insn_code, tree);
846 static rtx altivec_expand_vec_init_builtin (tree, tree, rtx);
847 static rtx altivec_expand_vec_set_builtin (tree);
848 static rtx altivec_expand_vec_ext_builtin (tree, rtx);
849 static int get_element_number (tree, tree);
850 static bool rs6000_handle_option (size_t, const char *, int);
851 static void rs6000_parse_tls_size_option (void);
852 static void rs6000_parse_yes_no_option (const char *, const char *, int *);
853 static int first_altivec_reg_to_save (void);
854 static unsigned int compute_vrsave_mask (void);
855 static void compute_save_world_info (rs6000_stack_t *info_ptr);
856 static void is_altivec_return_reg (rtx, void *);
857 static rtx generate_set_vrsave (rtx, rs6000_stack_t *, int);
858 int easy_vector_constant (rtx, enum machine_mode);
859 static bool rs6000_is_opaque_type (const_tree);
860 static rtx rs6000_dwarf_register_span (rtx);
861 static void rs6000_init_dwarf_reg_sizes_extra (tree);
862 static rtx rs6000_legitimize_tls_address (rtx, enum tls_model);
863 static void rs6000_output_dwarf_dtprel (FILE *, int, rtx) ATTRIBUTE_UNUSED;
864 static rtx rs6000_tls_get_addr (void);
865 static rtx rs6000_got_sym (void);
866 static int rs6000_tls_symbol_ref_1 (rtx *, void *);
867 static const char *rs6000_get_some_local_dynamic_name (void);
868 static int rs6000_get_some_local_dynamic_name_1 (rtx *, void *);
869 static rtx rs6000_complex_function_value (enum machine_mode);
870 static rtx rs6000_spe_function_arg (CUMULATIVE_ARGS *,
871                                     enum machine_mode, tree);
872 static void rs6000_darwin64_record_arg_advance_flush (CUMULATIVE_ARGS *,
873                                                       HOST_WIDE_INT);
874 static void rs6000_darwin64_record_arg_advance_recurse (CUMULATIVE_ARGS *,
875                                                         tree, HOST_WIDE_INT);
876 static void rs6000_darwin64_record_arg_flush (CUMULATIVE_ARGS *,
877                                               HOST_WIDE_INT,
878                                               rtx[], int *);
879 static void rs6000_darwin64_record_arg_recurse (CUMULATIVE_ARGS *,
880                                                 const_tree, HOST_WIDE_INT,
881                                                 rtx[], int *);
882 static rtx rs6000_darwin64_record_arg (CUMULATIVE_ARGS *, const_tree, int, bool);
883 static rtx rs6000_mixed_function_arg (enum machine_mode, tree, int);
884 static void rs6000_move_block_from_reg (int regno, rtx x, int nregs);
885 static void setup_incoming_varargs (CUMULATIVE_ARGS *,
886                                     enum machine_mode, tree,
887                                     int *, int);
888 static bool rs6000_pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode,
889                                       const_tree, bool);
890 static int rs6000_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode,
891                                      tree, bool);
892 static const char *invalid_arg_for_unprototyped_fn (const_tree, const_tree, const_tree);
893 #if TARGET_MACHO
894 static void macho_branch_islands (void);
895 static int no_previous_def (tree function_name);
896 static tree get_prev_label (tree function_name);
897 static void rs6000_darwin_file_start (void);
898 #endif
899
900 static tree rs6000_build_builtin_va_list (void);
901 static tree rs6000_gimplify_va_arg (tree, tree, tree *, tree *);
902 static bool rs6000_must_pass_in_stack (enum machine_mode, const_tree);
903 static bool rs6000_scalar_mode_supported_p (enum machine_mode);
904 static bool rs6000_vector_mode_supported_p (enum machine_mode);
905 static int get_vec_cmp_insn (enum rtx_code, enum machine_mode,
906                              enum machine_mode);
907 static rtx rs6000_emit_vector_compare (enum rtx_code, rtx, rtx,
908                                        enum machine_mode);
909 static int get_vsel_insn (enum machine_mode);
910 static void rs6000_emit_vector_select (rtx, rtx, rtx, rtx);
911 static tree rs6000_stack_protect_fail (void);
912
913 const int INSN_NOT_AVAILABLE = -1;
914 static enum machine_mode rs6000_eh_return_filter_mode (void);
915
916 /* Hash table stuff for keeping track of TOC entries.  */
917
918 struct toc_hash_struct GTY(())
919 {
920   /* `key' will satisfy CONSTANT_P; in fact, it will satisfy
921      ASM_OUTPUT_SPECIAL_POOL_ENTRY_P.  */
922   rtx key;
923   enum machine_mode key_mode;
924   int labelno;
925 };
926
927 static GTY ((param_is (struct toc_hash_struct))) htab_t toc_hash_table;
928 \f
929 /* Default register names.  */
930 char rs6000_reg_names[][8] =
931 {
932       "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",
933       "8",  "9", "10", "11", "12", "13", "14", "15",
934      "16", "17", "18", "19", "20", "21", "22", "23",
935      "24", "25", "26", "27", "28", "29", "30", "31",
936       "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",
937       "8",  "9", "10", "11", "12", "13", "14", "15",
938      "16", "17", "18", "19", "20", "21", "22", "23",
939      "24", "25", "26", "27", "28", "29", "30", "31",
940      "mq", "lr", "ctr","ap",
941       "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",
942       "xer",
943       /* AltiVec registers.  */
944       "0",  "1",  "2",  "3",  "4",  "5",  "6", "7",
945       "8",  "9",  "10", "11", "12", "13", "14", "15",
946       "16", "17", "18", "19", "20", "21", "22", "23",
947       "24", "25", "26", "27", "28", "29", "30", "31",
948       "vrsave", "vscr",
949       /* SPE registers.  */
950       "spe_acc", "spefscr",
951       /* Soft frame pointer.  */
952       "sfp"
953 };
954
955 #ifdef TARGET_REGNAMES
956 static const char alt_reg_names[][8] =
957 {
958    "%r0",   "%r1",  "%r2",  "%r3",  "%r4",  "%r5",  "%r6",  "%r7",
959    "%r8",   "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15",
960   "%r16",  "%r17", "%r18", "%r19", "%r20", "%r21", "%r22", "%r23",
961   "%r24",  "%r25", "%r26", "%r27", "%r28", "%r29", "%r30", "%r31",
962    "%f0",   "%f1",  "%f2",  "%f3",  "%f4",  "%f5",  "%f6",  "%f7",
963    "%f8",   "%f9", "%f10", "%f11", "%f12", "%f13", "%f14", "%f15",
964   "%f16",  "%f17", "%f18", "%f19", "%f20", "%f21", "%f22", "%f23",
965   "%f24",  "%f25", "%f26", "%f27", "%f28", "%f29", "%f30", "%f31",
966     "mq",    "lr",  "ctr",   "ap",
967   "%cr0",  "%cr1", "%cr2", "%cr3", "%cr4", "%cr5", "%cr6", "%cr7",
968    "xer",
969   /* AltiVec registers.  */
970    "%v0",  "%v1",  "%v2",  "%v3",  "%v4",  "%v5",  "%v6", "%v7",
971    "%v8",  "%v9", "%v10", "%v11", "%v12", "%v13", "%v14", "%v15",
972   "%v16", "%v17", "%v18", "%v19", "%v20", "%v21", "%v22", "%v23",
973   "%v24", "%v25", "%v26", "%v27", "%v28", "%v29", "%v30", "%v31",
974   "vrsave", "vscr",
975   /* SPE registers.  */
976   "spe_acc", "spefscr",
977   /* Soft frame pointer.  */
978   "sfp"
979 };
980 #endif
981 \f
982 #ifndef MASK_STRICT_ALIGN
983 #define MASK_STRICT_ALIGN 0
984 #endif
985 #ifndef TARGET_PROFILE_KERNEL
986 #define TARGET_PROFILE_KERNEL 0
987 #endif
988
989 /* The VRSAVE bitmask puts bit %v0 as the most significant bit.  */
990 #define ALTIVEC_REG_BIT(REGNO) (0x80000000 >> ((REGNO) - FIRST_ALTIVEC_REGNO))
991 \f
992 /* Initialize the GCC target structure.  */
993 #undef TARGET_ATTRIBUTE_TABLE
994 #define TARGET_ATTRIBUTE_TABLE rs6000_attribute_table
995 #undef TARGET_SET_DEFAULT_TYPE_ATTRIBUTES
996 #define TARGET_SET_DEFAULT_TYPE_ATTRIBUTES rs6000_set_default_type_attributes
997
998 #undef TARGET_ASM_ALIGNED_DI_OP
999 #define TARGET_ASM_ALIGNED_DI_OP DOUBLE_INT_ASM_OP
1000
1001 /* Default unaligned ops are only provided for ELF.  Find the ops needed
1002    for non-ELF systems.  */
1003 #ifndef OBJECT_FORMAT_ELF
1004 #if TARGET_XCOFF
1005 /* For XCOFF.  rs6000_assemble_integer will handle unaligned DIs on
1006    64-bit targets.  */
1007 #undef TARGET_ASM_UNALIGNED_HI_OP
1008 #define TARGET_ASM_UNALIGNED_HI_OP "\t.vbyte\t2,"
1009 #undef TARGET_ASM_UNALIGNED_SI_OP
1010 #define TARGET_ASM_UNALIGNED_SI_OP "\t.vbyte\t4,"
1011 #undef TARGET_ASM_UNALIGNED_DI_OP
1012 #define TARGET_ASM_UNALIGNED_DI_OP "\t.vbyte\t8,"
1013 #else
1014 /* For Darwin.  */
1015 #undef TARGET_ASM_UNALIGNED_HI_OP
1016 #define TARGET_ASM_UNALIGNED_HI_OP "\t.short\t"
1017 #undef TARGET_ASM_UNALIGNED_SI_OP
1018 #define TARGET_ASM_UNALIGNED_SI_OP "\t.long\t"
1019 #undef TARGET_ASM_UNALIGNED_DI_OP
1020 #define TARGET_ASM_UNALIGNED_DI_OP "\t.quad\t"
1021 #undef TARGET_ASM_ALIGNED_DI_OP
1022 #define TARGET_ASM_ALIGNED_DI_OP "\t.quad\t"
1023 #endif
1024 #endif
1025
1026 /* This hook deals with fixups for relocatable code and DI-mode objects
1027    in 64-bit code.  */
1028 #undef TARGET_ASM_INTEGER
1029 #define TARGET_ASM_INTEGER rs6000_assemble_integer
1030
1031 #ifdef HAVE_GAS_HIDDEN
1032 #undef TARGET_ASM_ASSEMBLE_VISIBILITY
1033 #define TARGET_ASM_ASSEMBLE_VISIBILITY rs6000_assemble_visibility
1034 #endif
1035
1036 #undef TARGET_HAVE_TLS
1037 #define TARGET_HAVE_TLS HAVE_AS_TLS
1038
1039 #undef TARGET_CANNOT_FORCE_CONST_MEM
1040 #define TARGET_CANNOT_FORCE_CONST_MEM rs6000_tls_referenced_p
1041
1042 #undef TARGET_ASM_FUNCTION_PROLOGUE
1043 #define TARGET_ASM_FUNCTION_PROLOGUE rs6000_output_function_prologue
1044 #undef TARGET_ASM_FUNCTION_EPILOGUE
1045 #define TARGET_ASM_FUNCTION_EPILOGUE rs6000_output_function_epilogue
1046
1047 #undef  TARGET_SCHED_VARIABLE_ISSUE
1048 #define TARGET_SCHED_VARIABLE_ISSUE rs6000_variable_issue
1049
1050 #undef TARGET_SCHED_ISSUE_RATE
1051 #define TARGET_SCHED_ISSUE_RATE rs6000_issue_rate
1052 #undef TARGET_SCHED_ADJUST_COST
1053 #define TARGET_SCHED_ADJUST_COST rs6000_adjust_cost
1054 #undef TARGET_SCHED_ADJUST_PRIORITY
1055 #define TARGET_SCHED_ADJUST_PRIORITY rs6000_adjust_priority
1056 #undef TARGET_SCHED_IS_COSTLY_DEPENDENCE
1057 #define TARGET_SCHED_IS_COSTLY_DEPENDENCE rs6000_is_costly_dependence
1058 #undef TARGET_SCHED_INIT
1059 #define TARGET_SCHED_INIT rs6000_sched_init
1060 #undef TARGET_SCHED_FINISH
1061 #define TARGET_SCHED_FINISH rs6000_sched_finish
1062 #undef TARGET_SCHED_REORDER
1063 #define TARGET_SCHED_REORDER rs6000_sched_reorder
1064 #undef TARGET_SCHED_REORDER2
1065 #define TARGET_SCHED_REORDER2 rs6000_sched_reorder2
1066
1067 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
1068 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD rs6000_use_sched_lookahead
1069
1070 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD
1071 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD rs6000_use_sched_lookahead_guard
1072
1073 #undef TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD
1074 #define TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD rs6000_builtin_mask_for_load
1075 #undef TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_EVEN
1076 #define TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_EVEN rs6000_builtin_mul_widen_even
1077 #undef TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_ODD
1078 #define TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_ODD rs6000_builtin_mul_widen_odd
1079 #undef TARGET_VECTORIZE_BUILTIN_CONVERSION
1080 #define TARGET_VECTORIZE_BUILTIN_CONVERSION rs6000_builtin_conversion
1081
1082 #undef TARGET_VECTOR_ALIGNMENT_REACHABLE
1083 #define TARGET_VECTOR_ALIGNMENT_REACHABLE rs6000_vector_alignment_reachable
1084
1085 #undef TARGET_INIT_BUILTINS
1086 #define TARGET_INIT_BUILTINS rs6000_init_builtins
1087
1088 #undef TARGET_EXPAND_BUILTIN
1089 #define TARGET_EXPAND_BUILTIN rs6000_expand_builtin
1090
1091 #undef TARGET_MANGLE_TYPE
1092 #define TARGET_MANGLE_TYPE rs6000_mangle_type
1093
1094 #undef TARGET_INIT_LIBFUNCS
1095 #define TARGET_INIT_LIBFUNCS rs6000_init_libfuncs
1096
1097 #if TARGET_MACHO
1098 #undef TARGET_BINDS_LOCAL_P
1099 #define TARGET_BINDS_LOCAL_P darwin_binds_local_p
1100 #endif
1101
1102 #undef TARGET_MS_BITFIELD_LAYOUT_P
1103 #define TARGET_MS_BITFIELD_LAYOUT_P rs6000_ms_bitfield_layout_p
1104
1105 #undef TARGET_ASM_OUTPUT_MI_THUNK
1106 #define TARGET_ASM_OUTPUT_MI_THUNK rs6000_output_mi_thunk
1107
1108 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
1109 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK hook_bool_const_tree_hwi_hwi_const_tree_true
1110
1111 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
1112 #define TARGET_FUNCTION_OK_FOR_SIBCALL rs6000_function_ok_for_sibcall
1113
1114 #undef TARGET_INVALID_WITHIN_DOLOOP
1115 #define TARGET_INVALID_WITHIN_DOLOOP rs6000_invalid_within_doloop
1116
1117 #undef TARGET_RTX_COSTS
1118 #define TARGET_RTX_COSTS rs6000_rtx_costs
1119 #undef TARGET_ADDRESS_COST
1120 #define TARGET_ADDRESS_COST hook_int_rtx_0
1121
1122 #undef TARGET_VECTOR_OPAQUE_P
1123 #define TARGET_VECTOR_OPAQUE_P rs6000_is_opaque_type
1124
1125 #undef TARGET_DWARF_REGISTER_SPAN
1126 #define TARGET_DWARF_REGISTER_SPAN rs6000_dwarf_register_span
1127
1128 #undef TARGET_INIT_DWARF_REG_SIZES_EXTRA
1129 #define TARGET_INIT_DWARF_REG_SIZES_EXTRA rs6000_init_dwarf_reg_sizes_extra
1130
1131 /* On rs6000, function arguments are promoted, as are function return
1132    values.  */
1133 #undef TARGET_PROMOTE_FUNCTION_ARGS
1134 #define TARGET_PROMOTE_FUNCTION_ARGS hook_bool_const_tree_true
1135 #undef TARGET_PROMOTE_FUNCTION_RETURN
1136 #define TARGET_PROMOTE_FUNCTION_RETURN hook_bool_const_tree_true
1137
1138 #undef TARGET_RETURN_IN_MEMORY
1139 #define TARGET_RETURN_IN_MEMORY rs6000_return_in_memory
1140
1141 #undef TARGET_SETUP_INCOMING_VARARGS
1142 #define TARGET_SETUP_INCOMING_VARARGS setup_incoming_varargs
1143
1144 /* Always strict argument naming on rs6000.  */
1145 #undef TARGET_STRICT_ARGUMENT_NAMING
1146 #define TARGET_STRICT_ARGUMENT_NAMING hook_bool_CUMULATIVE_ARGS_true
1147 #undef TARGET_PRETEND_OUTGOING_VARARGS_NAMED
1148 #define TARGET_PRETEND_OUTGOING_VARARGS_NAMED hook_bool_CUMULATIVE_ARGS_true
1149 #undef TARGET_SPLIT_COMPLEX_ARG
1150 #define TARGET_SPLIT_COMPLEX_ARG hook_bool_const_tree_true
1151 #undef TARGET_MUST_PASS_IN_STACK
1152 #define TARGET_MUST_PASS_IN_STACK rs6000_must_pass_in_stack
1153 #undef TARGET_PASS_BY_REFERENCE
1154 #define TARGET_PASS_BY_REFERENCE rs6000_pass_by_reference
1155 #undef TARGET_ARG_PARTIAL_BYTES
1156 #define TARGET_ARG_PARTIAL_BYTES rs6000_arg_partial_bytes
1157
1158 #undef TARGET_BUILD_BUILTIN_VA_LIST
1159 #define TARGET_BUILD_BUILTIN_VA_LIST rs6000_build_builtin_va_list
1160
1161 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
1162 #define TARGET_GIMPLIFY_VA_ARG_EXPR rs6000_gimplify_va_arg
1163
1164 #undef TARGET_EH_RETURN_FILTER_MODE
1165 #define TARGET_EH_RETURN_FILTER_MODE rs6000_eh_return_filter_mode
1166
1167 #undef TARGET_SCALAR_MODE_SUPPORTED_P
1168 #define TARGET_SCALAR_MODE_SUPPORTED_P rs6000_scalar_mode_supported_p
1169
1170 #undef TARGET_VECTOR_MODE_SUPPORTED_P
1171 #define TARGET_VECTOR_MODE_SUPPORTED_P rs6000_vector_mode_supported_p
1172
1173 #undef TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN
1174 #define TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN invalid_arg_for_unprototyped_fn
1175
1176 #undef TARGET_HANDLE_OPTION
1177 #define TARGET_HANDLE_OPTION rs6000_handle_option
1178
1179 #undef TARGET_DEFAULT_TARGET_FLAGS
1180 #define TARGET_DEFAULT_TARGET_FLAGS \
1181   (TARGET_DEFAULT)
1182
1183 #undef TARGET_STACK_PROTECT_FAIL
1184 #define TARGET_STACK_PROTECT_FAIL rs6000_stack_protect_fail
1185
1186 /* MPC604EUM 3.5.2 Weak Consistency between Multiple Processors
1187    The PowerPC architecture requires only weak consistency among
1188    processors--that is, memory accesses between processors need not be
1189    sequentially consistent and memory accesses among processors can occur
1190    in any order. The ability to order memory accesses weakly provides
1191    opportunities for more efficient use of the system bus. Unless a
1192    dependency exists, the 604e allows read operations to precede store
1193    operations.  */
1194 #undef TARGET_RELAXED_ORDERING
1195 #define TARGET_RELAXED_ORDERING true
1196
1197 #ifdef HAVE_AS_TLS
1198 #undef TARGET_ASM_OUTPUT_DWARF_DTPREL
1199 #define TARGET_ASM_OUTPUT_DWARF_DTPREL rs6000_output_dwarf_dtprel
1200 #endif
1201
1202 /* Use a 32-bit anchor range.  This leads to sequences like:
1203
1204         addis   tmp,anchor,high
1205         add     dest,tmp,low
1206
1207    where tmp itself acts as an anchor, and can be shared between
1208    accesses to the same 64k page.  */
1209 #undef TARGET_MIN_ANCHOR_OFFSET
1210 #define TARGET_MIN_ANCHOR_OFFSET -0x7fffffff - 1
1211 #undef TARGET_MAX_ANCHOR_OFFSET
1212 #define TARGET_MAX_ANCHOR_OFFSET 0x7fffffff
1213 #undef TARGET_USE_BLOCKS_FOR_CONSTANT_P
1214 #define TARGET_USE_BLOCKS_FOR_CONSTANT_P rs6000_use_blocks_for_constant_p
1215
1216 struct gcc_target targetm = TARGET_INITIALIZER;
1217 \f
1218
1219 /* Value is 1 if hard register REGNO can hold a value of machine-mode
1220    MODE.  */
1221 static int
1222 rs6000_hard_regno_mode_ok (int regno, enum machine_mode mode)
1223 {
1224   /* The GPRs can hold any mode, but values bigger than one register
1225      cannot go past R31.  */
1226   if (INT_REGNO_P (regno))
1227     return INT_REGNO_P (regno + HARD_REGNO_NREGS (regno, mode) - 1);
1228
1229   /* The float registers can only hold floating modes and DImode.
1230      This excludes the 32-bit decimal float mode for now.  */
1231   if (FP_REGNO_P (regno))
1232     return
1233       ((SCALAR_FLOAT_MODE_P (mode)
1234        && (mode != TDmode || (regno % 2) == 0)
1235        && mode != SDmode
1236        && FP_REGNO_P (regno + HARD_REGNO_NREGS (regno, mode) - 1))
1237       || (GET_MODE_CLASS (mode) == MODE_INT
1238           && GET_MODE_SIZE (mode) == UNITS_PER_FP_WORD)
1239       || (PAIRED_SIMD_REGNO_P (regno) && TARGET_PAIRED_FLOAT
1240            && PAIRED_VECTOR_MODE (mode)));
1241
1242   /* The CR register can only hold CC modes.  */
1243   if (CR_REGNO_P (regno))
1244     return GET_MODE_CLASS (mode) == MODE_CC;
1245
1246   if (XER_REGNO_P (regno))
1247     return mode == PSImode;
1248
1249   /* AltiVec only in AldyVec registers.  */
1250   if (ALTIVEC_REGNO_P (regno))
1251     return ALTIVEC_VECTOR_MODE (mode);
1252
1253   /* ...but GPRs can hold SIMD data on the SPE in one register.  */
1254   if (SPE_SIMD_REGNO_P (regno) && TARGET_SPE && SPE_VECTOR_MODE (mode))
1255     return 1;
1256
1257   /* We cannot put TImode anywhere except general register and it must be
1258      able to fit within the register set.  */
1259
1260   return GET_MODE_SIZE (mode) <= UNITS_PER_WORD;
1261 }
1262
1263 /* Initialize rs6000_hard_regno_mode_ok_p table.  */
1264 static void
1265 rs6000_init_hard_regno_mode_ok (void)
1266 {
1267   int r, m;
1268
1269   for (r = 0; r < FIRST_PSEUDO_REGISTER; ++r)
1270     for (m = 0; m < NUM_MACHINE_MODES; ++m)
1271       if (rs6000_hard_regno_mode_ok (r, m))
1272         rs6000_hard_regno_mode_ok_p[m][r] = true;
1273 }
1274
1275 #if TARGET_MACHO
1276 /* The Darwin version of SUBTARGET_OVERRIDE_OPTIONS.  */
1277
1278 static void
1279 darwin_rs6000_override_options (void)
1280 {
1281   /* The Darwin ABI always includes AltiVec, can't be (validly) turned
1282      off.  */
1283   rs6000_altivec_abi = 1;
1284   TARGET_ALTIVEC_VRSAVE = 1;
1285   if (DEFAULT_ABI == ABI_DARWIN)
1286   {
1287     if (MACHO_DYNAMIC_NO_PIC_P)
1288       {
1289         if (flag_pic)
1290             warning (0, "-mdynamic-no-pic overrides -fpic or -fPIC");
1291         flag_pic = 0;
1292       }
1293     else if (flag_pic == 1)
1294       {
1295         flag_pic = 2;
1296       }
1297   }
1298   if (TARGET_64BIT && ! TARGET_POWERPC64)
1299     {
1300       target_flags |= MASK_POWERPC64;
1301       warning (0, "-m64 requires PowerPC64 architecture, enabling");
1302     }
1303   if (flag_mkernel)
1304     {
1305       rs6000_default_long_calls = 1;
1306       target_flags |= MASK_SOFT_FLOAT;
1307     }
1308
1309   /* Make -m64 imply -maltivec.  Darwin's 64-bit ABI includes
1310      Altivec.  */
1311   if (!flag_mkernel && !flag_apple_kext
1312       && TARGET_64BIT
1313       && ! (target_flags_explicit & MASK_ALTIVEC))
1314     target_flags |= MASK_ALTIVEC;
1315
1316   /* Unless the user (not the configurer) has explicitly overridden
1317      it with -mcpu=G3 or -mno-altivec, then 10.5+ targets default to
1318      G4 unless targetting the kernel.  */
1319   if (!flag_mkernel
1320       && !flag_apple_kext
1321       && strverscmp (darwin_macosx_version_min, "10.5") >= 0
1322       && ! (target_flags_explicit & MASK_ALTIVEC)
1323       && ! rs6000_select[1].string)
1324     {
1325       target_flags |= MASK_ALTIVEC;
1326     }
1327 }
1328 #endif
1329
1330 /* If not otherwise specified by a target, make 'long double' equivalent to
1331    'double'.  */
1332
1333 #ifndef RS6000_DEFAULT_LONG_DOUBLE_SIZE
1334 #define RS6000_DEFAULT_LONG_DOUBLE_SIZE 64
1335 #endif
1336
1337 /* Override command line options.  Mostly we process the processor
1338    type and sometimes adjust other TARGET_ options.  */
1339
1340 void
1341 rs6000_override_options (const char *default_cpu)
1342 {
1343   size_t i, j;
1344   struct rs6000_cpu_select *ptr;
1345   int set_masks;
1346
1347   /* Simplifications for entries below.  */
1348
1349   enum {
1350     POWERPC_BASE_MASK = MASK_POWERPC | MASK_NEW_MNEMONICS,
1351     POWERPC_7400_MASK = POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_ALTIVEC
1352   };
1353
1354   /* This table occasionally claims that a processor does not support
1355      a particular feature even though it does, but the feature is slower
1356      than the alternative.  Thus, it shouldn't be relied on as a
1357      complete description of the processor's support.
1358
1359      Please keep this list in order, and don't forget to update the
1360      documentation in invoke.texi when adding a new processor or
1361      flag.  */
1362   static struct ptt
1363     {
1364       const char *const name;           /* Canonical processor name.  */
1365       const enum processor_type processor; /* Processor type enum value.  */
1366       const int target_enable;  /* Target flags to enable.  */
1367     } const processor_target_table[]
1368       = {{"401", PROCESSOR_PPC403, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1369          {"403", PROCESSOR_PPC403,
1370           POWERPC_BASE_MASK | MASK_SOFT_FLOAT | MASK_STRICT_ALIGN},
1371          {"405", PROCESSOR_PPC405,
1372           POWERPC_BASE_MASK | MASK_SOFT_FLOAT | MASK_MULHW | MASK_DLMZB},
1373          {"405fp", PROCESSOR_PPC405,
1374           POWERPC_BASE_MASK | MASK_MULHW | MASK_DLMZB},
1375          {"440", PROCESSOR_PPC440,
1376           POWERPC_BASE_MASK | MASK_SOFT_FLOAT | MASK_MULHW | MASK_DLMZB},
1377          {"440fp", PROCESSOR_PPC440,
1378           POWERPC_BASE_MASK | MASK_MULHW | MASK_DLMZB},
1379          {"505", PROCESSOR_MPCCORE, POWERPC_BASE_MASK},
1380          {"601", PROCESSOR_PPC601,
1381           MASK_POWER | POWERPC_BASE_MASK | MASK_MULTIPLE | MASK_STRING},
1382          {"602", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1383          {"603", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1384          {"603e", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1385          {"604", PROCESSOR_PPC604, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1386          {"604e", PROCESSOR_PPC604e, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1387          {"620", PROCESSOR_PPC620,
1388           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
1389          {"630", PROCESSOR_PPC630,
1390           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
1391          {"740", PROCESSOR_PPC750, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1392          {"7400", PROCESSOR_PPC7400, POWERPC_7400_MASK},
1393          {"7450", PROCESSOR_PPC7450, POWERPC_7400_MASK},
1394          {"750", PROCESSOR_PPC750, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1395          {"801", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1396          {"821", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1397          {"823", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1398          {"8540", PROCESSOR_PPC8540, POWERPC_BASE_MASK | MASK_STRICT_ALIGN},
1399          /* 8548 has a dummy entry for now.  */
1400          {"8548", PROCESSOR_PPC8540, POWERPC_BASE_MASK | MASK_STRICT_ALIGN},
1401          {"860", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1402          {"970", PROCESSOR_POWER4,
1403           POWERPC_7400_MASK | MASK_PPC_GPOPT | MASK_MFCRF | MASK_POWERPC64},
1404          {"cell", PROCESSOR_CELL,
1405           POWERPC_7400_MASK  | MASK_PPC_GPOPT | MASK_MFCRF | MASK_POWERPC64},
1406          {"common", PROCESSOR_COMMON, MASK_NEW_MNEMONICS},
1407          {"ec603e", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1408          {"G3", PROCESSOR_PPC750, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1409          {"G4",  PROCESSOR_PPC7450, POWERPC_7400_MASK},
1410          {"G5", PROCESSOR_POWER4,
1411           POWERPC_7400_MASK | MASK_PPC_GPOPT | MASK_MFCRF | MASK_POWERPC64},
1412          {"power", PROCESSOR_POWER, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
1413          {"power2", PROCESSOR_POWER,
1414           MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING},
1415          {"power3", PROCESSOR_PPC630,
1416           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
1417          {"power4", PROCESSOR_POWER4,
1418           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_MFCRF | MASK_POWERPC64},
1419          {"power5", PROCESSOR_POWER5,
1420           POWERPC_BASE_MASK | MASK_POWERPC64 | MASK_PPC_GFXOPT
1421           | MASK_MFCRF | MASK_POPCNTB},
1422          {"power5+", PROCESSOR_POWER5,
1423           POWERPC_BASE_MASK | MASK_POWERPC64 | MASK_PPC_GFXOPT
1424           | MASK_MFCRF | MASK_POPCNTB | MASK_FPRND},
1425          {"power6", PROCESSOR_POWER6,
1426           POWERPC_7400_MASK | MASK_POWERPC64 | MASK_MFCRF | MASK_POPCNTB
1427           | MASK_FPRND | MASK_CMPB | MASK_DFP },
1428          {"power6x", PROCESSOR_POWER6,
1429           POWERPC_7400_MASK | MASK_POWERPC64 | MASK_MFCRF | MASK_POPCNTB
1430           | MASK_FPRND | MASK_CMPB | MASK_MFPGPR | MASK_DFP },
1431          {"powerpc", PROCESSOR_POWERPC, POWERPC_BASE_MASK},
1432          {"powerpc64", PROCESSOR_POWERPC64,
1433           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
1434          {"rios", PROCESSOR_RIOS1, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
1435          {"rios1", PROCESSOR_RIOS1, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
1436          {"rios2", PROCESSOR_RIOS2,
1437           MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING},
1438          {"rsc", PROCESSOR_PPC601, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
1439          {"rsc1", PROCESSOR_PPC601, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
1440          {"rs64", PROCESSOR_RS64A,
1441           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64}
1442       };
1443
1444   const size_t ptt_size = ARRAY_SIZE (processor_target_table);
1445
1446   /* Some OSs don't support saving the high part of 64-bit registers on
1447      context switch.  Other OSs don't support saving Altivec registers.
1448      On those OSs, we don't touch the MASK_POWERPC64 or MASK_ALTIVEC
1449      settings; if the user wants either, the user must explicitly specify
1450      them and we won't interfere with the user's specification.  */
1451
1452   enum {
1453     POWER_MASKS = MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING,
1454     POWERPC_MASKS = (POWERPC_BASE_MASK | MASK_PPC_GPOPT | MASK_STRICT_ALIGN
1455                      | MASK_PPC_GFXOPT | MASK_POWERPC64 | MASK_ALTIVEC
1456                      | MASK_MFCRF | MASK_POPCNTB | MASK_FPRND | MASK_MULHW
1457                      | MASK_DLMZB | MASK_CMPB | MASK_MFPGPR | MASK_DFP)
1458   };
1459
1460   rs6000_init_hard_regno_mode_ok ();
1461
1462   set_masks = POWER_MASKS | POWERPC_MASKS | MASK_SOFT_FLOAT;
1463 #ifdef OS_MISSING_POWERPC64
1464   if (OS_MISSING_POWERPC64)
1465     set_masks &= ~MASK_POWERPC64;
1466 #endif
1467 #ifdef OS_MISSING_ALTIVEC
1468   if (OS_MISSING_ALTIVEC)
1469     set_masks &= ~MASK_ALTIVEC;
1470 #endif
1471
1472   /* Don't override by the processor default if given explicitly.  */
1473   set_masks &= ~target_flags_explicit;
1474
1475   /* Identify the processor type.  */
1476   rs6000_select[0].string = default_cpu;
1477   rs6000_cpu = TARGET_POWERPC64 ? PROCESSOR_DEFAULT64 : PROCESSOR_DEFAULT;
1478
1479   for (i = 0; i < ARRAY_SIZE (rs6000_select); i++)
1480     {
1481       ptr = &rs6000_select[i];
1482       if (ptr->string != (char *)0 && ptr->string[0] != '\0')
1483         {
1484           for (j = 0; j < ptt_size; j++)
1485             if (! strcmp (ptr->string, processor_target_table[j].name))
1486               {
1487                 if (ptr->set_tune_p)
1488                   rs6000_cpu = processor_target_table[j].processor;
1489
1490                 if (ptr->set_arch_p)
1491                   {
1492                     target_flags &= ~set_masks;
1493                     target_flags |= (processor_target_table[j].target_enable
1494                                      & set_masks);
1495                   }
1496                 break;
1497               }
1498
1499           if (j == ptt_size)
1500             error ("bad value (%s) for %s switch", ptr->string, ptr->name);
1501         }
1502     }
1503
1504   if (TARGET_E500)
1505     rs6000_isel = 1;
1506
1507   /* If we are optimizing big endian systems for space, use the load/store
1508      multiple and string instructions.  */
1509   if (BYTES_BIG_ENDIAN && optimize_size)
1510     target_flags |= ~target_flags_explicit & (MASK_MULTIPLE | MASK_STRING);
1511
1512   /* Don't allow -mmultiple or -mstring on little endian systems
1513      unless the cpu is a 750, because the hardware doesn't support the
1514      instructions used in little endian mode, and causes an alignment
1515      trap.  The 750 does not cause an alignment trap (except when the
1516      target is unaligned).  */
1517
1518   if (!BYTES_BIG_ENDIAN && rs6000_cpu != PROCESSOR_PPC750)
1519     {
1520       if (TARGET_MULTIPLE)
1521         {
1522           target_flags &= ~MASK_MULTIPLE;
1523           if ((target_flags_explicit & MASK_MULTIPLE) != 0)
1524             warning (0, "-mmultiple is not supported on little endian systems");
1525         }
1526
1527       if (TARGET_STRING)
1528         {
1529           target_flags &= ~MASK_STRING;
1530           if ((target_flags_explicit & MASK_STRING) != 0)
1531             warning (0, "-mstring is not supported on little endian systems");
1532         }
1533     }
1534
1535   /* Set debug flags */
1536   if (rs6000_debug_name)
1537     {
1538       if (! strcmp (rs6000_debug_name, "all"))
1539         rs6000_debug_stack = rs6000_debug_arg = 1;
1540       else if (! strcmp (rs6000_debug_name, "stack"))
1541         rs6000_debug_stack = 1;
1542       else if (! strcmp (rs6000_debug_name, "arg"))
1543         rs6000_debug_arg = 1;
1544       else
1545         error ("unknown -mdebug-%s switch", rs6000_debug_name);
1546     }
1547
1548   if (rs6000_traceback_name)
1549     {
1550       if (! strncmp (rs6000_traceback_name, "full", 4))
1551         rs6000_traceback = traceback_full;
1552       else if (! strncmp (rs6000_traceback_name, "part", 4))
1553         rs6000_traceback = traceback_part;
1554       else if (! strncmp (rs6000_traceback_name, "no", 2))
1555         rs6000_traceback = traceback_none;
1556       else
1557         error ("unknown -mtraceback arg %qs; expecting %<full%>, %<partial%> or %<none%>",
1558                rs6000_traceback_name);
1559     }
1560
1561   if (!rs6000_explicit_options.long_double)
1562     rs6000_long_double_type_size = RS6000_DEFAULT_LONG_DOUBLE_SIZE;
1563
1564 #ifndef POWERPC_LINUX
1565   if (!rs6000_explicit_options.ieee)
1566     rs6000_ieeequad = 1;
1567 #endif
1568
1569   /* Set Altivec ABI as default for powerpc64 linux.  */
1570   if (TARGET_ELF && TARGET_64BIT)
1571     {
1572       rs6000_altivec_abi = 1;
1573       TARGET_ALTIVEC_VRSAVE = 1;
1574     }
1575
1576   /* Set the Darwin64 ABI as default for 64-bit Darwin.  */
1577   if (DEFAULT_ABI == ABI_DARWIN && TARGET_64BIT)
1578     {
1579       rs6000_darwin64_abi = 1;
1580 #if TARGET_MACHO
1581       darwin_one_byte_bool = 1;
1582 #endif
1583       /* Default to natural alignment, for better performance.  */
1584       rs6000_alignment_flags = MASK_ALIGN_NATURAL;
1585     }
1586
1587   /* Place FP constants in the constant pool instead of TOC
1588      if section anchors enabled.  */
1589   if (flag_section_anchors)
1590     TARGET_NO_FP_IN_TOC = 1;
1591
1592   /* Handle -mtls-size option.  */
1593   rs6000_parse_tls_size_option ();
1594
1595 #ifdef SUBTARGET_OVERRIDE_OPTIONS
1596   SUBTARGET_OVERRIDE_OPTIONS;
1597 #endif
1598 #ifdef SUBSUBTARGET_OVERRIDE_OPTIONS
1599   SUBSUBTARGET_OVERRIDE_OPTIONS;
1600 #endif
1601 #ifdef SUB3TARGET_OVERRIDE_OPTIONS
1602   SUB3TARGET_OVERRIDE_OPTIONS;
1603 #endif
1604
1605   if (TARGET_E500)
1606     {
1607       /* The e500 does not have string instructions, and we set
1608          MASK_STRING above when optimizing for size.  */
1609       if ((target_flags & MASK_STRING) != 0)
1610         target_flags = target_flags & ~MASK_STRING;
1611     }
1612   else if (rs6000_select[1].string != NULL)
1613     {
1614       /* For the powerpc-eabispe configuration, we set all these by
1615          default, so let's unset them if we manually set another
1616          CPU that is not the E500.  */
1617       if (!rs6000_explicit_options.abi)
1618         rs6000_spe_abi = 0;
1619       if (!rs6000_explicit_options.spe)
1620         rs6000_spe = 0;
1621       if (!rs6000_explicit_options.float_gprs)
1622         rs6000_float_gprs = 0;
1623       if (!rs6000_explicit_options.isel)
1624         rs6000_isel = 0;
1625     }
1626
1627   /* Detect invalid option combinations with E500.  */
1628   CHECK_E500_OPTIONS;
1629
1630   rs6000_always_hint = (rs6000_cpu != PROCESSOR_POWER4
1631                         && rs6000_cpu != PROCESSOR_POWER5
1632                         && rs6000_cpu != PROCESSOR_POWER6
1633                         && rs6000_cpu != PROCESSOR_CELL);
1634   rs6000_sched_groups = (rs6000_cpu == PROCESSOR_POWER4
1635                          || rs6000_cpu == PROCESSOR_POWER5);
1636   rs6000_align_branch_targets = (rs6000_cpu == PROCESSOR_POWER4
1637                                  || rs6000_cpu == PROCESSOR_POWER5
1638                                  || rs6000_cpu == PROCESSOR_POWER6);
1639
1640   rs6000_sched_restricted_insns_priority
1641     = (rs6000_sched_groups ? 1 : 0);
1642
1643   /* Handle -msched-costly-dep option.  */
1644   rs6000_sched_costly_dep
1645     = (rs6000_sched_groups ? store_to_load_dep_costly : no_dep_costly);
1646
1647   if (rs6000_sched_costly_dep_str)
1648     {
1649       if (! strcmp (rs6000_sched_costly_dep_str, "no"))
1650         rs6000_sched_costly_dep = no_dep_costly;
1651       else if (! strcmp (rs6000_sched_costly_dep_str, "all"))
1652         rs6000_sched_costly_dep = all_deps_costly;
1653       else if (! strcmp (rs6000_sched_costly_dep_str, "true_store_to_load"))
1654         rs6000_sched_costly_dep = true_store_to_load_dep_costly;
1655       else if (! strcmp (rs6000_sched_costly_dep_str, "store_to_load"))
1656         rs6000_sched_costly_dep = store_to_load_dep_costly;
1657       else
1658         rs6000_sched_costly_dep = atoi (rs6000_sched_costly_dep_str);
1659     }
1660
1661   /* Handle -minsert-sched-nops option.  */
1662   rs6000_sched_insert_nops
1663     = (rs6000_sched_groups ? sched_finish_regroup_exact : sched_finish_none);
1664
1665   if (rs6000_sched_insert_nops_str)
1666     {
1667       if (! strcmp (rs6000_sched_insert_nops_str, "no"))
1668         rs6000_sched_insert_nops = sched_finish_none;
1669       else if (! strcmp (rs6000_sched_insert_nops_str, "pad"))
1670         rs6000_sched_insert_nops = sched_finish_pad_groups;
1671       else if (! strcmp (rs6000_sched_insert_nops_str, "regroup_exact"))
1672         rs6000_sched_insert_nops = sched_finish_regroup_exact;
1673       else
1674         rs6000_sched_insert_nops = atoi (rs6000_sched_insert_nops_str);
1675     }
1676
1677 #ifdef TARGET_REGNAMES
1678   /* If the user desires alternate register names, copy in the
1679      alternate names now.  */
1680   if (TARGET_REGNAMES)
1681     memcpy (rs6000_reg_names, alt_reg_names, sizeof (rs6000_reg_names));
1682 #endif
1683
1684   /* Set aix_struct_return last, after the ABI is determined.
1685      If -maix-struct-return or -msvr4-struct-return was explicitly
1686      used, don't override with the ABI default.  */
1687   if (!rs6000_explicit_options.aix_struct_ret)
1688     aix_struct_return = (DEFAULT_ABI != ABI_V4 || DRAFT_V4_STRUCT_RET);
1689
1690   if (TARGET_LONG_DOUBLE_128 && !TARGET_IEEEQUAD)
1691     REAL_MODE_FORMAT (TFmode) = &ibm_extended_format;
1692
1693   if (TARGET_TOC)
1694     ASM_GENERATE_INTERNAL_LABEL (toc_label_name, "LCTOC", 1);
1695
1696   /* We can only guarantee the availability of DI pseudo-ops when
1697      assembling for 64-bit targets.  */
1698   if (!TARGET_64BIT)
1699     {
1700       targetm.asm_out.aligned_op.di = NULL;
1701       targetm.asm_out.unaligned_op.di = NULL;
1702     }
1703
1704   /* Set branch target alignment, if not optimizing for size.  */
1705   if (!optimize_size)
1706     {
1707       /* Cell wants to be aligned 8byte for dual issue. */
1708       if (rs6000_cpu == PROCESSOR_CELL)
1709         {
1710           if (align_functions <= 0)
1711             align_functions = 8;
1712           if (align_jumps <= 0)
1713             align_jumps = 8;
1714           if (align_loops <= 0)
1715             align_loops = 8;
1716         }
1717       if (rs6000_align_branch_targets)
1718         {
1719           if (align_functions <= 0)
1720             align_functions = 16;
1721           if (align_jumps <= 0)
1722             align_jumps = 16;
1723           if (align_loops <= 0)
1724             align_loops = 16;
1725         }
1726       if (align_jumps_max_skip <= 0)
1727         align_jumps_max_skip = 15;
1728       if (align_loops_max_skip <= 0)
1729         align_loops_max_skip = 15;
1730     }
1731
1732   /* Arrange to save and restore machine status around nested functions.  */
1733   init_machine_status = rs6000_init_machine_status;
1734
1735   /* We should always be splitting complex arguments, but we can't break
1736      Linux and Darwin ABIs at the moment.  For now, only AIX is fixed.  */
1737   if (DEFAULT_ABI != ABI_AIX)
1738     targetm.calls.split_complex_arg = NULL;
1739
1740   /* Initialize rs6000_cost with the appropriate target costs.  */
1741   if (optimize_size)
1742     rs6000_cost = TARGET_POWERPC64 ? &size64_cost : &size32_cost;
1743   else
1744     switch (rs6000_cpu)
1745       {
1746       case PROCESSOR_RIOS1:
1747         rs6000_cost = &rios1_cost;
1748         break;
1749
1750       case PROCESSOR_RIOS2:
1751         rs6000_cost = &rios2_cost;
1752         break;
1753
1754       case PROCESSOR_RS64A:
1755         rs6000_cost = &rs64a_cost;
1756         break;
1757
1758       case PROCESSOR_MPCCORE:
1759         rs6000_cost = &mpccore_cost;
1760         break;
1761
1762       case PROCESSOR_PPC403:
1763         rs6000_cost = &ppc403_cost;
1764         break;
1765
1766       case PROCESSOR_PPC405:
1767         rs6000_cost = &ppc405_cost;
1768         break;
1769
1770       case PROCESSOR_PPC440:
1771         rs6000_cost = &ppc440_cost;
1772         break;
1773
1774       case PROCESSOR_PPC601:
1775         rs6000_cost = &ppc601_cost;
1776         break;
1777
1778       case PROCESSOR_PPC603:
1779         rs6000_cost = &ppc603_cost;
1780         break;
1781
1782       case PROCESSOR_PPC604:
1783         rs6000_cost = &ppc604_cost;
1784         break;
1785
1786       case PROCESSOR_PPC604e:
1787         rs6000_cost = &ppc604e_cost;
1788         break;
1789
1790       case PROCESSOR_PPC620:
1791         rs6000_cost = &ppc620_cost;
1792         break;
1793
1794       case PROCESSOR_PPC630:
1795         rs6000_cost = &ppc630_cost;
1796         break;
1797
1798       case PROCESSOR_CELL:
1799         rs6000_cost = &ppccell_cost;
1800         break;
1801
1802       case PROCESSOR_PPC750:
1803       case PROCESSOR_PPC7400:
1804         rs6000_cost = &ppc750_cost;
1805         break;
1806
1807       case PROCESSOR_PPC7450:
1808         rs6000_cost = &ppc7450_cost;
1809         break;
1810
1811       case PROCESSOR_PPC8540:
1812         rs6000_cost = &ppc8540_cost;
1813         break;
1814
1815       case PROCESSOR_POWER4:
1816       case PROCESSOR_POWER5:
1817         rs6000_cost = &power4_cost;
1818         break;
1819
1820       case PROCESSOR_POWER6:
1821         rs6000_cost = &power6_cost;
1822         break;
1823
1824       default:
1825         gcc_unreachable ();
1826       }
1827
1828   if (!PARAM_SET_P (PARAM_SIMULTANEOUS_PREFETCHES))
1829     set_param_value ("simultaneous-prefetches",
1830                      rs6000_cost->simultaneous_prefetches);
1831   if (!PARAM_SET_P (PARAM_L1_CACHE_SIZE))
1832     set_param_value ("l1-cache-size", rs6000_cost->l1_cache_size);
1833   if (!PARAM_SET_P (PARAM_L1_CACHE_LINE_SIZE))
1834     set_param_value ("l1-cache-line-size", rs6000_cost->cache_line_size);
1835   if (!PARAM_SET_P (PARAM_L2_CACHE_SIZE))
1836     set_param_value ("l2-cache-size", rs6000_cost->l2_cache_size);
1837 }
1838
1839 /* Implement targetm.vectorize.builtin_mask_for_load.  */
1840 static tree
1841 rs6000_builtin_mask_for_load (void)
1842 {
1843   if (TARGET_ALTIVEC)
1844     return altivec_builtin_mask_for_load;
1845   else
1846     return 0;
1847 }
1848
1849 /* Implement targetm.vectorize.builtin_conversion.  */
1850 static tree
1851 rs6000_builtin_conversion (enum tree_code code, tree type)
1852 {
1853   if (!TARGET_ALTIVEC)
1854     return NULL_TREE;
1855
1856   switch (code)
1857     {
1858     case FLOAT_EXPR:
1859       switch (TYPE_MODE (type))
1860         {
1861         case V4SImode:
1862           return TYPE_UNSIGNED (type) ?
1863             rs6000_builtin_decls[ALTIVEC_BUILTIN_VCFUX] :
1864             rs6000_builtin_decls[ALTIVEC_BUILTIN_VCFSX];
1865         default:
1866           return NULL_TREE;
1867         }
1868     default:
1869       return NULL_TREE;
1870     }
1871 }
1872
1873 /* Implement targetm.vectorize.builtin_mul_widen_even.  */
1874 static tree
1875 rs6000_builtin_mul_widen_even (tree type)
1876 {
1877   if (!TARGET_ALTIVEC)
1878     return NULL_TREE;
1879
1880   switch (TYPE_MODE (type))
1881     {
1882     case V8HImode:
1883       return TYPE_UNSIGNED (type) ?
1884             rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULEUH] :
1885             rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULESH];
1886
1887     case V16QImode:
1888       return TYPE_UNSIGNED (type) ?
1889             rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULEUB] :
1890             rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULESB];
1891     default:
1892       return NULL_TREE;
1893     }
1894 }
1895
1896 /* Implement targetm.vectorize.builtin_mul_widen_odd.  */
1897 static tree
1898 rs6000_builtin_mul_widen_odd (tree type)
1899 {
1900   if (!TARGET_ALTIVEC)
1901     return NULL_TREE;
1902
1903   switch (TYPE_MODE (type))
1904     {
1905     case V8HImode:
1906       return TYPE_UNSIGNED (type) ?
1907             rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOUH] :
1908             rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOSH];
1909
1910     case V16QImode:
1911       return TYPE_UNSIGNED (type) ?
1912             rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOUB] :
1913             rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOSB];
1914     default:
1915       return NULL_TREE;
1916     }
1917 }
1918
1919
1920 /* Return true iff, data reference of TYPE can reach vector alignment (16)
1921    after applying N number of iterations.  This routine does not determine
1922    how may iterations are required to reach desired alignment.  */
1923
1924 static bool
1925 rs6000_vector_alignment_reachable (const_tree type ATTRIBUTE_UNUSED, bool is_packed)
1926 {
1927   if (is_packed)
1928     return false;
1929
1930   if (TARGET_32BIT)
1931     {
1932       if (rs6000_alignment_flags == MASK_ALIGN_NATURAL)
1933         return true;
1934
1935       if (rs6000_alignment_flags ==  MASK_ALIGN_POWER)
1936         return true;
1937
1938       return false;
1939     }
1940   else
1941     {
1942       if (TARGET_MACHO)
1943         return false;
1944
1945       /* Assuming that all other types are naturally aligned. CHECKME!  */
1946       return true;
1947     }
1948 }
1949
1950 /* Handle generic options of the form -mfoo=yes/no.
1951    NAME is the option name.
1952    VALUE is the option value.
1953    FLAG is the pointer to the flag where to store a 1 or 0, depending on
1954    whether the option value is 'yes' or 'no' respectively.  */
1955 static void
1956 rs6000_parse_yes_no_option (const char *name, const char *value, int *flag)
1957 {
1958   if (value == 0)
1959     return;
1960   else if (!strcmp (value, "yes"))
1961     *flag = 1;
1962   else if (!strcmp (value, "no"))
1963     *flag = 0;
1964   else
1965     error ("unknown -m%s= option specified: '%s'", name, value);
1966 }
1967
1968 /* Validate and record the size specified with the -mtls-size option.  */
1969
1970 static void
1971 rs6000_parse_tls_size_option (void)
1972 {
1973   if (rs6000_tls_size_string == 0)
1974     return;
1975   else if (strcmp (rs6000_tls_size_string, "16") == 0)
1976     rs6000_tls_size = 16;
1977   else if (strcmp (rs6000_tls_size_string, "32") == 0)
1978     rs6000_tls_size = 32;
1979   else if (strcmp (rs6000_tls_size_string, "64") == 0)
1980     rs6000_tls_size = 64;
1981   else
1982     error ("bad value %qs for -mtls-size switch", rs6000_tls_size_string);
1983 }
1984
1985 void
1986 optimization_options (int level ATTRIBUTE_UNUSED, int size ATTRIBUTE_UNUSED)
1987 {
1988   if (DEFAULT_ABI == ABI_DARWIN)
1989     /* The Darwin libraries never set errno, so we might as well
1990        avoid calling them when that's the only reason we would.  */
1991     flag_errno_math = 0;
1992
1993   /* Double growth factor to counter reduced min jump length.  */
1994   set_param_value ("max-grow-copy-bb-insns", 16);
1995
1996   /* Enable section anchors by default.
1997      Skip section anchors for Objective C and Objective C++
1998      until front-ends fixed.  */
1999   if (!TARGET_MACHO && lang_hooks.name[4] != 'O')
2000     flag_section_anchors = 1;
2001 }
2002
2003 /* Implement TARGET_HANDLE_OPTION.  */
2004
2005 static bool
2006 rs6000_handle_option (size_t code, const char *arg, int value)
2007 {
2008   switch (code)
2009     {
2010     case OPT_mno_power:
2011       target_flags &= ~(MASK_POWER | MASK_POWER2
2012                         | MASK_MULTIPLE | MASK_STRING);
2013       target_flags_explicit |= (MASK_POWER | MASK_POWER2
2014                                 | MASK_MULTIPLE | MASK_STRING);
2015       break;
2016     case OPT_mno_powerpc:
2017       target_flags &= ~(MASK_POWERPC | MASK_PPC_GPOPT
2018                         | MASK_PPC_GFXOPT | MASK_POWERPC64);
2019       target_flags_explicit |= (MASK_POWERPC | MASK_PPC_GPOPT
2020                                 | MASK_PPC_GFXOPT | MASK_POWERPC64);
2021       break;
2022     case OPT_mfull_toc:
2023       target_flags &= ~MASK_MINIMAL_TOC;
2024       TARGET_NO_FP_IN_TOC = 0;
2025       TARGET_NO_SUM_IN_TOC = 0;
2026       target_flags_explicit |= MASK_MINIMAL_TOC;
2027 #ifdef TARGET_USES_SYSV4_OPT
2028       /* Note, V.4 no longer uses a normal TOC, so make -mfull-toc, be
2029          just the same as -mminimal-toc.  */
2030       target_flags |= MASK_MINIMAL_TOC;
2031       target_flags_explicit |= MASK_MINIMAL_TOC;
2032 #endif
2033       break;
2034
2035 #ifdef TARGET_USES_SYSV4_OPT
2036     case OPT_mtoc:
2037       /* Make -mtoc behave like -mminimal-toc.  */
2038       target_flags |= MASK_MINIMAL_TOC;
2039       target_flags_explicit |= MASK_MINIMAL_TOC;
2040       break;
2041 #endif
2042
2043 #ifdef TARGET_USES_AIX64_OPT
2044     case OPT_maix64:
2045 #else
2046     case OPT_m64:
2047 #endif
2048       target_flags |= MASK_POWERPC64 | MASK_POWERPC;
2049       target_flags |= ~target_flags_explicit & MASK_PPC_GFXOPT;
2050       target_flags_explicit |= MASK_POWERPC64 | MASK_POWERPC;
2051       break;
2052
2053 #ifdef TARGET_USES_AIX64_OPT
2054     case OPT_maix32:
2055 #else
2056     case OPT_m32:
2057 #endif
2058       target_flags &= ~MASK_POWERPC64;
2059       target_flags_explicit |= MASK_POWERPC64;
2060       break;
2061
2062     case OPT_minsert_sched_nops_:
2063       rs6000_sched_insert_nops_str = arg;
2064       break;
2065
2066     case OPT_mminimal_toc:
2067       if (value == 1)
2068         {
2069           TARGET_NO_FP_IN_TOC = 0;
2070           TARGET_NO_SUM_IN_TOC = 0;
2071         }
2072       break;
2073
2074     case OPT_mpower:
2075       if (value == 1)
2076         {
2077           target_flags |= (MASK_MULTIPLE | MASK_STRING);
2078           target_flags_explicit |= (MASK_MULTIPLE | MASK_STRING);
2079         }
2080       break;
2081
2082     case OPT_mpower2:
2083       if (value == 1)
2084         {
2085           target_flags |= (MASK_POWER | MASK_MULTIPLE | MASK_STRING);
2086           target_flags_explicit |= (MASK_POWER | MASK_MULTIPLE | MASK_STRING);
2087         }
2088       break;
2089
2090     case OPT_mpowerpc_gpopt:
2091     case OPT_mpowerpc_gfxopt:
2092       if (value == 1)
2093         {
2094           target_flags |= MASK_POWERPC;
2095           target_flags_explicit |= MASK_POWERPC;
2096         }
2097       break;
2098
2099     case OPT_maix_struct_return:
2100     case OPT_msvr4_struct_return:
2101       rs6000_explicit_options.aix_struct_ret = true;
2102       break;
2103
2104     case OPT_mvrsave_:
2105       rs6000_parse_yes_no_option ("vrsave", arg, &(TARGET_ALTIVEC_VRSAVE));
2106       break;
2107
2108     case OPT_misel_:
2109       rs6000_explicit_options.isel = true;
2110       rs6000_parse_yes_no_option ("isel", arg, &(rs6000_isel));
2111       break;
2112
2113     case OPT_mspe_:
2114       rs6000_explicit_options.spe = true;
2115       rs6000_parse_yes_no_option ("spe", arg, &(rs6000_spe));
2116       break;
2117
2118     case OPT_mdebug_:
2119       rs6000_debug_name = arg;
2120       break;
2121
2122 #ifdef TARGET_USES_SYSV4_OPT
2123     case OPT_mcall_:
2124       rs6000_abi_name = arg;
2125       break;
2126
2127     case OPT_msdata_:
2128       rs6000_sdata_name = arg;
2129       break;
2130
2131     case OPT_mtls_size_:
2132       rs6000_tls_size_string = arg;
2133       break;
2134
2135     case OPT_mrelocatable:
2136       if (value == 1)
2137         {
2138           target_flags |= MASK_MINIMAL_TOC;
2139           target_flags_explicit |= MASK_MINIMAL_TOC;
2140           TARGET_NO_FP_IN_TOC = 1;
2141         }
2142       break;
2143
2144     case OPT_mrelocatable_lib:
2145       if (value == 1)
2146         {
2147           target_flags |= MASK_RELOCATABLE | MASK_MINIMAL_TOC;
2148           target_flags_explicit |= MASK_RELOCATABLE | MASK_MINIMAL_TOC;
2149           TARGET_NO_FP_IN_TOC = 1;
2150         }
2151       else
2152         {
2153           target_flags &= ~MASK_RELOCATABLE;
2154           target_flags_explicit |= MASK_RELOCATABLE;
2155         }
2156       break;
2157 #endif
2158
2159     case OPT_mabi_:
2160       if (!strcmp (arg, "altivec"))
2161         {
2162           rs6000_explicit_options.abi = true;
2163           rs6000_altivec_abi = 1;
2164           rs6000_spe_abi = 0;
2165         }
2166       else if (! strcmp (arg, "no-altivec"))
2167         {
2168           /* ??? Don't set rs6000_explicit_options.abi here, to allow
2169              the default for rs6000_spe_abi to be chosen later.  */
2170           rs6000_altivec_abi = 0;
2171         }
2172       else if (! strcmp (arg, "spe"))
2173         {
2174           rs6000_explicit_options.abi = true;
2175           rs6000_spe_abi = 1;
2176           rs6000_altivec_abi = 0;
2177           if (!TARGET_SPE_ABI)
2178             error ("not configured for ABI: '%s'", arg);
2179         }
2180       else if (! strcmp (arg, "no-spe"))
2181         {
2182           rs6000_explicit_options.abi = true;
2183           rs6000_spe_abi = 0;
2184         }
2185
2186       /* These are here for testing during development only, do not
2187          document in the manual please.  */
2188       else if (! strcmp (arg, "d64"))
2189         {
2190           rs6000_darwin64_abi = 1;
2191           warning (0, "Using darwin64 ABI");
2192         }
2193       else if (! strcmp (arg, "d32"))
2194         {
2195           rs6000_darwin64_abi = 0;
2196           warning (0, "Using old darwin ABI");
2197         }
2198
2199       else if (! strcmp (arg, "ibmlongdouble"))
2200         {
2201           rs6000_explicit_options.ieee = true;
2202           rs6000_ieeequad = 0;
2203           warning (0, "Using IBM extended precision long double");
2204         }
2205       else if (! strcmp (arg, "ieeelongdouble"))
2206         {
2207           rs6000_explicit_options.ieee = true;
2208           rs6000_ieeequad = 1;
2209           warning (0, "Using IEEE extended precision long double");
2210         }
2211
2212       else
2213         {
2214           error ("unknown ABI specified: '%s'", arg);
2215           return false;
2216         }
2217       break;
2218
2219     case OPT_mcpu_:
2220       rs6000_select[1].string = arg;
2221       break;
2222
2223     case OPT_mtune_:
2224       rs6000_select[2].string = arg;
2225       break;
2226
2227     case OPT_mtraceback_:
2228       rs6000_traceback_name = arg;
2229       break;
2230
2231     case OPT_mfloat_gprs_:
2232       rs6000_explicit_options.float_gprs = true;
2233       if (! strcmp (arg, "yes") || ! strcmp (arg, "single"))
2234         rs6000_float_gprs = 1;
2235       else if (! strcmp (arg, "double"))
2236         rs6000_float_gprs = 2;
2237       else if (! strcmp (arg, "no"))
2238         rs6000_float_gprs = 0;
2239       else
2240         {
2241           error ("invalid option for -mfloat-gprs: '%s'", arg);
2242           return false;
2243         }
2244       break;
2245
2246     case OPT_mlong_double_:
2247       rs6000_explicit_options.long_double = true;
2248       rs6000_long_double_type_size = RS6000_DEFAULT_LONG_DOUBLE_SIZE;
2249       if (value != 64 && value != 128)
2250         {
2251           error ("Unknown switch -mlong-double-%s", arg);
2252           rs6000_long_double_type_size = RS6000_DEFAULT_LONG_DOUBLE_SIZE;
2253           return false;
2254         }
2255       else
2256         rs6000_long_double_type_size = value;
2257       break;
2258
2259     case OPT_msched_costly_dep_:
2260       rs6000_sched_costly_dep_str = arg;
2261       break;
2262
2263     case OPT_malign_:
2264       rs6000_explicit_options.alignment = true;
2265       if (! strcmp (arg, "power"))
2266         {
2267           /* On 64-bit Darwin, power alignment is ABI-incompatible with
2268              some C library functions, so warn about it. The flag may be
2269              useful for performance studies from time to time though, so
2270              don't disable it entirely.  */
2271           if (DEFAULT_ABI == ABI_DARWIN && TARGET_64BIT)
2272             warning (0, "-malign-power is not supported for 64-bit Darwin;"
2273                      " it is incompatible with the installed C and C++ libraries");
2274           rs6000_alignment_flags = MASK_ALIGN_POWER;
2275         }
2276       else if (! strcmp (arg, "natural"))
2277         rs6000_alignment_flags = MASK_ALIGN_NATURAL;
2278       else
2279         {
2280           error ("unknown -malign-XXXXX option specified: '%s'", arg);
2281           return false;
2282         }
2283       break;
2284     }
2285   return true;
2286 }
2287 \f
2288 /* Do anything needed at the start of the asm file.  */
2289
2290 static void
2291 rs6000_file_start (void)
2292 {
2293   size_t i;
2294   char buffer[80];
2295   const char *start = buffer;
2296   struct rs6000_cpu_select *ptr;
2297   const char *default_cpu = TARGET_CPU_DEFAULT;
2298   FILE *file = asm_out_file;
2299
2300   default_file_start ();
2301
2302 #ifdef TARGET_BI_ARCH
2303   if ((TARGET_DEFAULT ^ target_flags) & MASK_64BIT)
2304     default_cpu = 0;
2305 #endif
2306
2307   if (flag_verbose_asm)
2308     {
2309       sprintf (buffer, "\n%s rs6000/powerpc options:", ASM_COMMENT_START);
2310       rs6000_select[0].string = default_cpu;
2311
2312       for (i = 0; i < ARRAY_SIZE (rs6000_select); i++)
2313         {
2314           ptr = &rs6000_select[i];
2315           if (ptr->string != (char *)0 && ptr->string[0] != '\0')
2316             {
2317               fprintf (file, "%s %s%s", start, ptr->name, ptr->string);
2318               start = "";
2319             }
2320         }
2321
2322       if (PPC405_ERRATUM77)
2323         {
2324           fprintf (file, "%s PPC405CR_ERRATUM77", start);
2325           start = "";
2326         }
2327
2328 #ifdef USING_ELFOS_H
2329       switch (rs6000_sdata)
2330         {
2331         case SDATA_NONE: fprintf (file, "%s -msdata=none", start); start = ""; break;
2332         case SDATA_DATA: fprintf (file, "%s -msdata=data", start); start = ""; break;
2333         case SDATA_SYSV: fprintf (file, "%s -msdata=sysv", start); start = ""; break;
2334         case SDATA_EABI: fprintf (file, "%s -msdata=eabi", start); start = ""; break;
2335         }
2336
2337       if (rs6000_sdata && g_switch_value)
2338         {
2339           fprintf (file, "%s -G " HOST_WIDE_INT_PRINT_UNSIGNED, start,
2340                    g_switch_value);
2341           start = "";
2342         }
2343 #endif
2344
2345       if (*start == '\0')
2346         putc ('\n', file);
2347     }
2348
2349 #ifdef HAVE_AS_GNU_ATTRIBUTE
2350   if (TARGET_32BIT && DEFAULT_ABI == ABI_V4)
2351     {
2352       fprintf (file, "\t.gnu_attribute 4, %d\n",
2353                (TARGET_HARD_FLOAT && TARGET_FPRS) ? 1 : 2);
2354       fprintf (file, "\t.gnu_attribute 8, %d\n",
2355                (TARGET_ALTIVEC_ABI ? 2
2356                 : TARGET_SPE_ABI ? 3
2357                 : 1));
2358     }
2359 #endif
2360
2361   if (DEFAULT_ABI == ABI_AIX || (TARGET_ELF && flag_pic == 2))
2362     {
2363       switch_to_section (toc_section);
2364       switch_to_section (text_section);
2365     }
2366 }
2367
2368 \f
2369 /* Return nonzero if this function is known to have a null epilogue.  */
2370
2371 int
2372 direct_return (void)
2373 {
2374   if (reload_completed)
2375     {
2376       rs6000_stack_t *info = rs6000_stack_info ();
2377
2378       if (info->first_gp_reg_save == 32
2379           && info->first_fp_reg_save == 64
2380           && info->first_altivec_reg_save == LAST_ALTIVEC_REGNO + 1
2381           && ! info->lr_save_p
2382           && ! info->cr_save_p
2383           && info->vrsave_mask == 0
2384           && ! info->push_p)
2385         return 1;
2386     }
2387
2388   return 0;
2389 }
2390
2391 /* Return the number of instructions it takes to form a constant in an
2392    integer register.  */
2393
2394 int
2395 num_insns_constant_wide (HOST_WIDE_INT value)
2396 {
2397   /* signed constant loadable with {cal|addi} */
2398   if ((unsigned HOST_WIDE_INT) (value + 0x8000) < 0x10000)
2399     return 1;
2400
2401   /* constant loadable with {cau|addis} */
2402   else if ((value & 0xffff) == 0
2403            && (value >> 31 == -1 || value >> 31 == 0))
2404     return 1;
2405
2406 #if HOST_BITS_PER_WIDE_INT == 64
2407   else if (TARGET_POWERPC64)
2408     {
2409       HOST_WIDE_INT low  = ((value & 0xffffffff) ^ 0x80000000) - 0x80000000;
2410       HOST_WIDE_INT high = value >> 31;
2411
2412       if (high == 0 || high == -1)
2413         return 2;
2414
2415       high >>= 1;
2416
2417       if (low == 0)
2418         return num_insns_constant_wide (high) + 1;
2419       else
2420         return (num_insns_constant_wide (high)
2421                 + num_insns_constant_wide (low) + 1);
2422     }
2423 #endif
2424
2425   else
2426     return 2;
2427 }
2428
2429 int
2430 num_insns_constant (rtx op, enum machine_mode mode)
2431 {
2432   HOST_WIDE_INT low, high;
2433
2434   switch (GET_CODE (op))
2435     {
2436     case CONST_INT:
2437 #if HOST_BITS_PER_WIDE_INT == 64
2438       if ((INTVAL (op) >> 31) != 0 && (INTVAL (op) >> 31) != -1
2439           && mask64_operand (op, mode))
2440         return 2;
2441       else
2442 #endif
2443         return num_insns_constant_wide (INTVAL (op));
2444
2445       case CONST_DOUBLE:
2446         if (mode == SFmode)
2447           {
2448             long l;
2449             REAL_VALUE_TYPE rv;
2450
2451             REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
2452             REAL_VALUE_TO_TARGET_SINGLE (rv, l);
2453             return num_insns_constant_wide ((HOST_WIDE_INT) l);
2454           }
2455
2456         if (mode == VOIDmode || mode == DImode)
2457           {
2458             high = CONST_DOUBLE_HIGH (op);
2459             low  = CONST_DOUBLE_LOW (op);
2460           }
2461         else
2462           {
2463             long l[2];
2464             REAL_VALUE_TYPE rv;
2465
2466             REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
2467             if (DECIMAL_FLOAT_MODE_P (mode))
2468               REAL_VALUE_TO_TARGET_DECIMAL64 (rv, l);
2469             else
2470               REAL_VALUE_TO_TARGET_DOUBLE (rv, l);
2471             high = l[WORDS_BIG_ENDIAN == 0];
2472             low  = l[WORDS_BIG_ENDIAN != 0];
2473           }
2474
2475         if (TARGET_32BIT)
2476           return (num_insns_constant_wide (low)
2477                   + num_insns_constant_wide (high));
2478         else
2479           {
2480             if ((high == 0 && low >= 0)
2481                 || (high == -1 && low < 0))
2482               return num_insns_constant_wide (low);
2483
2484             else if (mask64_operand (op, mode))
2485               return 2;
2486
2487             else if (low == 0)
2488               return num_insns_constant_wide (high) + 1;
2489
2490             else
2491               return (num_insns_constant_wide (high)
2492                       + num_insns_constant_wide (low) + 1);
2493           }
2494
2495     default:
2496       gcc_unreachable ();
2497     }
2498 }
2499
2500 /* Interpret element ELT of the CONST_VECTOR OP as an integer value.
2501    If the mode of OP is MODE_VECTOR_INT, this simply returns the
2502    corresponding element of the vector, but for V4SFmode and V2SFmode,
2503    the corresponding "float" is interpreted as an SImode integer.  */
2504
2505 static HOST_WIDE_INT
2506 const_vector_elt_as_int (rtx op, unsigned int elt)
2507 {
2508   rtx tmp = CONST_VECTOR_ELT (op, elt);
2509   if (GET_MODE (op) == V4SFmode
2510       || GET_MODE (op) == V2SFmode)
2511     tmp = gen_lowpart (SImode, tmp);
2512   return INTVAL (tmp);
2513 }
2514
2515 /* Return true if OP can be synthesized with a particular vspltisb, vspltish
2516    or vspltisw instruction.  OP is a CONST_VECTOR.  Which instruction is used
2517    depends on STEP and COPIES, one of which will be 1.  If COPIES > 1,
2518    all items are set to the same value and contain COPIES replicas of the
2519    vsplt's operand; if STEP > 1, one in STEP elements is set to the vsplt's
2520    operand and the others are set to the value of the operand's msb.  */
2521
2522 static bool
2523 vspltis_constant (rtx op, unsigned step, unsigned copies)
2524 {
2525   enum machine_mode mode = GET_MODE (op);
2526   enum machine_mode inner = GET_MODE_INNER (mode);
2527
2528   unsigned i;
2529   unsigned nunits = GET_MODE_NUNITS (mode);
2530   unsigned bitsize = GET_MODE_BITSIZE (inner);
2531   unsigned mask = GET_MODE_MASK (inner);
2532
2533   HOST_WIDE_INT val = const_vector_elt_as_int (op, nunits - 1);
2534   HOST_WIDE_INT splat_val = val;
2535   HOST_WIDE_INT msb_val = val > 0 ? 0 : -1;
2536
2537   /* Construct the value to be splatted, if possible.  If not, return 0.  */
2538   for (i = 2; i <= copies; i *= 2)
2539     {
2540       HOST_WIDE_INT small_val;
2541       bitsize /= 2;
2542       small_val = splat_val >> bitsize;
2543       mask >>= bitsize;
2544       if (splat_val != ((small_val << bitsize) | (small_val & mask)))
2545         return false;
2546       splat_val = small_val;
2547     }
2548
2549   /* Check if SPLAT_VAL can really be the operand of a vspltis[bhw].  */
2550   if (EASY_VECTOR_15 (splat_val))
2551     ;
2552
2553   /* Also check if we can splat, and then add the result to itself.  Do so if
2554      the value is positive, of if the splat instruction is using OP's mode;
2555      for splat_val < 0, the splat and the add should use the same mode.  */
2556   else if (EASY_VECTOR_15_ADD_SELF (splat_val)
2557            && (splat_val >= 0 || (step == 1 && copies == 1)))
2558     ;
2559
2560   else
2561     return false;
2562
2563   /* Check if VAL is present in every STEP-th element, and the
2564      other elements are filled with its most significant bit.  */
2565   for (i = 0; i < nunits - 1; ++i)
2566     {
2567       HOST_WIDE_INT desired_val;
2568       if (((i + 1) & (step - 1)) == 0)
2569         desired_val = val;
2570       else
2571         desired_val = msb_val;
2572
2573       if (desired_val != const_vector_elt_as_int (op, i))
2574         return false;
2575     }
2576
2577   return true;
2578 }
2579
2580
2581 /* Return true if OP is of the given MODE and can be synthesized
2582    with a vspltisb, vspltish or vspltisw.  */
2583
2584 bool
2585 easy_altivec_constant (rtx op, enum machine_mode mode)
2586 {
2587   unsigned step, copies;
2588
2589   if (mode == VOIDmode)
2590     mode = GET_MODE (op);
2591   else if (mode != GET_MODE (op))
2592     return false;
2593
2594   /* Start with a vspltisw.  */
2595   step = GET_MODE_NUNITS (mode) / 4;
2596   copies = 1;
2597
2598   if (vspltis_constant (op, step, copies))
2599     return true;
2600
2601   /* Then try with a vspltish.  */
2602   if (step == 1)
2603     copies <<= 1;
2604   else
2605     step >>= 1;
2606
2607   if (vspltis_constant (op, step, copies))
2608     return true;
2609
2610   /* And finally a vspltisb.  */
2611   if (step == 1)
2612     copies <<= 1;
2613   else
2614     step >>= 1;
2615
2616   if (vspltis_constant (op, step, copies))
2617     return true;
2618
2619   return false;
2620 }
2621
2622 /* Generate a VEC_DUPLICATE representing a vspltis[bhw] instruction whose
2623    result is OP.  Abort if it is not possible.  */
2624
2625 rtx
2626 gen_easy_altivec_constant (rtx op)
2627 {
2628   enum machine_mode mode = GET_MODE (op);
2629   int nunits = GET_MODE_NUNITS (mode);
2630   rtx last = CONST_VECTOR_ELT (op, nunits - 1);
2631   unsigned step = nunits / 4;
2632   unsigned copies = 1;
2633
2634   /* Start with a vspltisw.  */
2635   if (vspltis_constant (op, step, copies))
2636     return gen_rtx_VEC_DUPLICATE (V4SImode, gen_lowpart (SImode, last));
2637
2638   /* Then try with a vspltish.  */
2639   if (step == 1)
2640     copies <<= 1;
2641   else
2642     step >>= 1;
2643
2644   if (vspltis_constant (op, step, copies))
2645     return gen_rtx_VEC_DUPLICATE (V8HImode, gen_lowpart (HImode, last));
2646
2647   /* And finally a vspltisb.  */
2648   if (step == 1)
2649     copies <<= 1;
2650   else
2651     step >>= 1;
2652
2653   if (vspltis_constant (op, step, copies))
2654     return gen_rtx_VEC_DUPLICATE (V16QImode, gen_lowpart (QImode, last));
2655
2656   gcc_unreachable ();
2657 }
2658
2659 const char *
2660 output_vec_const_move (rtx *operands)
2661 {
2662   int cst, cst2;
2663   enum machine_mode mode;
2664   rtx dest, vec;
2665
2666   dest = operands[0];
2667   vec = operands[1];
2668   mode = GET_MODE (dest);
2669
2670   if (TARGET_ALTIVEC)
2671     {
2672       rtx splat_vec;
2673       if (zero_constant (vec, mode))
2674         return "vxor %0,%0,%0";
2675
2676       splat_vec = gen_easy_altivec_constant (vec);
2677       gcc_assert (GET_CODE (splat_vec) == VEC_DUPLICATE);
2678       operands[1] = XEXP (splat_vec, 0);
2679       if (!EASY_VECTOR_15 (INTVAL (operands[1])))
2680         return "#";
2681
2682       switch (GET_MODE (splat_vec))
2683         {
2684         case V4SImode:
2685           return "vspltisw %0,%1";
2686
2687         case V8HImode:
2688           return "vspltish %0,%1";
2689
2690         case V16QImode:
2691           return "vspltisb %0,%1";
2692
2693         default:
2694           gcc_unreachable ();
2695         }
2696     }
2697
2698   gcc_assert (TARGET_SPE);
2699
2700   /* Vector constant 0 is handled as a splitter of V2SI, and in the
2701      pattern of V1DI, V4HI, and V2SF.
2702
2703      FIXME: We should probably return # and add post reload
2704      splitters for these, but this way is so easy ;-).  */
2705   cst = INTVAL (CONST_VECTOR_ELT (vec, 0));
2706   cst2 = INTVAL (CONST_VECTOR_ELT (vec, 1));
2707   operands[1] = CONST_VECTOR_ELT (vec, 0);
2708   operands[2] = CONST_VECTOR_ELT (vec, 1);
2709   if (cst == cst2)
2710     return "li %0,%1\n\tevmergelo %0,%0,%0";
2711   else
2712     return "li %0,%1\n\tevmergelo %0,%0,%0\n\tli %0,%2";
2713 }
2714
2715 /* Initialize vector TARGET to VALS.  */
2716
2717 void
2718 rs6000_expand_vector_init (rtx target, rtx vals)
2719 {
2720   enum machine_mode mode = GET_MODE (target);
2721   enum machine_mode inner_mode = GET_MODE_INNER (mode);
2722   int n_elts = GET_MODE_NUNITS (mode);
2723   int n_var = 0, one_var = -1;
2724   bool all_same = true, all_const_zero = true;
2725   rtx x, mem;
2726   int i;
2727
2728   for (i = 0; i < n_elts; ++i)
2729     {
2730       x = XVECEXP (vals, 0, i);
2731       if (!CONSTANT_P (x))
2732         ++n_var, one_var = i;
2733       else if (x != CONST0_RTX (inner_mode))
2734         all_const_zero = false;
2735
2736       if (i > 0 && !rtx_equal_p (x, XVECEXP (vals, 0, 0)))
2737         all_same = false;
2738     }
2739
2740   if (n_var == 0)
2741     {
2742       if (mode != V4SFmode && all_const_zero)
2743         {
2744           /* Zero register.  */
2745           emit_insn (gen_rtx_SET (VOIDmode, target,
2746                                   gen_rtx_XOR (mode, target, target)));
2747           return;
2748         }
2749       else if (mode != V4SFmode && easy_vector_constant (vals, mode))
2750         {
2751           /* Splat immediate.  */
2752           emit_insn (gen_rtx_SET (VOIDmode, target, vals));
2753           return;
2754         }
2755       else if (all_same)
2756         ;       /* Splat vector element.  */
2757       else
2758         {
2759           /* Load from constant pool.  */
2760           emit_move_insn (target, gen_rtx_CONST_VECTOR (mode, XVEC (vals, 0)));
2761           return;
2762         }
2763     }
2764
2765   /* Store value to stack temp.  Load vector element.  Splat.  */
2766   if (all_same)
2767     {
2768       mem = assign_stack_temp (mode, GET_MODE_SIZE (inner_mode), 0);
2769       emit_move_insn (adjust_address_nv (mem, inner_mode, 0),
2770                       XVECEXP (vals, 0, 0));
2771       x = gen_rtx_UNSPEC (VOIDmode,
2772                           gen_rtvec (1, const0_rtx), UNSPEC_LVE);
2773       emit_insn (gen_rtx_PARALLEL (VOIDmode,
2774                                    gen_rtvec (2,
2775                                               gen_rtx_SET (VOIDmode,
2776                                                            target, mem),
2777                                               x)));
2778       x = gen_rtx_VEC_SELECT (inner_mode, target,
2779                               gen_rtx_PARALLEL (VOIDmode,
2780                                                 gen_rtvec (1, const0_rtx)));
2781       emit_insn (gen_rtx_SET (VOIDmode, target,
2782                               gen_rtx_VEC_DUPLICATE (mode, x)));
2783       return;
2784     }
2785
2786   /* One field is non-constant.  Load constant then overwrite
2787      varying field.  */
2788   if (n_var == 1)
2789     {
2790       rtx copy = copy_rtx (vals);
2791
2792       /* Load constant part of vector, substitute neighboring value for
2793          varying element.  */
2794       XVECEXP (copy, 0, one_var) = XVECEXP (vals, 0, (one_var + 1) % n_elts);
2795       rs6000_expand_vector_init (target, copy);
2796
2797       /* Insert variable.  */
2798       rs6000_expand_vector_set (target, XVECEXP (vals, 0, one_var), one_var);
2799       return;
2800     }
2801
2802   /* Construct the vector in memory one field at a time
2803      and load the whole vector.  */
2804   mem = assign_stack_temp (mode, GET_MODE_SIZE (mode), 0);
2805   for (i = 0; i < n_elts; i++)
2806     emit_move_insn (adjust_address_nv (mem, inner_mode,
2807                                     i * GET_MODE_SIZE (inner_mode)),
2808                     XVECEXP (vals, 0, i));
2809   emit_move_insn (target, mem);
2810 }
2811
2812 /* Set field ELT of TARGET to VAL.  */
2813
2814 void
2815 rs6000_expand_vector_set (rtx target, rtx val, int elt)
2816 {
2817   enum machine_mode mode = GET_MODE (target);
2818   enum machine_mode inner_mode = GET_MODE_INNER (mode);
2819   rtx reg = gen_reg_rtx (mode);
2820   rtx mask, mem, x;
2821   int width = GET_MODE_SIZE (inner_mode);
2822   int i;
2823
2824   /* Load single variable value.  */
2825   mem = assign_stack_temp (mode, GET_MODE_SIZE (inner_mode), 0);
2826   emit_move_insn (adjust_address_nv (mem, inner_mode, 0), val);
2827   x = gen_rtx_UNSPEC (VOIDmode,
2828                       gen_rtvec (1, const0_rtx), UNSPEC_LVE);
2829   emit_insn (gen_rtx_PARALLEL (VOIDmode,
2830                                gen_rtvec (2,
2831                                           gen_rtx_SET (VOIDmode,
2832                                                        reg, mem),
2833                                           x)));
2834
2835   /* Linear sequence.  */
2836   mask = gen_rtx_PARALLEL (V16QImode, rtvec_alloc (16));
2837   for (i = 0; i < 16; ++i)
2838     XVECEXP (mask, 0, i) = GEN_INT (i);
2839
2840   /* Set permute mask to insert element into target.  */
2841   for (i = 0; i < width; ++i)
2842     XVECEXP (mask, 0, elt*width + i)
2843       = GEN_INT (i + 0x10);
2844   x = gen_rtx_CONST_VECTOR (V16QImode, XVEC (mask, 0));
2845   x = gen_rtx_UNSPEC (mode,
2846                       gen_rtvec (3, target, reg,
2847                                  force_reg (V16QImode, x)),
2848                       UNSPEC_VPERM);
2849   emit_insn (gen_rtx_SET (VOIDmode, target, x));
2850 }
2851
2852 /* Extract field ELT from VEC into TARGET.  */
2853
2854 void
2855 rs6000_expand_vector_extract (rtx target, rtx vec, int elt)
2856 {
2857   enum machine_mode mode = GET_MODE (vec);
2858   enum machine_mode inner_mode = GET_MODE_INNER (mode);
2859   rtx mem, x;
2860
2861   /* Allocate mode-sized buffer.  */
2862   mem = assign_stack_temp (mode, GET_MODE_SIZE (mode), 0);
2863
2864   /* Add offset to field within buffer matching vector element.  */
2865   mem = adjust_address_nv (mem, mode, elt * GET_MODE_SIZE (inner_mode));
2866
2867   /* Store single field into mode-sized buffer.  */
2868   x = gen_rtx_UNSPEC (VOIDmode,
2869                       gen_rtvec (1, const0_rtx), UNSPEC_STVE);
2870   emit_insn (gen_rtx_PARALLEL (VOIDmode,
2871                                gen_rtvec (2,
2872                                           gen_rtx_SET (VOIDmode,
2873                                                        mem, vec),
2874                                           x)));
2875   emit_move_insn (target, adjust_address_nv (mem, inner_mode, 0));
2876 }
2877
2878 /* Generates shifts and masks for a pair of rldicl or rldicr insns to
2879    implement ANDing by the mask IN.  */
2880 void
2881 build_mask64_2_operands (rtx in, rtx *out)
2882 {
2883 #if HOST_BITS_PER_WIDE_INT >= 64
2884   unsigned HOST_WIDE_INT c, lsb, m1, m2;
2885   int shift;
2886
2887   gcc_assert (GET_CODE (in) == CONST_INT);
2888
2889   c = INTVAL (in);
2890   if (c & 1)
2891     {
2892       /* Assume c initially something like 0x00fff000000fffff.  The idea
2893          is to rotate the word so that the middle ^^^^^^ group of zeros
2894          is at the MS end and can be cleared with an rldicl mask.  We then
2895          rotate back and clear off the MS    ^^ group of zeros with a
2896          second rldicl.  */
2897       c = ~c;                   /*   c == 0xff000ffffff00000 */
2898       lsb = c & -c;             /* lsb == 0x0000000000100000 */
2899       m1 = -lsb;                /*  m1 == 0xfffffffffff00000 */
2900       c = ~c;                   /*   c == 0x00fff000000fffff */
2901       c &= -lsb;                /*   c == 0x00fff00000000000 */
2902       lsb = c & -c;             /* lsb == 0x0000100000000000 */
2903       c = ~c;                   /*   c == 0xff000fffffffffff */
2904       c &= -lsb;                /*   c == 0xff00000000000000 */
2905       shift = 0;
2906       while ((lsb >>= 1) != 0)
2907         shift++;                /* shift == 44 on exit from loop */
2908       m1 <<= 64 - shift;        /*  m1 == 0xffffff0000000000 */
2909       m1 = ~m1;                 /*  m1 == 0x000000ffffffffff */
2910       m2 = ~c;                  /*  m2 == 0x00ffffffffffffff */
2911     }
2912   else
2913     {
2914       /* Assume c initially something like 0xff000f0000000000.  The idea
2915          is to rotate the word so that the     ^^^  middle group of zeros
2916          is at the LS end and can be cleared with an rldicr mask.  We then
2917          rotate back and clear off the LS group of ^^^^^^^^^^ zeros with
2918          a second rldicr.  */
2919       lsb = c & -c;             /* lsb == 0x0000010000000000 */
2920       m2 = -lsb;                /*  m2 == 0xffffff0000000000 */
2921       c = ~c;                   /*   c == 0x00fff0ffffffffff */
2922       c &= -lsb;                /*   c == 0x00fff00000000000 */
2923       lsb = c & -c;             /* lsb == 0x0000100000000000 */
2924       c = ~c;                   /*   c == 0xff000fffffffffff */
2925       c &= -lsb;                /*   c == 0xff00000000000000 */
2926       shift = 0;
2927       while ((lsb >>= 1) != 0)
2928         shift++;                /* shift == 44 on exit from loop */
2929       m1 = ~c;                  /*  m1 == 0x00ffffffffffffff */
2930       m1 >>= shift;             /*  m1 == 0x0000000000000fff */
2931       m1 = ~m1;                 /*  m1 == 0xfffffffffffff000 */
2932     }
2933
2934   /* Note that when we only have two 0->1 and 1->0 transitions, one of the
2935      masks will be all 1's.  We are guaranteed more than one transition.  */
2936   out[0] = GEN_INT (64 - shift);
2937   out[1] = GEN_INT (m1);
2938   out[2] = GEN_INT (shift);
2939   out[3] = GEN_INT (m2);
2940 #else
2941   (void)in;
2942   (void)out;
2943   gcc_unreachable ();
2944 #endif
2945 }
2946
2947 /* Return TRUE if OP is an invalid SUBREG operation on the e500.  */
2948
2949 bool
2950 invalid_e500_subreg (rtx op, enum machine_mode mode)
2951 {
2952   if (TARGET_E500_DOUBLE)
2953     {
2954       /* Reject (subreg:SI (reg:DF)); likewise with subreg:DI or
2955          subreg:TI and reg:TF.  */
2956       if (GET_CODE (op) == SUBREG
2957           && (mode == SImode || mode == DImode || mode == TImode)
2958           && REG_P (SUBREG_REG (op))
2959           && (GET_MODE (SUBREG_REG (op)) == DFmode
2960               || GET_MODE (SUBREG_REG (op)) == TFmode))
2961         return true;
2962
2963       /* Reject (subreg:DF (reg:DI)); likewise with subreg:TF and
2964          reg:TI.  */
2965       if (GET_CODE (op) == SUBREG
2966           && (mode == DFmode || mode == TFmode)
2967           && REG_P (SUBREG_REG (op))
2968           && (GET_MODE (SUBREG_REG (op)) == DImode
2969               || GET_MODE (SUBREG_REG (op)) == TImode))
2970         return true;
2971     }
2972
2973   if (TARGET_SPE
2974       && GET_CODE (op) == SUBREG
2975       && mode == SImode
2976       && REG_P (SUBREG_REG (op))
2977       && SPE_VECTOR_MODE (GET_MODE (SUBREG_REG (op))))
2978     return true;
2979
2980   return false;
2981 }
2982
2983 /* AIX increases natural record alignment to doubleword if the first
2984    field is an FP double while the FP fields remain word aligned.  */
2985
2986 unsigned int
2987 rs6000_special_round_type_align (tree type, unsigned int computed,
2988                                  unsigned int specified)
2989 {
2990   unsigned int align = MAX (computed, specified);
2991   tree field = TYPE_FIELDS (type);
2992
2993   /* Skip all non field decls */
2994   while (field != NULL && TREE_CODE (field) != FIELD_DECL)
2995     field = TREE_CHAIN (field);
2996
2997   if (field != NULL && field != type)
2998     {
2999       type = TREE_TYPE (field);
3000       while (TREE_CODE (type) == ARRAY_TYPE)
3001         type = TREE_TYPE (type);
3002
3003       if (type != error_mark_node && TYPE_MODE (type) == DFmode)
3004         align = MAX (align, 64);
3005     }
3006
3007   return align;
3008 }
3009
3010 /* Darwin increases record alignment to the natural alignment of
3011    the first field.  */
3012
3013 unsigned int
3014 darwin_rs6000_special_round_type_align (tree type, unsigned int computed,
3015                                         unsigned int specified)
3016 {
3017   unsigned int align = MAX (computed, specified);
3018
3019   if (TYPE_PACKED (type))
3020     return align;
3021
3022   /* Find the first field, looking down into aggregates.  */
3023   do {
3024     tree field = TYPE_FIELDS (type);
3025     /* Skip all non field decls */
3026     while (field != NULL && TREE_CODE (field) != FIELD_DECL)
3027       field = TREE_CHAIN (field);
3028     if (! field)
3029       break;
3030     type = TREE_TYPE (field);
3031     while (TREE_CODE (type) == ARRAY_TYPE)
3032       type = TREE_TYPE (type);
3033   } while (AGGREGATE_TYPE_P (type));
3034
3035   if (! AGGREGATE_TYPE_P (type) && type != error_mark_node)
3036     align = MAX (align, TYPE_ALIGN (type));
3037
3038   return align;
3039 }
3040
3041 /* Return 1 for an operand in small memory on V.4/eabi.  */
3042
3043 int
3044 small_data_operand (rtx op ATTRIBUTE_UNUSED,
3045                     enum machine_mode mode ATTRIBUTE_UNUSED)
3046 {
3047 #if TARGET_ELF
3048   rtx sym_ref;
3049
3050   if (rs6000_sdata == SDATA_NONE || rs6000_sdata == SDATA_DATA)
3051     return 0;
3052
3053   if (DEFAULT_ABI != ABI_V4)
3054     return 0;
3055
3056   if (GET_CODE (op) == SYMBOL_REF)
3057     sym_ref = op;
3058
3059   else if (GET_CODE (op) != CONST
3060            || GET_CODE (XEXP (op, 0)) != PLUS
3061            || GET_CODE (XEXP (XEXP (op, 0), 0)) != SYMBOL_REF
3062            || GET_CODE (XEXP (XEXP (op, 0), 1)) != CONST_INT)
3063     return 0;
3064
3065   else
3066     {
3067       rtx sum = XEXP (op, 0);
3068       HOST_WIDE_INT summand;
3069
3070       /* We have to be careful here, because it is the referenced address
3071          that must be 32k from _SDA_BASE_, not just the symbol.  */
3072       summand = INTVAL (XEXP (sum, 1));
3073       if (summand < 0 || (unsigned HOST_WIDE_INT) summand > g_switch_value)
3074         return 0;
3075
3076       sym_ref = XEXP (sum, 0);
3077     }
3078
3079   return SYMBOL_REF_SMALL_P (sym_ref);
3080 #else
3081   return 0;
3082 #endif
3083 }
3084
3085 /* Return true if either operand is a general purpose register.  */
3086
3087 bool
3088 gpr_or_gpr_p (rtx op0, rtx op1)
3089 {
3090   return ((REG_P (op0) && INT_REGNO_P (REGNO (op0)))
3091           || (REG_P (op1) && INT_REGNO_P (REGNO (op1))));
3092 }
3093
3094 \f
3095 /* Subroutines of rs6000_legitimize_address and rs6000_legitimate_address.  */
3096
3097 static int
3098 constant_pool_expr_1 (rtx op, int *have_sym, int *have_toc)
3099 {
3100   switch (GET_CODE (op))
3101     {
3102     case SYMBOL_REF:
3103       if (RS6000_SYMBOL_REF_TLS_P (op))
3104         return 0;
3105       else if (CONSTANT_POOL_ADDRESS_P (op))
3106         {
3107           if (ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (get_pool_constant (op), Pmode))
3108             {
3109               *have_sym = 1;
3110               return 1;
3111             }
3112           else
3113             return 0;
3114         }
3115       else if (! strcmp (XSTR (op, 0), toc_label_name))
3116         {
3117           *have_toc = 1;
3118           return 1;
3119         }
3120       else
3121         return 0;
3122     case PLUS:
3123     case MINUS:
3124       return (constant_pool_expr_1 (XEXP (op, 0), have_sym, have_toc)
3125               && constant_pool_expr_1 (XEXP (op, 1), have_sym, have_toc));
3126     case CONST:
3127       return constant_pool_expr_1 (XEXP (op, 0), have_sym, have_toc);
3128     case CONST_INT:
3129       return 1;
3130     default:
3131       return 0;
3132     }
3133 }
3134
3135 static bool
3136 constant_pool_expr_p (rtx op)
3137 {
3138   int have_sym = 0;
3139   int have_toc = 0;
3140   return constant_pool_expr_1 (op, &have_sym, &have_toc) && have_sym;
3141 }
3142
3143 bool
3144 toc_relative_expr_p (rtx op)
3145 {
3146   int have_sym = 0;
3147   int have_toc = 0;
3148   return constant_pool_expr_1 (op, &have_sym, &have_toc) && have_toc;
3149 }
3150
3151 bool
3152 legitimate_constant_pool_address_p (rtx x)
3153 {
3154   return (TARGET_TOC
3155           && GET_CODE (x) == PLUS
3156           && GET_CODE (XEXP (x, 0)) == REG
3157           && (TARGET_MINIMAL_TOC || REGNO (XEXP (x, 0)) == TOC_REGISTER)
3158           && constant_pool_expr_p (XEXP (x, 1)));
3159 }
3160
3161 static bool
3162 legitimate_small_data_p (enum machine_mode mode, rtx x)
3163 {
3164   return (DEFAULT_ABI == ABI_V4
3165           && !flag_pic && !TARGET_TOC
3166           && (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == CONST)
3167           && small_data_operand (x, mode));
3168 }
3169
3170 /* SPE offset addressing is limited to 5-bits worth of double words.  */
3171 #define SPE_CONST_OFFSET_OK(x) (((x) & ~0xf8) == 0)
3172
3173 bool
3174 rs6000_legitimate_offset_address_p (enum machine_mode mode, rtx x, int strict)
3175 {
3176   unsigned HOST_WIDE_INT offset, extra;
3177
3178   if (GET_CODE (x) != PLUS)
3179     return false;
3180   if (GET_CODE (XEXP (x, 0)) != REG)
3181     return false;
3182   if (!INT_REG_OK_FOR_BASE_P (XEXP (x, 0), strict))
3183     return false;
3184   if (legitimate_constant_pool_address_p (x))
3185     return true;
3186   if (GET_CODE (XEXP (x, 1)) != CONST_INT)
3187     return false;
3188
3189   offset = INTVAL (XEXP (x, 1));
3190   extra = 0;
3191   switch (mode)
3192     {
3193     case V16QImode:
3194     case V8HImode:
3195     case V4SFmode:
3196     case V4SImode:
3197       /* AltiVec vector modes.  Only reg+reg addressing is valid and
3198          constant offset zero should not occur due to canonicalization.
3199          Allow any offset when not strict before reload.  */
3200       return !strict;
3201
3202     case V4HImode:
3203     case V2SImode:
3204     case V1DImode:
3205     case V2SFmode:
3206        /* Paired vector modes.  Only reg+reg addressing is valid and
3207          constant offset zero should not occur due to canonicalization.
3208          Allow any offset when not strict before reload.  */
3209       if (TARGET_PAIRED_FLOAT)
3210         return !strict;
3211       /* SPE vector modes.  */
3212       return SPE_CONST_OFFSET_OK (offset);
3213
3214     case DFmode:
3215     case DDmode:
3216       if (TARGET_E500_DOUBLE)
3217         return SPE_CONST_OFFSET_OK (offset);
3218
3219     case DImode:
3220       /* On e500v2, we may have:
3221
3222            (subreg:DF (mem:DI (plus (reg) (const_int))) 0).
3223
3224          Which gets addressed with evldd instructions.  */
3225       if (TARGET_E500_DOUBLE)
3226         return SPE_CONST_OFFSET_OK (offset);
3227
3228       if (mode == DFmode || mode == DDmode || !TARGET_POWERPC64)
3229         extra = 4;
3230       else if (offset & 3)
3231         return false;
3232       break;
3233
3234     case TFmode:
3235       if (TARGET_E500_DOUBLE)
3236         return (SPE_CONST_OFFSET_OK (offset)
3237                 && SPE_CONST_OFFSET_OK (offset + 8));
3238
3239     case TImode:
3240     case TDmode:
3241       if (mode == TFmode || mode == TDmode || !TARGET_POWERPC64)
3242         extra = 12;
3243       else if (offset & 3)
3244         return false;
3245       else
3246         extra = 8;
3247       break;
3248
3249     default:
3250       break;
3251     }
3252
3253   offset += 0x8000;
3254   return (offset < 0x10000) && (offset + extra < 0x10000);
3255 }
3256
3257 bool
3258 legitimate_indexed_address_p (rtx x, int strict)
3259 {
3260   rtx op0, op1;
3261
3262   if (GET_CODE (x) != PLUS)
3263     return false;
3264
3265   op0 = XEXP (x, 0);
3266   op1 = XEXP (x, 1);
3267
3268   /* Recognize the rtl generated by reload which we know will later be
3269      replaced with proper base and index regs.  */
3270   if (!strict
3271       && reload_in_progress
3272       && (REG_P (op0) || GET_CODE (op0) == PLUS)
3273       && REG_P (op1))
3274     return true;
3275
3276   return (REG_P (op0) && REG_P (op1)
3277           && ((INT_REG_OK_FOR_BASE_P (op0, strict)
3278                && INT_REG_OK_FOR_INDEX_P (op1, strict))
3279               || (INT_REG_OK_FOR_BASE_P (op1, strict)
3280                   && INT_REG_OK_FOR_INDEX_P (op0, strict))));
3281 }
3282
3283 inline bool
3284 legitimate_indirect_address_p (rtx x, int strict)
3285 {
3286   return GET_CODE (x) == REG && INT_REG_OK_FOR_BASE_P (x, strict);
3287 }
3288
3289 bool
3290 macho_lo_sum_memory_operand (rtx x, enum machine_mode mode)
3291 {
3292   if (!TARGET_MACHO || !flag_pic
3293       || mode != SImode || GET_CODE (x) != MEM)
3294     return false;
3295   x = XEXP (x, 0);
3296
3297   if (GET_CODE (x) != LO_SUM)
3298     return false;
3299   if (GET_CODE (XEXP (x, 0)) != REG)
3300     return false;
3301   if (!INT_REG_OK_FOR_BASE_P (XEXP (x, 0), 0))
3302     return false;
3303   x = XEXP (x, 1);
3304
3305   return CONSTANT_P (x);
3306 }
3307
3308 static bool
3309 legitimate_lo_sum_address_p (enum machine_mode mode, rtx x, int strict)
3310 {
3311   if (GET_CODE (x) != LO_SUM)
3312     return false;
3313   if (GET_CODE (XEXP (x, 0)) != REG)
3314     return false;
3315   if (!INT_REG_OK_FOR_BASE_P (XEXP (x, 0), strict))
3316     return false;
3317   /* Restrict addressing for DI because of our SUBREG hackery.  */
3318   if (TARGET_E500_DOUBLE && (mode == DFmode || mode == TFmode
3319                              || mode == DImode))
3320     return false;
3321   x = XEXP (x, 1);
3322
3323   if (TARGET_ELF || TARGET_MACHO)
3324     {
3325       if (DEFAULT_ABI != ABI_AIX && DEFAULT_ABI != ABI_DARWIN && flag_pic)
3326         return false;
3327       if (TARGET_TOC)
3328         return false;
3329       if (GET_MODE_NUNITS (mode) != 1)
3330         return false;
3331       if (GET_MODE_BITSIZE (mode) > 64
3332           || (GET_MODE_BITSIZE (mode) > 32 && !TARGET_POWERPC64
3333               && !(TARGET_HARD_FLOAT && TARGET_FPRS && mode == DFmode)))
3334         return false;
3335
3336       return CONSTANT_P (x);
3337     }
3338
3339   return false;
3340 }
3341
3342
3343 /* Try machine-dependent ways of modifying an illegitimate address
3344    to be legitimate.  If we find one, return the new, valid address.
3345    This is used from only one place: `memory_address' in explow.c.
3346
3347    OLDX is the address as it was before break_out_memory_refs was
3348    called.  In some cases it is useful to look at this to decide what
3349    needs to be done.
3350
3351    MODE is passed so that this function can use GO_IF_LEGITIMATE_ADDRESS.
3352
3353    It is always safe for this function to do nothing.  It exists to
3354    recognize opportunities to optimize the output.
3355
3356    On RS/6000, first check for the sum of a register with a constant
3357    integer that is out of range.  If so, generate code to add the
3358    constant with the low-order 16 bits masked to the register and force
3359    this result into another register (this can be done with `cau').
3360    Then generate an address of REG+(CONST&0xffff), allowing for the
3361    possibility of bit 16 being a one.
3362
3363    Then check for the sum of a register and something not constant, try to
3364    load the other things into a register and return the sum.  */
3365
3366 rtx
3367 rs6000_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
3368                            enum machine_mode mode)
3369 {
3370   if (GET_CODE (x) == SYMBOL_REF)
3371     {
3372       enum tls_model model = SYMBOL_REF_TLS_MODEL (x);
3373       if (model != 0)
3374         return rs6000_legitimize_tls_address (x, model);
3375     }
3376
3377   if (GET_CODE (x) == PLUS
3378       && GET_CODE (XEXP (x, 0)) == REG
3379       && GET_CODE (XEXP (x, 1)) == CONST_INT
3380       && (unsigned HOST_WIDE_INT) (INTVAL (XEXP (x, 1)) + 0x8000) >= 0x10000)
3381     {
3382       HOST_WIDE_INT high_int, low_int;
3383       rtx sum;
3384       low_int = ((INTVAL (XEXP (x, 1)) & 0xffff) ^ 0x8000) - 0x8000;
3385       high_int = INTVAL (XEXP (x, 1)) - low_int;
3386       sum = force_operand (gen_rtx_PLUS (Pmode, XEXP (x, 0),
3387                                          GEN_INT (high_int)), 0);
3388       return gen_rtx_PLUS (Pmode, sum, GEN_INT (low_int));
3389     }
3390   else if (GET_CODE (x) == PLUS
3391            && GET_CODE (XEXP (x, 0)) == REG
3392            && GET_CODE (XEXP (x, 1)) != CONST_INT
3393            && GET_MODE_NUNITS (mode) == 1
3394            && ((TARGET_HARD_FLOAT && TARGET_FPRS)
3395                || TARGET_POWERPC64
3396                || (((mode != DImode && mode != DFmode && mode != DDmode)
3397                     || TARGET_E500_DOUBLE)
3398                    && mode != TFmode && mode != TDmode))
3399            && (TARGET_POWERPC64 || mode != DImode)
3400            && mode != TImode)
3401     {
3402       return gen_rtx_PLUS (Pmode, XEXP (x, 0),
3403                            force_reg (Pmode, force_operand (XEXP (x, 1), 0)));
3404     }
3405   else if (ALTIVEC_VECTOR_MODE (mode))
3406     {
3407       rtx reg;
3408
3409       /* Make sure both operands are registers.  */
3410       if (GET_CODE (x) == PLUS)
3411         return gen_rtx_PLUS (Pmode, force_reg (Pmode, XEXP (x, 0)),
3412                              force_reg (Pmode, XEXP (x, 1)));
3413
3414       reg = force_reg (Pmode, x);
3415       return reg;
3416     }
3417   else if (SPE_VECTOR_MODE (mode)
3418            || (TARGET_E500_DOUBLE && (mode == DFmode || mode == TFmode
3419                                       || mode == DDmode || mode == TDmode
3420                                       || mode == DImode)))
3421     {
3422       if (mode == DImode)
3423         return NULL_RTX;
3424       /* We accept [reg + reg] and [reg + OFFSET].  */
3425
3426       if (GET_CODE (x) == PLUS)
3427         {
3428           rtx op1 = XEXP (x, 0);
3429           rtx op2 = XEXP (x, 1);
3430
3431           op1 = force_reg (Pmode, op1);
3432
3433           if (GET_CODE (op2) != REG
3434               && (GET_CODE (op2) != CONST_INT
3435                   || !SPE_CONST_OFFSET_OK (INTVAL (op2))))
3436             op2 = force_reg (Pmode, op2);
3437
3438           return gen_rtx_PLUS (Pmode, op1, op2);
3439         }
3440
3441       return force_reg (Pmode, x);
3442     }
3443   else if (TARGET_ELF
3444            && TARGET_32BIT
3445            && TARGET_NO_TOC
3446            && ! flag_pic
3447            && GET_CODE (x) != CONST_INT
3448            && GET_CODE (x) != CONST_DOUBLE
3449            && CONSTANT_P (x)
3450            && GET_MODE_NUNITS (mode) == 1
3451            && (GET_MODE_BITSIZE (mode) <= 32
3452                || ((TARGET_HARD_FLOAT && TARGET_FPRS) && mode == DFmode)))
3453     {
3454       rtx reg = gen_reg_rtx (Pmode);
3455       emit_insn (gen_elf_high (reg, x));
3456       return gen_rtx_LO_SUM (Pmode, reg, x);
3457     }
3458   else if (TARGET_MACHO && TARGET_32BIT && TARGET_NO_TOC
3459            && ! flag_pic
3460 #if TARGET_MACHO
3461            && ! MACHO_DYNAMIC_NO_PIC_P
3462 #endif
3463            && GET_CODE (x) != CONST_INT
3464            && GET_CODE (x) != CONST_DOUBLE
3465            && CONSTANT_P (x)
3466            && ((TARGET_HARD_FLOAT && TARGET_FPRS) || mode != DFmode)
3467            && mode != DImode
3468            && mode != TImode)
3469     {
3470       rtx reg = gen_reg_rtx (Pmode);
3471       emit_insn (gen_macho_high (reg, x));
3472       return gen_rtx_LO_SUM (Pmode, reg, x);
3473     }
3474   else if (TARGET_TOC
3475            && constant_pool_expr_p (x)
3476            && ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (get_pool_constant (x), Pmode))
3477     {
3478       return create_TOC_reference (x);
3479     }
3480   else
3481     return NULL_RTX;
3482 }
3483
3484 /* This is called from dwarf2out.c via TARGET_ASM_OUTPUT_DWARF_DTPREL.
3485    We need to emit DTP-relative relocations.  */
3486
3487 static void
3488 rs6000_output_dwarf_dtprel (FILE *file, int size, rtx x)
3489 {
3490   switch (size)
3491     {
3492     case 4:
3493       fputs ("\t.long\t", file);
3494       break;
3495     case 8:
3496       fputs (DOUBLE_INT_ASM_OP, file);
3497       break;
3498     default:
3499       gcc_unreachable ();
3500     }
3501   output_addr_const (file, x);
3502   fputs ("@dtprel+0x8000", file);
3503 }
3504
3505 /* Construct the SYMBOL_REF for the tls_get_addr function.  */
3506
3507 static GTY(()) rtx rs6000_tls_symbol;
3508 static rtx
3509 rs6000_tls_get_addr (void)
3510 {
3511   if (!rs6000_tls_symbol)
3512     rs6000_tls_symbol = init_one_libfunc ("__tls_get_addr");
3513
3514   return rs6000_tls_symbol;
3515 }
3516
3517 /* Construct the SYMBOL_REF for TLS GOT references.  */
3518
3519 static GTY(()) rtx rs6000_got_symbol;
3520 static rtx
3521 rs6000_got_sym (void)
3522 {
3523   if (!rs6000_got_symbol)
3524     {
3525       rs6000_got_symbol = gen_rtx_SYMBOL_REF (Pmode, "_GLOBAL_OFFSET_TABLE_");
3526       SYMBOL_REF_FLAGS (rs6000_got_symbol) |= SYMBOL_FLAG_LOCAL;
3527       SYMBOL_REF_FLAGS (rs6000_got_symbol) |= SYMBOL_FLAG_EXTERNAL;
3528     }
3529
3530   return rs6000_got_symbol;
3531 }
3532
3533 /* ADDR contains a thread-local SYMBOL_REF.  Generate code to compute
3534    this (thread-local) address.  */
3535
3536 static rtx
3537 rs6000_legitimize_tls_address (rtx addr, enum tls_model model)
3538 {
3539   rtx dest, insn;
3540
3541   dest = gen_reg_rtx (Pmode);
3542   if (model == TLS_MODEL_LOCAL_EXEC && rs6000_tls_size == 16)
3543     {
3544       rtx tlsreg;
3545
3546       if (TARGET_64BIT)
3547         {
3548           tlsreg = gen_rtx_REG (Pmode, 13);
3549           insn = gen_tls_tprel_64 (dest, tlsreg, addr);
3550         }
3551       else
3552         {
3553           tlsreg = gen_rtx_REG (Pmode, 2);
3554           insn = gen_tls_tprel_32 (dest, tlsreg, addr);
3555         }
3556       emit_insn (insn);
3557     }
3558   else if (model == TLS_MODEL_LOCAL_EXEC && rs6000_tls_size == 32)
3559     {
3560       rtx tlsreg, tmp;
3561
3562       tmp = gen_reg_rtx (Pmode);
3563       if (TARGET_64BIT)
3564         {
3565           tlsreg = gen_rtx_REG (Pmode, 13);
3566           insn = gen_tls_tprel_ha_64 (tmp, tlsreg, addr);
3567         }
3568       else
3569         {
3570           tlsreg = gen_rtx_REG (Pmode, 2);
3571           insn = gen_tls_tprel_ha_32 (tmp, tlsreg, addr);
3572         }
3573       emit_insn (insn);
3574       if (TARGET_64BIT)
3575         insn = gen_tls_tprel_lo_64 (dest, tmp, addr);
3576       else
3577         insn = gen_tls_tprel_lo_32 (dest, tmp, addr);
3578       emit_insn (insn);
3579     }
3580   else
3581     {
3582       rtx r3, got, tga, tmp1, tmp2, eqv;
3583
3584       /* We currently use relocations like @got@tlsgd for tls, which
3585          means the linker will handle allocation of tls entries, placing
3586          them in the .got section.  So use a pointer to the .got section,
3587          not one to secondary TOC sections used by 64-bit -mminimal-toc,
3588          or to secondary GOT sections used by 32-bit -fPIC.  */
3589       if (TARGET_64BIT)
3590         got = gen_rtx_REG (Pmode, 2);
3591       else
3592         {
3593           if (flag_pic == 1)
3594             got = gen_rtx_REG (Pmode, RS6000_PIC_OFFSET_TABLE_REGNUM);
3595           else
3596             {
3597               rtx gsym = rs6000_got_sym ();
3598               got = gen_reg_rtx (Pmode);
3599               if (flag_pic == 0)
3600                 rs6000_emit_move (got, gsym, Pmode);
3601               else
3602                 {
3603                   rtx tmp3, mem;
3604                   rtx first, last;
3605
3606                   tmp1 = gen_reg_rtx (Pmode);
3607                   tmp2 = gen_reg_rtx (Pmode);
3608                   tmp3 = gen_reg_rtx (Pmode);
3609                   mem = gen_const_mem (Pmode, tmp1);
3610
3611                   first = emit_insn (gen_load_toc_v4_PIC_1b (gsym));
3612                   emit_move_insn (tmp1,
3613                                   gen_rtx_REG (Pmode, LR_REGNO));
3614                   emit_move_insn (tmp2, mem);
3615                   emit_insn (gen_addsi3 (tmp3, tmp1, tmp2));
3616                   last = emit_move_insn (got, tmp3);
3617                   set_unique_reg_note (last, REG_EQUAL, gsym);
3618                   maybe_encapsulate_block (first, last, gsym);
3619                 }
3620             }
3621         }
3622
3623       if (model == TLS_MODEL_GLOBAL_DYNAMIC)
3624         {
3625           r3 = gen_rtx_REG (Pmode, 3);
3626           if (TARGET_64BIT)
3627             insn = gen_tls_gd_64 (r3, got, addr);
3628           else
3629             insn = gen_tls_gd_32 (r3, got, addr);
3630           start_sequence ();
3631           emit_insn (insn);
3632           tga = gen_rtx_MEM (Pmode, rs6000_tls_get_addr ());
3633           insn = gen_call_value (r3, tga, const0_rtx, const0_rtx);
3634           insn = emit_call_insn (insn);
3635           CONST_OR_PURE_CALL_P (insn) = 1;
3636           use_reg (&CALL_INSN_FUNCTION_USAGE (insn), r3);
3637           insn = get_insns ();
3638           end_sequence ();
3639           emit_libcall_block (insn, dest, r3, addr);
3640         }
3641       else if (model == TLS_MODEL_LOCAL_DYNAMIC)
3642         {
3643           r3 = gen_rtx_REG (Pmode, 3);
3644           if (TARGET_64BIT)
3645             insn = gen_tls_ld_64 (r3, got);
3646           else
3647             insn = gen_tls_ld_32 (r3, got);
3648           start_sequence ();
3649           emit_insn (insn);
3650           tga = gen_rtx_MEM (Pmode, rs6000_tls_get_addr ());
3651           insn = gen_call_value (r3, tga, const0_rtx, const0_rtx);
3652           insn = emit_call_insn (insn);
3653           CONST_OR_PURE_CALL_P (insn) = 1;
3654           use_reg (&CALL_INSN_FUNCTION_USAGE (insn), r3);
3655           insn = get_insns ();
3656           end_sequence ();
3657           tmp1 = gen_reg_rtx (Pmode);
3658           eqv = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
3659                                 UNSPEC_TLSLD);
3660           emit_libcall_block (insn, tmp1, r3, eqv);
3661           if (rs6000_tls_size == 16)
3662             {
3663               if (TARGET_64BIT)
3664                 insn = gen_tls_dtprel_64 (dest, tmp1, addr);
3665               else
3666                 insn = gen_tls_dtprel_32 (dest, tmp1, addr);
3667             }
3668           else if (rs6000_tls_size == 32)
3669             {
3670               tmp2 = gen_reg_rtx (Pmode);
3671               if (TARGET_64BIT)
3672                 insn = gen_tls_dtprel_ha_64 (tmp2, tmp1, addr);
3673               else
3674                 insn = gen_tls_dtprel_ha_32 (tmp2, tmp1, addr);
3675               emit_insn (insn);
3676               if (TARGET_64BIT)
3677                 insn = gen_tls_dtprel_lo_64 (dest, tmp2, addr);
3678               else
3679                 insn = gen_tls_dtprel_lo_32 (dest, tmp2, addr);
3680             }
3681           else
3682             {
3683               tmp2 = gen_reg_rtx (Pmode);
3684               if (TARGET_64BIT)
3685                 insn = gen_tls_got_dtprel_64 (tmp2, got, addr);
3686               else
3687                 insn = gen_tls_got_dtprel_32 (tmp2, got, addr);
3688               emit_insn (insn);
3689               insn = gen_rtx_SET (Pmode, dest,
3690                                   gen_rtx_PLUS (Pmode, tmp2, tmp1));
3691             }
3692           emit_insn (insn);
3693         }
3694       else
3695         {
3696           /* IE, or 64-bit offset LE.  */
3697           tmp2 = gen_reg_rtx (Pmode);
3698           if (TARGET_64BIT)
3699             insn = gen_tls_got_tprel_64 (tmp2, got, addr);
3700           else
3701             insn = gen_tls_got_tprel_32 (tmp2, got, addr);
3702           emit_insn (insn);
3703           if (TARGET_64BIT)
3704             insn = gen_tls_tls_64 (dest, tmp2, addr);
3705           else
3706             insn = gen_tls_tls_32 (dest, tmp2, addr);
3707           emit_insn (insn);
3708         }
3709     }
3710
3711   return dest;
3712 }
3713
3714 /* Return 1 if X contains a thread-local symbol.  */
3715
3716 bool
3717 rs6000_tls_referenced_p (rtx x)
3718 {
3719   if (! TARGET_HAVE_TLS)
3720     return false;
3721
3722   return for_each_rtx (&x, &rs6000_tls_symbol_ref_1, 0);
3723 }
3724
3725 /* Return 1 if *X is a thread-local symbol.  This is the same as
3726    rs6000_tls_symbol_ref except for the type of the unused argument.  */
3727
3728 static int
3729 rs6000_tls_symbol_ref_1 (rtx *x, void *data ATTRIBUTE_UNUSED)
3730 {
3731   return RS6000_SYMBOL_REF_TLS_P (*x);
3732 }
3733
3734 /* The convention appears to be to define this wherever it is used.
3735    With legitimize_reload_address now defined here, REG_MODE_OK_FOR_BASE_P
3736    is now used here.  */
3737 #ifndef REG_MODE_OK_FOR_BASE_P
3738 #define REG_MODE_OK_FOR_BASE_P(REGNO, MODE) REG_OK_FOR_BASE_P (REGNO)
3739 #endif
3740
3741 /* Our implementation of LEGITIMIZE_RELOAD_ADDRESS.  Returns a value to
3742    replace the input X, or the original X if no replacement is called for.
3743    The output parameter *WIN is 1 if the calling macro should goto WIN,
3744    0 if it should not.
3745
3746    For RS/6000, we wish to handle large displacements off a base
3747    register by splitting the addend across an addiu/addis and the mem insn.
3748    This cuts number of extra insns needed from 3 to 1.
3749
3750    On Darwin, we use this to generate code for floating point constants.
3751    A movsf_low is generated so we wind up with 2 instructions rather than 3.
3752    The Darwin code is inside #if TARGET_MACHO because only then is
3753    machopic_function_base_name() defined.  */
3754 rtx
3755 rs6000_legitimize_reload_address (rtx x, enum machine_mode mode,
3756                                   int opnum, int type,
3757                                   int ind_levels ATTRIBUTE_UNUSED, int *win)
3758 {
3759   /* We must recognize output that we have already generated ourselves.  */
3760   if (GET_CODE (x) == PLUS
3761       && GET_CODE (XEXP (x, 0)) == PLUS
3762       && GET_CODE (XEXP (XEXP (x, 0), 0)) == REG
3763       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
3764       && GET_CODE (XEXP (x, 1)) == CONST_INT)
3765     {
3766       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
3767                    BASE_REG_CLASS, GET_MODE (x), VOIDmode, 0, 0,
3768                    opnum, (enum reload_type)type);
3769       *win = 1;
3770       return x;
3771     }
3772
3773 #if TARGET_MACHO
3774   if (DEFAULT_ABI == ABI_DARWIN && flag_pic
3775       && GET_CODE (x) == LO_SUM
3776       && GET_CODE (XEXP (x, 0)) == PLUS
3777       && XEXP (XEXP (x, 0), 0) == pic_offset_table_rtx
3778       && GET_CODE (XEXP (XEXP (x, 0), 1)) == HIGH
3779       && GET_CODE (XEXP (XEXP (XEXP (x, 0), 1), 0)) == CONST
3780       && XEXP (XEXP (XEXP (x, 0), 1), 0) == XEXP (x, 1)
3781       && GET_CODE (XEXP (XEXP (x, 1), 0)) == MINUS
3782       && GET_CODE (XEXP (XEXP (XEXP (x, 1), 0), 0)) == SYMBOL_REF
3783       && GET_CODE (XEXP (XEXP (XEXP (x, 1), 0), 1)) == SYMBOL_REF)
3784     {
3785       /* Result of previous invocation of this function on Darwin
3786          floating point constant.  */
3787       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
3788                    BASE_REG_CLASS, Pmode, VOIDmode, 0, 0,
3789                    opnum, (enum reload_type)type);
3790       *win = 1;
3791       return x;
3792     }
3793 #endif
3794
3795   /* Force ld/std non-word aligned offset into base register by wrapping
3796      in offset 0.  */
3797   if (GET_CODE (x) == PLUS
3798       && GET_CODE (XEXP (x, 0)) == REG
3799       && REGNO (XEXP (x, 0)) < 32
3800       && REG_MODE_OK_FOR_BASE_P (XEXP (x, 0), mode)
3801       && GET_CODE (XEXP (x, 1)) == CONST_INT
3802       && (INTVAL (XEXP (x, 1)) & 3) != 0
3803       && !ALTIVEC_VECTOR_MODE (mode)
3804       && GET_MODE_SIZE (mode) >= UNITS_PER_WORD
3805       && TARGET_POWERPC64)
3806     {
3807       x = gen_rtx_PLUS (GET_MODE (x), x, GEN_INT (0));
3808       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
3809                    BASE_REG_CLASS, GET_MODE (x), VOIDmode, 0, 0,
3810                    opnum, (enum reload_type) type);
3811       *win = 1;
3812       return x;
3813     }
3814
3815   if (GET_CODE (x) == PLUS
3816       && GET_CODE (XEXP (x, 0)) == REG
3817       && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER
3818       && REG_MODE_OK_FOR_BASE_P (XEXP (x, 0), mode)
3819       && GET_CODE (XEXP (x, 1)) == CONST_INT
3820       && !SPE_VECTOR_MODE (mode)
3821       && !(TARGET_E500_DOUBLE && (mode == DFmode || mode == TFmode
3822                                   || mode == DImode))
3823       && !ALTIVEC_VECTOR_MODE (mode))
3824     {
3825       HOST_WIDE_INT val = INTVAL (XEXP (x, 1));
3826       HOST_WIDE_INT low = ((val & 0xffff) ^ 0x8000) - 0x8000;
3827       HOST_WIDE_INT high
3828         = (((val - low) & 0xffffffff) ^ 0x80000000) - 0x80000000;
3829
3830       /* Check for 32-bit overflow.  */
3831       if (high + low != val)
3832         {
3833           *win = 0;
3834           return x;
3835         }
3836
3837       /* Reload the high part into a base reg; leave the low part
3838          in the mem directly.  */
3839
3840       x = gen_rtx_PLUS (GET_MODE (x),
3841                         gen_rtx_PLUS (GET_MODE (x), XEXP (x, 0),
3842                                       GEN_INT (high)),
3843                         GEN_INT (low));
3844
3845       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
3846                    BASE_REG_CLASS, GET_MODE (x), VOIDmode, 0, 0,
3847                    opnum, (enum reload_type)type);
3848       *win = 1;
3849       return x;
3850     }
3851
3852   if (GET_CODE (x) == SYMBOL_REF
3853       && !ALTIVEC_VECTOR_MODE (mode)
3854       && !SPE_VECTOR_MODE (mode)
3855 #if TARGET_MACHO
3856       && DEFAULT_ABI == ABI_DARWIN
3857       && (flag_pic || MACHO_DYNAMIC_NO_PIC_P)
3858 #else
3859       && DEFAULT_ABI == ABI_V4
3860       && !flag_pic
3861 #endif
3862       /* Don't do this for TFmode or TDmode, since the result isn't offsettable.
3863          The same goes for DImode without 64-bit gprs and DFmode
3864          without fprs.  */
3865       && mode != TFmode
3866       && mode != TDmode
3867       && (mode != DImode || TARGET_POWERPC64)
3868       && (mode != DFmode || TARGET_POWERPC64
3869           || (TARGET_FPRS && TARGET_HARD_FLOAT)))
3870     {
3871 #if TARGET_MACHO
3872       if (flag_pic)
3873         {
3874           rtx offset = gen_rtx_CONST (Pmode,
3875                          gen_rtx_MINUS (Pmode, x,
3876                                         machopic_function_base_sym ()));
3877           x = gen_rtx_LO_SUM (GET_MODE (x),
3878                 gen_rtx_PLUS (Pmode, pic_offset_table_rtx,
3879                   gen_rtx_HIGH (Pmode, offset)), offset);
3880         }
3881       else
3882 #endif
3883         x = gen_rtx_LO_SUM (GET_MODE (x),
3884               gen_rtx_HIGH (Pmode, x), x);
3885
3886       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
3887                    BASE_REG_CLASS, Pmode, VOIDmode, 0, 0,
3888                    opnum, (enum reload_type)type);
3889       *win = 1;
3890       return x;
3891     }
3892
3893   /* Reload an offset address wrapped by an AND that represents the
3894      masking of the lower bits.  Strip the outer AND and let reload
3895      convert the offset address into an indirect address.  */
3896   if (TARGET_ALTIVEC
3897       && ALTIVEC_VECTOR_MODE (mode)
3898       && GET_CODE (x) == AND
3899       && GET_CODE (XEXP (x, 0)) == PLUS
3900       && GET_CODE (XEXP (XEXP (x, 0), 0)) == REG
3901       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
3902       && GET_CODE (XEXP (x, 1)) == CONST_INT
3903       && INTVAL (XEXP (x, 1)) == -16)
3904     {
3905       x = XEXP (x, 0);
3906       *win = 1;
3907       return x;
3908     }
3909
3910   if (TARGET_TOC
3911       && constant_pool_expr_p (x)
3912       && ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (get_pool_constant (x), mode))
3913     {
3914       x = create_TOC_reference (x);
3915       *win = 1;
3916       return x;
3917     }
3918   *win = 0;
3919   return x;
3920 }
3921
3922 /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression
3923    that is a valid memory address for an instruction.
3924    The MODE argument is the machine mode for the MEM expression
3925    that wants to use this address.
3926
3927    On the RS/6000, there are four valid address: a SYMBOL_REF that
3928    refers to a constant pool entry of an address (or the sum of it
3929    plus a constant), a short (16-bit signed) constant plus a register,
3930    the sum of two registers, or a register indirect, possibly with an
3931    auto-increment.  For DFmode and DImode with a constant plus register,
3932    we must ensure that both words are addressable or PowerPC64 with offset
3933    word aligned.
3934
3935    For modes spanning multiple registers (DFmode in 32-bit GPRs,
3936    32-bit DImode, TImode, TFmode, TDmode), indexed addressing cannot be used
3937    because adjacent memory cells are accessed by adding word-sized offsets
3938    during assembly output.  */
3939 int
3940 rs6000_legitimate_address (enum machine_mode mode, rtx x, int reg_ok_strict)
3941 {
3942   /* If this is an unaligned stvx/ldvx type address, discard the outer AND.  */
3943   if (TARGET_ALTIVEC
3944       && ALTIVEC_VECTOR_MODE (mode)
3945       && GET_CODE (x) == AND
3946       && GET_CODE (XEXP (x, 1)) == CONST_INT
3947       && INTVAL (XEXP (x, 1)) == -16)
3948     x = XEXP (x, 0);
3949
3950   if (RS6000_SYMBOL_REF_TLS_P (x))
3951     return 0;
3952   if (legitimate_indirect_address_p (x, reg_ok_strict))
3953     return 1;
3954   if ((GET_CODE (x) == PRE_INC || GET_CODE (x) == PRE_DEC)
3955       && !ALTIVEC_VECTOR_MODE (mode)
3956       && !SPE_VECTOR_MODE (mode)
3957       && mode != TFmode
3958       && mode != TDmode
3959       /* Restrict addressing for DI because of our SUBREG hackery.  */
3960       && !(TARGET_E500_DOUBLE && (mode == DFmode || mode == TFmode
3961                                   || mode == DImode))
3962       && TARGET_UPDATE
3963       && legitimate_indirect_address_p (XEXP (x, 0), reg_ok_strict))
3964     return 1;
3965   if (legitimate_small_data_p (mode, x))
3966     return 1;
3967   if (legitimate_constant_pool_address_p (x))
3968     return 1;
3969   /* If not REG_OK_STRICT (before reload) let pass any stack offset.  */
3970   if (! reg_ok_strict
3971       && GET_CODE (x) == PLUS
3972       && GET_CODE (XEXP (x, 0)) == REG
3973       && (XEXP (x, 0) == virtual_stack_vars_rtx
3974           || XEXP (x, 0) == arg_pointer_rtx)
3975       && GET_CODE (XEXP (x, 1)) == CONST_INT)
3976     return 1;
3977   if (rs6000_legitimate_offset_address_p (mode, x, reg_ok_strict))
3978     return 1;
3979   if (mode != TImode
3980       && mode != TFmode
3981       && mode != TDmode
3982       && ((TARGET_HARD_FLOAT && TARGET_FPRS)
3983           || TARGET_POWERPC64
3984           || ((mode != DFmode || TARGET_E500_DOUBLE) && mode != TFmode))
3985       && (TARGET_POWERPC64 || mode != DImode)
3986       && legitimate_indexed_address_p (x, reg_ok_strict))
3987     return 1;
3988   if (GET_CODE (x) == PRE_MODIFY
3989       && mode != TImode
3990       && mode != TFmode
3991       && mode != TDmode
3992       && ((TARGET_HARD_FLOAT && TARGET_FPRS)
3993           || TARGET_POWERPC64
3994           || ((mode != DFmode || TARGET_E500_DOUBLE) && mode != TFmode))
3995       && (TARGET_POWERPC64 || mode != DImode)
3996       && !ALTIVEC_VECTOR_MODE (mode)
3997       && !SPE_VECTOR_MODE (mode)
3998       /* Restrict addressing for DI because of our SUBREG hackery.  */
3999       && !(TARGET_E500_DOUBLE && (mode == DFmode || mode == DImode))
4000       && TARGET_UPDATE
4001       && legitimate_indirect_address_p (XEXP (x, 0), reg_ok_strict)
4002       && (rs6000_legitimate_offset_address_p (mode, XEXP (x, 1), reg_ok_strict)
4003           || legitimate_indexed_address_p (XEXP (x, 1), reg_ok_strict))
4004       && rtx_equal_p (XEXP (XEXP (x, 1), 0), XEXP (x, 0)))
4005     return 1;
4006   if (legitimate_lo_sum_address_p (mode, x, reg_ok_strict))
4007     return 1;
4008   return 0;