OSDN Git Service

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