OSDN Git Service

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