OSDN Git Service

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