OSDN Git Service

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