OSDN Git Service

9bae3f8b24d4b0c7947bfe836a2f5de00388128d
[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          {"power6", PROCESSOR_POWER5,
1198           POWERPC_7400_MASK | MASK_POWERPC64 | MASK_MFCRF | MASK_POPCNTB
1199           | MASK_FPRND},
1200          {"powerpc", PROCESSOR_POWERPC, POWERPC_BASE_MASK},
1201          {"powerpc64", PROCESSOR_POWERPC64,
1202           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
1203          {"rios", PROCESSOR_RIOS1, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
1204          {"rios1", PROCESSOR_RIOS1, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
1205          {"rios2", PROCESSOR_RIOS2,
1206           MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING},
1207          {"rsc", PROCESSOR_PPC601, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
1208          {"rsc1", PROCESSOR_PPC601, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
1209          {"rs64", PROCESSOR_RS64A,
1210           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64}
1211       };
1212
1213   const size_t ptt_size = ARRAY_SIZE (processor_target_table);
1214
1215   /* Some OSs don't support saving the high part of 64-bit registers on
1216      context switch.  Other OSs don't support saving Altivec registers.
1217      On those OSs, we don't touch the MASK_POWERPC64 or MASK_ALTIVEC
1218      settings; if the user wants either, the user must explicitly specify
1219      them and we won't interfere with the user's specification.  */
1220
1221   enum {
1222     POWER_MASKS = MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING,
1223     POWERPC_MASKS = (POWERPC_BASE_MASK | MASK_PPC_GPOPT
1224                      | MASK_PPC_GFXOPT | MASK_POWERPC64 | MASK_ALTIVEC
1225                      | MASK_MFCRF | MASK_POPCNTB | MASK_FPRND | MASK_MULHW
1226                      | MASK_DLMZB)
1227   };
1228
1229   rs6000_init_hard_regno_mode_ok ();
1230
1231   set_masks = POWER_MASKS | POWERPC_MASKS | MASK_SOFT_FLOAT;
1232 #ifdef OS_MISSING_POWERPC64
1233   if (OS_MISSING_POWERPC64)
1234     set_masks &= ~MASK_POWERPC64;
1235 #endif
1236 #ifdef OS_MISSING_ALTIVEC
1237   if (OS_MISSING_ALTIVEC)
1238     set_masks &= ~MASK_ALTIVEC;
1239 #endif
1240
1241   /* Don't override by the processor default if given explicitly.  */
1242   set_masks &= ~target_flags_explicit;
1243
1244   /* Identify the processor type.  */
1245   rs6000_select[0].string = default_cpu;
1246   rs6000_cpu = TARGET_POWERPC64 ? PROCESSOR_DEFAULT64 : PROCESSOR_DEFAULT;
1247
1248   for (i = 0; i < ARRAY_SIZE (rs6000_select); i++)
1249     {
1250       ptr = &rs6000_select[i];
1251       if (ptr->string != (char *)0 && ptr->string[0] != '\0')
1252         {
1253           for (j = 0; j < ptt_size; j++)
1254             if (! strcmp (ptr->string, processor_target_table[j].name))
1255               {
1256                 if (ptr->set_tune_p)
1257                   rs6000_cpu = processor_target_table[j].processor;
1258
1259                 if (ptr->set_arch_p)
1260                   {
1261                     target_flags &= ~set_masks;
1262                     target_flags |= (processor_target_table[j].target_enable
1263                                      & set_masks);
1264                   }
1265                 break;
1266               }
1267
1268           if (j == ptt_size)
1269             error ("bad value (%s) for %s switch", ptr->string, ptr->name);
1270         }
1271     }
1272
1273   if (TARGET_E500)
1274     rs6000_isel = 1;
1275
1276   /* If we are optimizing big endian systems for space, use the load/store
1277      multiple and string instructions.  */
1278   if (BYTES_BIG_ENDIAN && optimize_size)
1279     target_flags |= ~target_flags_explicit & (MASK_MULTIPLE | MASK_STRING);
1280
1281   /* Don't allow -mmultiple or -mstring on little endian systems
1282      unless the cpu is a 750, because the hardware doesn't support the
1283      instructions used in little endian mode, and causes an alignment
1284      trap.  The 750 does not cause an alignment trap (except when the
1285      target is unaligned).  */
1286
1287   if (!BYTES_BIG_ENDIAN && rs6000_cpu != PROCESSOR_PPC750)
1288     {
1289       if (TARGET_MULTIPLE)
1290         {
1291           target_flags &= ~MASK_MULTIPLE;
1292           if ((target_flags_explicit & MASK_MULTIPLE) != 0)
1293             warning (0, "-mmultiple is not supported on little endian systems");
1294         }
1295
1296       if (TARGET_STRING)
1297         {
1298           target_flags &= ~MASK_STRING;
1299           if ((target_flags_explicit & MASK_STRING) != 0)
1300             warning (0, "-mstring is not supported on little endian systems");
1301         }
1302     }
1303
1304   /* Set debug flags */
1305   if (rs6000_debug_name)
1306     {
1307       if (! strcmp (rs6000_debug_name, "all"))
1308         rs6000_debug_stack = rs6000_debug_arg = 1;
1309       else if (! strcmp (rs6000_debug_name, "stack"))
1310         rs6000_debug_stack = 1;
1311       else if (! strcmp (rs6000_debug_name, "arg"))
1312         rs6000_debug_arg = 1;
1313       else
1314         error ("unknown -mdebug-%s switch", rs6000_debug_name);
1315     }
1316
1317   if (rs6000_traceback_name)
1318     {
1319       if (! strncmp (rs6000_traceback_name, "full", 4))
1320         rs6000_traceback = traceback_full;
1321       else if (! strncmp (rs6000_traceback_name, "part", 4))
1322         rs6000_traceback = traceback_part;
1323       else if (! strncmp (rs6000_traceback_name, "no", 2))
1324         rs6000_traceback = traceback_none;
1325       else
1326         error ("unknown -mtraceback arg %qs; expecting %<full%>, %<partial%> or %<none%>",
1327                rs6000_traceback_name);
1328     }
1329
1330   if (!rs6000_explicit_options.long_double)
1331     rs6000_long_double_type_size = RS6000_DEFAULT_LONG_DOUBLE_SIZE;
1332
1333 #ifndef POWERPC_LINUX
1334   if (!rs6000_explicit_options.ieee)
1335     rs6000_ieeequad = 1;
1336 #endif
1337
1338   /* Set Altivec ABI as default for powerpc64 linux.  */
1339   if (TARGET_ELF && TARGET_64BIT)
1340     {
1341       rs6000_altivec_abi = 1;
1342       TARGET_ALTIVEC_VRSAVE = 1;
1343     }
1344
1345   /* Set the Darwin64 ABI as default for 64-bit Darwin.  */
1346   if (DEFAULT_ABI == ABI_DARWIN && TARGET_64BIT)
1347     {
1348       rs6000_darwin64_abi = 1;
1349 #if TARGET_MACHO
1350       darwin_one_byte_bool = 1;
1351 #endif
1352       /* Default to natural alignment, for better performance.  */
1353       rs6000_alignment_flags = MASK_ALIGN_NATURAL;
1354     }
1355
1356   /* Place FP constants in the constant pool instead of TOC
1357      if section anchors enabled.  */
1358   if (flag_section_anchors)
1359     TARGET_NO_FP_IN_TOC = 1;
1360
1361   /* Handle -mtls-size option.  */
1362   rs6000_parse_tls_size_option ();
1363
1364 #ifdef SUBTARGET_OVERRIDE_OPTIONS
1365   SUBTARGET_OVERRIDE_OPTIONS;
1366 #endif
1367 #ifdef SUBSUBTARGET_OVERRIDE_OPTIONS
1368   SUBSUBTARGET_OVERRIDE_OPTIONS;
1369 #endif
1370 #ifdef SUB3TARGET_OVERRIDE_OPTIONS
1371   SUB3TARGET_OVERRIDE_OPTIONS;
1372 #endif
1373
1374   if (TARGET_E500)
1375     {
1376       if (TARGET_ALTIVEC)
1377         error ("AltiVec and E500 instructions cannot coexist");
1378
1379       /* The e500 does not have string instructions, and we set
1380          MASK_STRING above when optimizing for size.  */
1381       if ((target_flags & MASK_STRING) != 0)
1382         target_flags = target_flags & ~MASK_STRING;
1383     }
1384   else if (rs6000_select[1].string != NULL)
1385     {
1386       /* For the powerpc-eabispe configuration, we set all these by
1387          default, so let's unset them if we manually set another
1388          CPU that is not the E500.  */
1389       if (!rs6000_explicit_options.abi)
1390         rs6000_spe_abi = 0;
1391       if (!rs6000_explicit_options.spe)
1392         rs6000_spe = 0;
1393       if (!rs6000_explicit_options.float_gprs)
1394         rs6000_float_gprs = 0;
1395       if (!rs6000_explicit_options.isel)
1396         rs6000_isel = 0;
1397       if (!rs6000_explicit_options.long_double)
1398         rs6000_long_double_type_size = RS6000_DEFAULT_LONG_DOUBLE_SIZE;
1399     }
1400
1401   rs6000_always_hint = (rs6000_cpu != PROCESSOR_POWER4
1402                         && rs6000_cpu != PROCESSOR_POWER5);
1403   rs6000_sched_groups = (rs6000_cpu == PROCESSOR_POWER4
1404                          || rs6000_cpu == PROCESSOR_POWER5);
1405
1406   rs6000_sched_restricted_insns_priority
1407     = (rs6000_sched_groups ? 1 : 0);
1408
1409   /* Handle -msched-costly-dep option.  */
1410   rs6000_sched_costly_dep
1411     = (rs6000_sched_groups ? store_to_load_dep_costly : no_dep_costly);
1412
1413   if (rs6000_sched_costly_dep_str)
1414     {
1415       if (! strcmp (rs6000_sched_costly_dep_str, "no"))
1416         rs6000_sched_costly_dep = no_dep_costly;
1417       else if (! strcmp (rs6000_sched_costly_dep_str, "all"))
1418         rs6000_sched_costly_dep = all_deps_costly;
1419       else if (! strcmp (rs6000_sched_costly_dep_str, "true_store_to_load"))
1420         rs6000_sched_costly_dep = true_store_to_load_dep_costly;
1421       else if (! strcmp (rs6000_sched_costly_dep_str, "store_to_load"))
1422         rs6000_sched_costly_dep = store_to_load_dep_costly;
1423       else
1424         rs6000_sched_costly_dep = atoi (rs6000_sched_costly_dep_str);
1425     }
1426
1427   /* Handle -minsert-sched-nops option.  */
1428   rs6000_sched_insert_nops
1429     = (rs6000_sched_groups ? sched_finish_regroup_exact : sched_finish_none);
1430
1431   if (rs6000_sched_insert_nops_str)
1432     {
1433       if (! strcmp (rs6000_sched_insert_nops_str, "no"))
1434         rs6000_sched_insert_nops = sched_finish_none;
1435       else if (! strcmp (rs6000_sched_insert_nops_str, "pad"))
1436         rs6000_sched_insert_nops = sched_finish_pad_groups;
1437       else if (! strcmp (rs6000_sched_insert_nops_str, "regroup_exact"))
1438         rs6000_sched_insert_nops = sched_finish_regroup_exact;
1439       else
1440         rs6000_sched_insert_nops = atoi (rs6000_sched_insert_nops_str);
1441     }
1442
1443 #ifdef TARGET_REGNAMES
1444   /* If the user desires alternate register names, copy in the
1445      alternate names now.  */
1446   if (TARGET_REGNAMES)
1447     memcpy (rs6000_reg_names, alt_reg_names, sizeof (rs6000_reg_names));
1448 #endif
1449
1450   /* Set aix_struct_return last, after the ABI is determined.
1451      If -maix-struct-return or -msvr4-struct-return was explicitly
1452      used, don't override with the ABI default.  */
1453   if (!rs6000_explicit_options.aix_struct_ret)
1454     aix_struct_return = (DEFAULT_ABI != ABI_V4 || DRAFT_V4_STRUCT_RET);
1455
1456   if (TARGET_LONG_DOUBLE_128 && !TARGET_IEEEQUAD)
1457     REAL_MODE_FORMAT (TFmode) = &ibm_extended_format;
1458
1459   if (TARGET_TOC)
1460     ASM_GENERATE_INTERNAL_LABEL (toc_label_name, "LCTOC", 1);
1461
1462   /* We can only guarantee the availability of DI pseudo-ops when
1463      assembling for 64-bit targets.  */
1464   if (!TARGET_64BIT)
1465     {
1466       targetm.asm_out.aligned_op.di = NULL;
1467       targetm.asm_out.unaligned_op.di = NULL;
1468     }
1469
1470   /* Set branch target alignment, if not optimizing for size.  */
1471   if (!optimize_size)
1472     {
1473       if (rs6000_sched_groups)
1474         {
1475           if (align_functions <= 0)
1476             align_functions = 16;
1477           if (align_jumps <= 0)
1478             align_jumps = 16;
1479           if (align_loops <= 0)
1480             align_loops = 16;
1481         }
1482       if (align_jumps_max_skip <= 0)
1483         align_jumps_max_skip = 15;
1484       if (align_loops_max_skip <= 0)
1485         align_loops_max_skip = 15;
1486     }
1487
1488   /* Arrange to save and restore machine status around nested functions.  */
1489   init_machine_status = rs6000_init_machine_status;
1490
1491   /* We should always be splitting complex arguments, but we can't break
1492      Linux and Darwin ABIs at the moment.  For now, only AIX is fixed.  */
1493   if (DEFAULT_ABI != ABI_AIX)
1494     targetm.calls.split_complex_arg = NULL;
1495
1496   /* Initialize rs6000_cost with the appropriate target costs.  */
1497   if (optimize_size)
1498     rs6000_cost = TARGET_POWERPC64 ? &size64_cost : &size32_cost;
1499   else
1500     switch (rs6000_cpu)
1501       {
1502       case PROCESSOR_RIOS1:
1503         rs6000_cost = &rios1_cost;
1504         break;
1505
1506       case PROCESSOR_RIOS2:
1507         rs6000_cost = &rios2_cost;
1508         break;
1509
1510       case PROCESSOR_RS64A:
1511         rs6000_cost = &rs64a_cost;
1512         break;
1513
1514       case PROCESSOR_MPCCORE:
1515         rs6000_cost = &mpccore_cost;
1516         break;
1517
1518       case PROCESSOR_PPC403:
1519         rs6000_cost = &ppc403_cost;
1520         break;
1521
1522       case PROCESSOR_PPC405:
1523         rs6000_cost = &ppc405_cost;
1524         break;
1525
1526       case PROCESSOR_PPC440:
1527         rs6000_cost = &ppc440_cost;
1528         break;
1529
1530       case PROCESSOR_PPC601:
1531         rs6000_cost = &ppc601_cost;
1532         break;
1533
1534       case PROCESSOR_PPC603:
1535         rs6000_cost = &ppc603_cost;
1536         break;
1537
1538       case PROCESSOR_PPC604:
1539         rs6000_cost = &ppc604_cost;
1540         break;
1541
1542       case PROCESSOR_PPC604e:
1543         rs6000_cost = &ppc604e_cost;
1544         break;
1545
1546       case PROCESSOR_PPC620:
1547         rs6000_cost = &ppc620_cost;
1548         break;
1549
1550       case PROCESSOR_PPC630:
1551         rs6000_cost = &ppc630_cost;
1552         break;
1553
1554       case PROCESSOR_PPC750:
1555       case PROCESSOR_PPC7400:
1556         rs6000_cost = &ppc750_cost;
1557         break;
1558
1559       case PROCESSOR_PPC7450:
1560         rs6000_cost = &ppc7450_cost;
1561         break;
1562
1563       case PROCESSOR_PPC8540:
1564         rs6000_cost = &ppc8540_cost;
1565         break;
1566
1567       case PROCESSOR_POWER4:
1568       case PROCESSOR_POWER5:
1569         rs6000_cost = &power4_cost;
1570         break;
1571
1572       default:
1573         gcc_unreachable ();
1574       }
1575 }
1576
1577 /* Implement targetm.vectorize.builtin_mask_for_load.  */
1578 static tree
1579 rs6000_builtin_mask_for_load (void)
1580 {
1581   if (TARGET_ALTIVEC)
1582     return altivec_builtin_mask_for_load;
1583   else
1584     return 0;
1585 }
1586
1587 /* Handle generic options of the form -mfoo=yes/no.
1588    NAME is the option name.
1589    VALUE is the option value.
1590    FLAG is the pointer to the flag where to store a 1 or 0, depending on
1591    whether the option value is 'yes' or 'no' respectively.  */
1592 static void
1593 rs6000_parse_yes_no_option (const char *name, const char *value, int *flag)
1594 {
1595   if (value == 0)
1596     return;
1597   else if (!strcmp (value, "yes"))
1598     *flag = 1;
1599   else if (!strcmp (value, "no"))
1600     *flag = 0;
1601   else
1602     error ("unknown -m%s= option specified: '%s'", name, value);
1603 }
1604
1605 /* Validate and record the size specified with the -mtls-size option.  */
1606
1607 static void
1608 rs6000_parse_tls_size_option (void)
1609 {
1610   if (rs6000_tls_size_string == 0)
1611     return;
1612   else if (strcmp (rs6000_tls_size_string, "16") == 0)
1613     rs6000_tls_size = 16;
1614   else if (strcmp (rs6000_tls_size_string, "32") == 0)
1615     rs6000_tls_size = 32;
1616   else if (strcmp (rs6000_tls_size_string, "64") == 0)
1617     rs6000_tls_size = 64;
1618   else
1619     error ("bad value %qs for -mtls-size switch", rs6000_tls_size_string);
1620 }
1621
1622 void
1623 optimization_options (int level ATTRIBUTE_UNUSED, int size ATTRIBUTE_UNUSED)
1624 {
1625   if (DEFAULT_ABI == ABI_DARWIN)
1626     /* The Darwin libraries never set errno, so we might as well
1627        avoid calling them when that's the only reason we would.  */
1628     flag_errno_math = 0;
1629
1630   /* Double growth factor to counter reduced min jump length.  */
1631   set_param_value ("max-grow-copy-bb-insns", 16);
1632
1633   /* Enable section anchors by default.
1634      Skip section anchors for Objective C and Objective C++
1635      until front-ends fixed.  */
1636   if (!TARGET_MACHO && lang_hooks.name[4] != 'O')
1637     flag_section_anchors = 1;
1638 }
1639
1640 /* Implement TARGET_HANDLE_OPTION.  */
1641
1642 static bool
1643 rs6000_handle_option (size_t code, const char *arg, int value)
1644 {
1645   switch (code)
1646     {
1647     case OPT_mno_power:
1648       target_flags &= ~(MASK_POWER | MASK_POWER2
1649                         | MASK_MULTIPLE | MASK_STRING);
1650       target_flags_explicit |= (MASK_POWER | MASK_POWER2
1651                                 | MASK_MULTIPLE | MASK_STRING);
1652       break;
1653     case OPT_mno_powerpc:
1654       target_flags &= ~(MASK_POWERPC | MASK_PPC_GPOPT
1655                         | MASK_PPC_GFXOPT | MASK_POWERPC64);
1656       target_flags_explicit |= (MASK_POWERPC | MASK_PPC_GPOPT
1657                                 | MASK_PPC_GFXOPT | MASK_POWERPC64);
1658       break;
1659     case OPT_mfull_toc:
1660       target_flags &= ~MASK_MINIMAL_TOC;
1661       TARGET_NO_FP_IN_TOC = 0;
1662       TARGET_NO_SUM_IN_TOC = 0;
1663       target_flags_explicit |= MASK_MINIMAL_TOC;
1664 #ifdef TARGET_USES_SYSV4_OPT
1665       /* Note, V.4 no longer uses a normal TOC, so make -mfull-toc, be
1666          just the same as -mminimal-toc.  */
1667       target_flags |= MASK_MINIMAL_TOC;
1668       target_flags_explicit |= MASK_MINIMAL_TOC;
1669 #endif
1670       break;
1671
1672 #ifdef TARGET_USES_SYSV4_OPT
1673     case OPT_mtoc:
1674       /* Make -mtoc behave like -mminimal-toc.  */
1675       target_flags |= MASK_MINIMAL_TOC;
1676       target_flags_explicit |= MASK_MINIMAL_TOC;
1677       break;
1678 #endif
1679
1680 #ifdef TARGET_USES_AIX64_OPT
1681     case OPT_maix64:
1682 #else
1683     case OPT_m64:
1684 #endif
1685       target_flags |= MASK_POWERPC64 | MASK_POWERPC;
1686       target_flags |= ~target_flags_explicit & MASK_PPC_GFXOPT;
1687       target_flags_explicit |= MASK_POWERPC64 | MASK_POWERPC;
1688       break;
1689
1690 #ifdef TARGET_USES_AIX64_OPT
1691     case OPT_maix32:
1692 #else
1693     case OPT_m32:
1694 #endif
1695       target_flags &= ~MASK_POWERPC64;
1696       target_flags_explicit |= MASK_POWERPC64;
1697       break;
1698
1699     case OPT_minsert_sched_nops_:
1700       rs6000_sched_insert_nops_str = arg;
1701       break;
1702
1703     case OPT_mminimal_toc:
1704       if (value == 1)
1705         {
1706           TARGET_NO_FP_IN_TOC = 0;
1707           TARGET_NO_SUM_IN_TOC = 0;
1708         }
1709       break;
1710
1711     case OPT_mpower:
1712       if (value == 1)
1713         {
1714           target_flags |= (MASK_MULTIPLE | MASK_STRING);
1715           target_flags_explicit |= (MASK_MULTIPLE | MASK_STRING);
1716         }
1717       break;
1718
1719     case OPT_mpower2:
1720       if (value == 1)
1721         {
1722           target_flags |= (MASK_POWER | MASK_MULTIPLE | MASK_STRING);
1723           target_flags_explicit |= (MASK_POWER | MASK_MULTIPLE | MASK_STRING);
1724         }
1725       break;
1726
1727     case OPT_mpowerpc_gpopt:
1728     case OPT_mpowerpc_gfxopt:
1729       if (value == 1)
1730         {
1731           target_flags |= MASK_POWERPC;
1732           target_flags_explicit |= MASK_POWERPC;
1733         }
1734       break;
1735
1736     case OPT_maix_struct_return:
1737     case OPT_msvr4_struct_return:
1738       rs6000_explicit_options.aix_struct_ret = true;
1739       break;
1740
1741     case OPT_mvrsave_:
1742       rs6000_parse_yes_no_option ("vrsave", arg, &(TARGET_ALTIVEC_VRSAVE));
1743       break;
1744
1745     case OPT_misel_:
1746       rs6000_explicit_options.isel = true;
1747       rs6000_parse_yes_no_option ("isel", arg, &(rs6000_isel));
1748       break;
1749
1750     case OPT_mspe_:
1751       rs6000_explicit_options.spe = true;
1752       rs6000_parse_yes_no_option ("spe", arg, &(rs6000_spe));
1753       /* No SPE means 64-bit long doubles, even if an E500.  */
1754       if (!rs6000_spe)
1755         rs6000_long_double_type_size = 64;
1756       break;
1757
1758     case OPT_mdebug_:
1759       rs6000_debug_name = arg;
1760       break;
1761
1762 #ifdef TARGET_USES_SYSV4_OPT
1763     case OPT_mcall_:
1764       rs6000_abi_name = arg;
1765       break;
1766
1767     case OPT_msdata_:
1768       rs6000_sdata_name = arg;
1769       break;
1770
1771     case OPT_mtls_size_:
1772       rs6000_tls_size_string = arg;
1773       break;
1774
1775     case OPT_mrelocatable:
1776       if (value == 1)
1777         {
1778           target_flags |= MASK_MINIMAL_TOC;
1779           target_flags_explicit |= MASK_MINIMAL_TOC;
1780           TARGET_NO_FP_IN_TOC = 1;
1781         }
1782       break;
1783
1784     case OPT_mrelocatable_lib:
1785       if (value == 1)
1786         {
1787           target_flags |= MASK_RELOCATABLE | MASK_MINIMAL_TOC;
1788           target_flags_explicit |= MASK_RELOCATABLE | MASK_MINIMAL_TOC;
1789           TARGET_NO_FP_IN_TOC = 1;
1790         }
1791       else
1792         {
1793           target_flags &= ~MASK_RELOCATABLE;
1794           target_flags_explicit |= MASK_RELOCATABLE;
1795         }
1796       break;
1797 #endif
1798
1799     case OPT_mabi_:
1800       if (!strcmp (arg, "altivec"))
1801         {
1802           rs6000_explicit_options.abi = true;
1803           rs6000_altivec_abi = 1;
1804           rs6000_spe_abi = 0;
1805         }
1806       else if (! strcmp (arg, "no-altivec"))
1807         {
1808           /* ??? Don't set rs6000_explicit_options.abi here, to allow
1809              the default for rs6000_spe_abi to be chosen later.  */
1810           rs6000_altivec_abi = 0;
1811         }
1812       else if (! strcmp (arg, "spe"))
1813         {
1814           rs6000_explicit_options.abi = true;
1815           rs6000_spe_abi = 1;
1816           rs6000_altivec_abi = 0;
1817           if (!TARGET_SPE_ABI)
1818             error ("not configured for ABI: '%s'", arg);
1819         }
1820       else if (! strcmp (arg, "no-spe"))
1821         {
1822           rs6000_explicit_options.abi = true;
1823           rs6000_spe_abi = 0;
1824         }
1825
1826       /* These are here for testing during development only, do not
1827          document in the manual please.  */
1828       else if (! strcmp (arg, "d64"))
1829         {
1830           rs6000_darwin64_abi = 1;
1831           warning (0, "Using darwin64 ABI");
1832         }
1833       else if (! strcmp (arg, "d32"))
1834         {
1835           rs6000_darwin64_abi = 0;
1836           warning (0, "Using old darwin ABI");
1837         }
1838
1839       else if (! strcmp (arg, "ibmlongdouble"))
1840         {
1841           rs6000_explicit_options.ieee = true;
1842           rs6000_ieeequad = 0;
1843           warning (0, "Using IBM extended precision long double");
1844         }
1845       else if (! strcmp (arg, "ieeelongdouble"))
1846         {
1847           rs6000_explicit_options.ieee = true;
1848           rs6000_ieeequad = 1;
1849           warning (0, "Using IEEE extended precision long double");
1850         }
1851
1852       else
1853         {
1854           error ("unknown ABI specified: '%s'", arg);
1855           return false;
1856         }
1857       break;
1858
1859     case OPT_mcpu_:
1860       rs6000_select[1].string = arg;
1861       break;
1862
1863     case OPT_mtune_:
1864       rs6000_select[2].string = arg;
1865       break;
1866
1867     case OPT_mtraceback_:
1868       rs6000_traceback_name = arg;
1869       break;
1870
1871     case OPT_mfloat_gprs_:
1872       rs6000_explicit_options.float_gprs = true;
1873       if (! strcmp (arg, "yes") || ! strcmp (arg, "single"))
1874         rs6000_float_gprs = 1;
1875       else if (! strcmp (arg, "double"))
1876         rs6000_float_gprs = 2;
1877       else if (! strcmp (arg, "no"))
1878         rs6000_float_gprs = 0;
1879       else
1880         {
1881           error ("invalid option for -mfloat-gprs: '%s'", arg);
1882           return false;
1883         }
1884       break;
1885
1886     case OPT_mlong_double_:
1887       rs6000_explicit_options.long_double = true;
1888       rs6000_long_double_type_size = RS6000_DEFAULT_LONG_DOUBLE_SIZE;
1889       if (value != 64 && value != 128)
1890         {
1891           error ("Unknown switch -mlong-double-%s", arg);
1892           rs6000_long_double_type_size = RS6000_DEFAULT_LONG_DOUBLE_SIZE;
1893           return false;
1894         }
1895       else
1896         rs6000_long_double_type_size = value;
1897       break;
1898
1899     case OPT_msched_costly_dep_:
1900       rs6000_sched_costly_dep_str = arg;
1901       break;
1902
1903     case OPT_malign_:
1904       rs6000_explicit_options.alignment = true;
1905       if (! strcmp (arg, "power"))
1906         {
1907           /* On 64-bit Darwin, power alignment is ABI-incompatible with
1908              some C library functions, so warn about it. The flag may be
1909              useful for performance studies from time to time though, so
1910              don't disable it entirely.  */
1911           if (DEFAULT_ABI == ABI_DARWIN && TARGET_64BIT)
1912             warning (0, "-malign-power is not supported for 64-bit Darwin;"
1913                      " it is incompatible with the installed C and C++ libraries");
1914           rs6000_alignment_flags = MASK_ALIGN_POWER;
1915         }
1916       else if (! strcmp (arg, "natural"))
1917         rs6000_alignment_flags = MASK_ALIGN_NATURAL;
1918       else
1919         {
1920           error ("unknown -malign-XXXXX option specified: '%s'", arg);
1921           return false;
1922         }
1923       break;
1924     }
1925   return true;
1926 }
1927 \f
1928 /* Do anything needed at the start of the asm file.  */
1929
1930 static void
1931 rs6000_file_start (void)
1932 {
1933   size_t i;
1934   char buffer[80];
1935   const char *start = buffer;
1936   struct rs6000_cpu_select *ptr;
1937   const char *default_cpu = TARGET_CPU_DEFAULT;
1938   FILE *file = asm_out_file;
1939
1940   default_file_start ();
1941
1942 #ifdef TARGET_BI_ARCH
1943   if ((TARGET_DEFAULT ^ target_flags) & MASK_64BIT)
1944     default_cpu = 0;
1945 #endif
1946
1947   if (flag_verbose_asm)
1948     {
1949       sprintf (buffer, "\n%s rs6000/powerpc options:", ASM_COMMENT_START);
1950       rs6000_select[0].string = default_cpu;
1951
1952       for (i = 0; i < ARRAY_SIZE (rs6000_select); i++)
1953         {
1954           ptr = &rs6000_select[i];
1955           if (ptr->string != (char *)0 && ptr->string[0] != '\0')
1956             {
1957               fprintf (file, "%s %s%s", start, ptr->name, ptr->string);
1958               start = "";
1959             }
1960         }
1961
1962       if (PPC405_ERRATUM77)
1963         {
1964           fprintf (file, "%s PPC405CR_ERRATUM77", start);
1965           start = "";
1966         }
1967
1968 #ifdef USING_ELFOS_H
1969       switch (rs6000_sdata)
1970         {
1971         case SDATA_NONE: fprintf (file, "%s -msdata=none", start); start = ""; break;
1972         case SDATA_DATA: fprintf (file, "%s -msdata=data", start); start = ""; break;
1973         case SDATA_SYSV: fprintf (file, "%s -msdata=sysv", start); start = ""; break;
1974         case SDATA_EABI: fprintf (file, "%s -msdata=eabi", start); start = ""; break;
1975         }
1976
1977       if (rs6000_sdata && g_switch_value)
1978         {
1979           fprintf (file, "%s -G " HOST_WIDE_INT_PRINT_UNSIGNED, start,
1980                    g_switch_value);
1981           start = "";
1982         }
1983 #endif
1984
1985       if (*start == '\0')
1986         putc ('\n', file);
1987     }
1988
1989   if (DEFAULT_ABI == ABI_AIX || (TARGET_ELF && flag_pic == 2))
1990     {
1991       switch_to_section (toc_section);
1992       switch_to_section (text_section);
1993     }
1994 }
1995
1996 \f
1997 /* Return nonzero if this function is known to have a null epilogue.  */
1998
1999 int
2000 direct_return (void)
2001 {
2002   if (reload_completed)
2003     {
2004       rs6000_stack_t *info = rs6000_stack_info ();
2005
2006       if (info->first_gp_reg_save == 32
2007           && info->first_fp_reg_save == 64
2008           && info->first_altivec_reg_save == LAST_ALTIVEC_REGNO + 1
2009           && ! info->lr_save_p
2010           && ! info->cr_save_p
2011           && info->vrsave_mask == 0
2012           && ! info->push_p)
2013         return 1;
2014     }
2015
2016   return 0;
2017 }
2018
2019 /* Return the number of instructions it takes to form a constant in an
2020    integer register.  */
2021
2022 int
2023 num_insns_constant_wide (HOST_WIDE_INT value)
2024 {
2025   /* signed constant loadable with {cal|addi} */
2026   if ((unsigned HOST_WIDE_INT) (value + 0x8000) < 0x10000)
2027     return 1;
2028
2029   /* constant loadable with {cau|addis} */
2030   else if ((value & 0xffff) == 0
2031            && (value >> 31 == -1 || value >> 31 == 0))
2032     return 1;
2033
2034 #if HOST_BITS_PER_WIDE_INT == 64
2035   else if (TARGET_POWERPC64)
2036     {
2037       HOST_WIDE_INT low  = ((value & 0xffffffff) ^ 0x80000000) - 0x80000000;
2038       HOST_WIDE_INT high = value >> 31;
2039
2040       if (high == 0 || high == -1)
2041         return 2;
2042
2043       high >>= 1;
2044
2045       if (low == 0)
2046         return num_insns_constant_wide (high) + 1;
2047       else
2048         return (num_insns_constant_wide (high)
2049                 + num_insns_constant_wide (low) + 1);
2050     }
2051 #endif
2052
2053   else
2054     return 2;
2055 }
2056
2057 int
2058 num_insns_constant (rtx op, enum machine_mode mode)
2059 {
2060   HOST_WIDE_INT low, high;
2061
2062   switch (GET_CODE (op))
2063     {
2064     case CONST_INT:
2065 #if HOST_BITS_PER_WIDE_INT == 64
2066       if ((INTVAL (op) >> 31) != 0 && (INTVAL (op) >> 31) != -1
2067           && mask64_operand (op, mode))
2068         return 2;
2069       else
2070 #endif
2071         return num_insns_constant_wide (INTVAL (op));
2072
2073       case CONST_DOUBLE:
2074         if (mode == SFmode)
2075           {
2076             long l;
2077             REAL_VALUE_TYPE rv;
2078
2079             REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
2080             REAL_VALUE_TO_TARGET_SINGLE (rv, l);
2081             return num_insns_constant_wide ((HOST_WIDE_INT) l);
2082           }
2083
2084         if (mode == VOIDmode || mode == DImode)
2085           {
2086             high = CONST_DOUBLE_HIGH (op);
2087             low  = CONST_DOUBLE_LOW (op);
2088           }
2089         else
2090           {
2091             long l[2];
2092             REAL_VALUE_TYPE rv;
2093
2094             REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
2095             REAL_VALUE_TO_TARGET_DOUBLE (rv, l);
2096             high = l[WORDS_BIG_ENDIAN == 0];
2097             low  = l[WORDS_BIG_ENDIAN != 0];
2098           }
2099
2100         if (TARGET_32BIT)
2101           return (num_insns_constant_wide (low)
2102                   + num_insns_constant_wide (high));
2103         else
2104           {
2105             if ((high == 0 && low >= 0)
2106                 || (high == -1 && low < 0))
2107               return num_insns_constant_wide (low);
2108
2109             else if (mask64_operand (op, mode))
2110               return 2;
2111
2112             else if (low == 0)
2113               return num_insns_constant_wide (high) + 1;
2114
2115             else
2116               return (num_insns_constant_wide (high)
2117                       + num_insns_constant_wide (low) + 1);
2118           }
2119
2120     default:
2121       gcc_unreachable ();
2122     }
2123 }
2124
2125 /* Interpret element ELT of the CONST_VECTOR OP as an integer value.
2126    If the mode of OP is MODE_VECTOR_INT, this simply returns the
2127    corresponding element of the vector, but for V4SFmode and V2SFmode,
2128    the corresponding "float" is interpreted as an SImode integer.  */
2129
2130 static HOST_WIDE_INT
2131 const_vector_elt_as_int (rtx op, unsigned int elt)
2132 {
2133   rtx tmp = CONST_VECTOR_ELT (op, elt);
2134   if (GET_MODE (op) == V4SFmode
2135       || GET_MODE (op) == V2SFmode)
2136     tmp = gen_lowpart (SImode, tmp);
2137   return INTVAL (tmp);
2138 }
2139
2140 /* Return true if OP can be synthesized with a particular vspltisb, vspltish
2141    or vspltisw instruction.  OP is a CONST_VECTOR.  Which instruction is used
2142    depends on STEP and COPIES, one of which will be 1.  If COPIES > 1,
2143    all items are set to the same value and contain COPIES replicas of the
2144    vsplt's operand; if STEP > 1, one in STEP elements is set to the vsplt's
2145    operand and the others are set to the value of the operand's msb.  */
2146
2147 static bool
2148 vspltis_constant (rtx op, unsigned step, unsigned copies)
2149 {
2150   enum machine_mode mode = GET_MODE (op);
2151   enum machine_mode inner = GET_MODE_INNER (mode);
2152
2153   unsigned i;
2154   unsigned nunits = GET_MODE_NUNITS (mode);
2155   unsigned bitsize = GET_MODE_BITSIZE (inner);
2156   unsigned mask = GET_MODE_MASK (inner);
2157
2158   HOST_WIDE_INT val = const_vector_elt_as_int (op, nunits - 1);
2159   HOST_WIDE_INT splat_val = val;
2160   HOST_WIDE_INT msb_val = val > 0 ? 0 : -1;
2161
2162   /* Construct the value to be splatted, if possible.  If not, return 0.  */
2163   for (i = 2; i <= copies; i *= 2)
2164     {
2165       HOST_WIDE_INT small_val;
2166       bitsize /= 2;
2167       small_val = splat_val >> bitsize;
2168       mask >>= bitsize;
2169       if (splat_val != ((small_val << bitsize) | (small_val & mask)))
2170         return false;
2171       splat_val = small_val;
2172     }
2173
2174   /* Check if SPLAT_VAL can really be the operand of a vspltis[bhw].  */
2175   if (EASY_VECTOR_15 (splat_val))
2176     ;
2177
2178   /* Also check if we can splat, and then add the result to itself.  Do so if
2179      the value is positive, of if the splat instruction is using OP's mode;
2180      for splat_val < 0, the splat and the add should use the same mode.  */
2181   else if (EASY_VECTOR_15_ADD_SELF (splat_val)
2182            && (splat_val >= 0 || (step == 1 && copies == 1)))
2183     ;
2184
2185   else
2186     return false;
2187
2188   /* Check if VAL is present in every STEP-th element, and the
2189      other elements are filled with its most significant bit.  */
2190   for (i = 0; i < nunits - 1; ++i)
2191     {
2192       HOST_WIDE_INT desired_val;
2193       if (((i + 1) & (step - 1)) == 0)
2194         desired_val = val;
2195       else
2196         desired_val = msb_val;
2197
2198       if (desired_val != const_vector_elt_as_int (op, i))
2199         return false;
2200     }
2201
2202   return true;
2203 }
2204
2205
2206 /* Return true if OP is of the given MODE and can be synthesized
2207    with a vspltisb, vspltish or vspltisw.  */
2208
2209 bool
2210 easy_altivec_constant (rtx op, enum machine_mode mode)
2211 {
2212   unsigned step, copies;
2213
2214   if (mode == VOIDmode)
2215     mode = GET_MODE (op);
2216   else if (mode != GET_MODE (op))
2217     return false;
2218
2219   /* Start with a vspltisw.  */
2220   step = GET_MODE_NUNITS (mode) / 4;
2221   copies = 1;
2222
2223   if (vspltis_constant (op, step, copies))
2224     return true;
2225
2226   /* Then try with a vspltish.  */
2227   if (step == 1)
2228     copies <<= 1;
2229   else
2230     step >>= 1;
2231
2232   if (vspltis_constant (op, step, copies))
2233     return true;
2234
2235   /* And finally a vspltisb.  */
2236   if (step == 1)
2237     copies <<= 1;
2238   else
2239     step >>= 1;
2240
2241   if (vspltis_constant (op, step, copies))
2242     return true;
2243
2244   return false;
2245 }
2246
2247 /* Generate a VEC_DUPLICATE representing a vspltis[bhw] instruction whose
2248    result is OP.  Abort if it is not possible.  */
2249
2250 rtx
2251 gen_easy_altivec_constant (rtx op)
2252 {
2253   enum machine_mode mode = GET_MODE (op);
2254   int nunits = GET_MODE_NUNITS (mode);
2255   rtx last = CONST_VECTOR_ELT (op, nunits - 1);
2256   unsigned step = nunits / 4;
2257   unsigned copies = 1;
2258
2259   /* Start with a vspltisw.  */
2260   if (vspltis_constant (op, step, copies))
2261     return gen_rtx_VEC_DUPLICATE (V4SImode, gen_lowpart (SImode, last));
2262
2263   /* Then try with a vspltish.  */
2264   if (step == 1)
2265     copies <<= 1;
2266   else
2267     step >>= 1;
2268
2269   if (vspltis_constant (op, step, copies))
2270     return gen_rtx_VEC_DUPLICATE (V8HImode, gen_lowpart (HImode, last));
2271
2272   /* And finally a vspltisb.  */
2273   if (step == 1)
2274     copies <<= 1;
2275   else
2276     step >>= 1;
2277
2278   if (vspltis_constant (op, step, copies))
2279     return gen_rtx_VEC_DUPLICATE (V16QImode, gen_lowpart (QImode, last));
2280
2281   gcc_unreachable ();
2282 }
2283
2284 const char *
2285 output_vec_const_move (rtx *operands)
2286 {
2287   int cst, cst2;
2288   enum machine_mode mode;
2289   rtx dest, vec;
2290
2291   dest = operands[0];
2292   vec = operands[1];
2293   mode = GET_MODE (dest);
2294
2295   if (TARGET_ALTIVEC)
2296     {
2297       rtx splat_vec;
2298       if (zero_constant (vec, mode))
2299         return "vxor %0,%0,%0";
2300
2301       splat_vec = gen_easy_altivec_constant (vec);
2302       gcc_assert (GET_CODE (splat_vec) == VEC_DUPLICATE);
2303       operands[1] = XEXP (splat_vec, 0);
2304       if (!EASY_VECTOR_15 (INTVAL (operands[1])))
2305         return "#";
2306
2307       switch (GET_MODE (splat_vec))
2308         {
2309         case V4SImode:
2310           return "vspltisw %0,%1";
2311
2312         case V8HImode:
2313           return "vspltish %0,%1";
2314
2315         case V16QImode:
2316           return "vspltisb %0,%1";
2317
2318         default:
2319           gcc_unreachable ();
2320         }
2321     }
2322
2323   gcc_assert (TARGET_SPE);
2324
2325   /* Vector constant 0 is handled as a splitter of V2SI, and in the
2326      pattern of V1DI, V4HI, and V2SF.
2327
2328      FIXME: We should probably return # and add post reload
2329      splitters for these, but this way is so easy ;-).  */
2330   cst = INTVAL (CONST_VECTOR_ELT (vec, 0));
2331   cst2 = INTVAL (CONST_VECTOR_ELT (vec, 1));
2332   operands[1] = CONST_VECTOR_ELT (vec, 0);
2333   operands[2] = CONST_VECTOR_ELT (vec, 1);
2334   if (cst == cst2)
2335     return "li %0,%1\n\tevmergelo %0,%0,%0";
2336   else
2337     return "li %0,%1\n\tevmergelo %0,%0,%0\n\tli %0,%2";
2338 }
2339
2340 /* Initialize vector TARGET to VALS.  */
2341
2342 void
2343 rs6000_expand_vector_init (rtx target, rtx vals)
2344 {
2345   enum machine_mode mode = GET_MODE (target);
2346   enum machine_mode inner_mode = GET_MODE_INNER (mode);
2347   int n_elts = GET_MODE_NUNITS (mode);
2348   int n_var = 0, one_var = -1;
2349   bool all_same = true, all_const_zero = true;
2350   rtx x, mem;
2351   int i;
2352
2353   for (i = 0; i < n_elts; ++i)
2354     {
2355       x = XVECEXP (vals, 0, i);
2356       if (!CONSTANT_P (x))
2357         ++n_var, one_var = i;
2358       else if (x != CONST0_RTX (inner_mode))
2359         all_const_zero = false;
2360
2361       if (i > 0 && !rtx_equal_p (x, XVECEXP (vals, 0, 0)))
2362         all_same = false;
2363     }
2364
2365   if (n_var == 0)
2366     {
2367       if (mode != V4SFmode && all_const_zero)
2368         {
2369           /* Zero register.  */
2370           emit_insn (gen_rtx_SET (VOIDmode, target,
2371                                   gen_rtx_XOR (mode, target, target)));
2372           return;
2373         }
2374       else if (mode != V4SFmode && easy_vector_constant (vals, mode))
2375         {
2376           /* Splat immediate.  */
2377           emit_insn (gen_rtx_SET (VOIDmode, target, vals));
2378           return;
2379         }
2380       else if (all_same)
2381         ;       /* Splat vector element.  */
2382       else
2383         {
2384           /* Load from constant pool.  */
2385           emit_move_insn (target, gen_rtx_CONST_VECTOR (mode, XVEC (vals, 0)));
2386           return;
2387         }
2388     }
2389
2390   /* Store value to stack temp.  Load vector element.  Splat.  */
2391   if (all_same)
2392     {
2393       mem = assign_stack_temp (mode, GET_MODE_SIZE (inner_mode), 0);
2394       emit_move_insn (adjust_address_nv (mem, inner_mode, 0),
2395                       XVECEXP (vals, 0, 0));
2396       x = gen_rtx_UNSPEC (VOIDmode,
2397                           gen_rtvec (1, const0_rtx), UNSPEC_LVE);
2398       emit_insn (gen_rtx_PARALLEL (VOIDmode,
2399                                    gen_rtvec (2,
2400                                               gen_rtx_SET (VOIDmode,
2401                                                            target, mem),
2402                                               x)));
2403       x = gen_rtx_VEC_SELECT (inner_mode, target,
2404                               gen_rtx_PARALLEL (VOIDmode,
2405                                                 gen_rtvec (1, const0_rtx)));
2406       emit_insn (gen_rtx_SET (VOIDmode, target,
2407                               gen_rtx_VEC_DUPLICATE (mode, x)));
2408       return;
2409     }
2410
2411   /* One field is non-constant.  Load constant then overwrite
2412      varying field.  */
2413   if (n_var == 1)
2414     {
2415       rtx copy = copy_rtx (vals);
2416
2417       /* Load constant part of vector, substitute neighboring value for
2418          varying element.  */
2419       XVECEXP (copy, 0, one_var) = XVECEXP (vals, 0, (one_var + 1) % n_elts);
2420       rs6000_expand_vector_init (target, copy);
2421
2422       /* Insert variable.  */
2423       rs6000_expand_vector_set (target, XVECEXP (vals, 0, one_var), one_var);
2424       return;
2425     }
2426
2427   /* Construct the vector in memory one field at a time
2428      and load the whole vector.  */
2429   mem = assign_stack_temp (mode, GET_MODE_SIZE (mode), 0);
2430   for (i = 0; i < n_elts; i++)
2431     emit_move_insn (adjust_address_nv (mem, inner_mode,
2432                                     i * GET_MODE_SIZE (inner_mode)),
2433                     XVECEXP (vals, 0, i));
2434   emit_move_insn (target, mem);
2435 }
2436
2437 /* Set field ELT of TARGET to VAL.  */
2438
2439 void
2440 rs6000_expand_vector_set (rtx target, rtx val, int elt)
2441 {
2442   enum machine_mode mode = GET_MODE (target);
2443   enum machine_mode inner_mode = GET_MODE_INNER (mode);
2444   rtx reg = gen_reg_rtx (mode);
2445   rtx mask, mem, x;
2446   int width = GET_MODE_SIZE (inner_mode);
2447   int i;
2448
2449   /* Load single variable value.  */
2450   mem = assign_stack_temp (mode, GET_MODE_SIZE (inner_mode), 0);
2451   emit_move_insn (adjust_address_nv (mem, inner_mode, 0), val);
2452   x = gen_rtx_UNSPEC (VOIDmode,
2453                       gen_rtvec (1, const0_rtx), UNSPEC_LVE);
2454   emit_insn (gen_rtx_PARALLEL (VOIDmode,
2455                                gen_rtvec (2,
2456                                           gen_rtx_SET (VOIDmode,
2457                                                        reg, mem),
2458                                           x)));
2459
2460   /* Linear sequence.  */
2461   mask = gen_rtx_PARALLEL (V16QImode, rtvec_alloc (16));
2462   for (i = 0; i < 16; ++i)
2463     XVECEXP (mask, 0, i) = GEN_INT (i);
2464
2465   /* Set permute mask to insert element into target.  */
2466   for (i = 0; i < width; ++i)
2467     XVECEXP (mask, 0, elt*width + i)
2468       = GEN_INT (i + 0x10);
2469   x = gen_rtx_CONST_VECTOR (V16QImode, XVEC (mask, 0));
2470   x = gen_rtx_UNSPEC (mode,
2471                       gen_rtvec (3, target, reg,
2472                                  force_reg (V16QImode, x)),
2473                       UNSPEC_VPERM);
2474   emit_insn (gen_rtx_SET (VOIDmode, target, x));
2475 }
2476
2477 /* Extract field ELT from VEC into TARGET.  */
2478
2479 void
2480 rs6000_expand_vector_extract (rtx target, rtx vec, int elt)
2481 {
2482   enum machine_mode mode = GET_MODE (vec);
2483   enum machine_mode inner_mode = GET_MODE_INNER (mode);
2484   rtx mem, x;
2485
2486   /* Allocate mode-sized buffer.  */
2487   mem = assign_stack_temp (mode, GET_MODE_SIZE (mode), 0);
2488
2489   /* Add offset to field within buffer matching vector element.  */
2490   mem = adjust_address_nv (mem, mode, elt * GET_MODE_SIZE (inner_mode));
2491
2492   /* Store single field into mode-sized buffer.  */
2493   x = gen_rtx_UNSPEC (VOIDmode,
2494                       gen_rtvec (1, const0_rtx), UNSPEC_STVE);
2495   emit_insn (gen_rtx_PARALLEL (VOIDmode,
2496                                gen_rtvec (2,
2497                                           gen_rtx_SET (VOIDmode,
2498                                                        mem, vec),
2499                                           x)));
2500   emit_move_insn (target, adjust_address_nv (mem, inner_mode, 0));
2501 }
2502
2503 /* Generates shifts and masks for a pair of rldicl or rldicr insns to
2504    implement ANDing by the mask IN.  */
2505 void
2506 build_mask64_2_operands (rtx in, rtx *out)
2507 {
2508 #if HOST_BITS_PER_WIDE_INT >= 64
2509   unsigned HOST_WIDE_INT c, lsb, m1, m2;
2510   int shift;
2511
2512   gcc_assert (GET_CODE (in) == CONST_INT);
2513
2514   c = INTVAL (in);
2515   if (c & 1)
2516     {
2517       /* Assume c initially something like 0x00fff000000fffff.  The idea
2518          is to rotate the word so that the middle ^^^^^^ group of zeros
2519          is at the MS end and can be cleared with an rldicl mask.  We then
2520          rotate back and clear off the MS    ^^ group of zeros with a
2521          second rldicl.  */
2522       c = ~c;                   /*   c == 0xff000ffffff00000 */
2523       lsb = c & -c;             /* lsb == 0x0000000000100000 */
2524       m1 = -lsb;                /*  m1 == 0xfffffffffff00000 */
2525       c = ~c;                   /*   c == 0x00fff000000fffff */
2526       c &= -lsb;                /*   c == 0x00fff00000000000 */
2527       lsb = c & -c;             /* lsb == 0x0000100000000000 */
2528       c = ~c;                   /*   c == 0xff000fffffffffff */
2529       c &= -lsb;                /*   c == 0xff00000000000000 */
2530       shift = 0;
2531       while ((lsb >>= 1) != 0)
2532         shift++;                /* shift == 44 on exit from loop */
2533       m1 <<= 64 - shift;        /*  m1 == 0xffffff0000000000 */
2534       m1 = ~m1;                 /*  m1 == 0x000000ffffffffff */
2535       m2 = ~c;                  /*  m2 == 0x00ffffffffffffff */
2536     }
2537   else
2538     {
2539       /* Assume c initially something like 0xff000f0000000000.  The idea
2540          is to rotate the word so that the     ^^^  middle group of zeros
2541          is at the LS end and can be cleared with an rldicr mask.  We then
2542          rotate back and clear off the LS group of ^^^^^^^^^^ zeros with
2543          a second rldicr.  */
2544       lsb = c & -c;             /* lsb == 0x0000010000000000 */
2545       m2 = -lsb;                /*  m2 == 0xffffff0000000000 */
2546       c = ~c;                   /*   c == 0x00fff0ffffffffff */
2547       c &= -lsb;                /*   c == 0x00fff00000000000 */
2548       lsb = c & -c;             /* lsb == 0x0000100000000000 */
2549       c = ~c;                   /*   c == 0xff000fffffffffff */
2550       c &= -lsb;                /*   c == 0xff00000000000000 */
2551       shift = 0;
2552       while ((lsb >>= 1) != 0)
2553         shift++;                /* shift == 44 on exit from loop */
2554       m1 = ~c;                  /*  m1 == 0x00ffffffffffffff */
2555       m1 >>= shift;             /*  m1 == 0x0000000000000fff */
2556       m1 = ~m1;                 /*  m1 == 0xfffffffffffff000 */
2557     }
2558
2559   /* Note that when we only have two 0->1 and 1->0 transitions, one of the
2560      masks will be all 1's.  We are guaranteed more than one transition.  */
2561   out[0] = GEN_INT (64 - shift);
2562   out[1] = GEN_INT (m1);
2563   out[2] = GEN_INT (shift);
2564   out[3] = GEN_INT (m2);
2565 #else
2566   (void)in;
2567   (void)out;
2568   gcc_unreachable ();
2569 #endif
2570 }
2571
2572 /* Return TRUE if OP is an invalid SUBREG operation on the e500.  */
2573
2574 bool
2575 invalid_e500_subreg (rtx op, enum machine_mode mode)
2576 {
2577   /* Reject (subreg:SI (reg:DF)).  */
2578   if (GET_CODE (op) == SUBREG
2579       && mode == SImode
2580       && REG_P (SUBREG_REG (op))
2581       && GET_MODE (SUBREG_REG (op)) == DFmode)
2582     return true;
2583
2584   /* Reject (subreg:DF (reg:DI)).  */
2585   if (GET_CODE (op) == SUBREG
2586       && mode == DFmode
2587       && REG_P (SUBREG_REG (op))
2588       && GET_MODE (SUBREG_REG (op)) == DImode)
2589     return true;
2590
2591   return false;
2592 }
2593
2594 /* Darwin, AIX increases natural record alignment to doubleword if the first
2595    field is an FP double while the FP fields remain word aligned.  */
2596
2597 unsigned int
2598 rs6000_special_round_type_align (tree type, unsigned int computed,
2599                                  unsigned int specified)
2600 {
2601   unsigned int align = MAX (computed, specified);
2602   tree field = TYPE_FIELDS (type);
2603
2604   /* Skip all non field decls */
2605   while (field != NULL && TREE_CODE (field) != FIELD_DECL)
2606     field = TREE_CHAIN (field);
2607
2608   if (field != NULL && field != type)
2609     {
2610       type = TREE_TYPE (field);
2611       while (TREE_CODE (type) == ARRAY_TYPE)
2612         type = TREE_TYPE (type);
2613
2614       if (type != error_mark_node && TYPE_MODE (type) == DFmode)
2615         align = MAX (align, 64);
2616     }
2617
2618   return align;
2619 }
2620
2621 /* Return 1 for an operand in small memory on V.4/eabi.  */
2622
2623 int
2624 small_data_operand (rtx op ATTRIBUTE_UNUSED,
2625                     enum machine_mode mode ATTRIBUTE_UNUSED)
2626 {
2627 #if TARGET_ELF
2628   rtx sym_ref;
2629
2630   if (rs6000_sdata == SDATA_NONE || rs6000_sdata == SDATA_DATA)
2631     return 0;
2632
2633   if (DEFAULT_ABI != ABI_V4)
2634     return 0;
2635
2636   if (GET_CODE (op) == SYMBOL_REF)
2637     sym_ref = op;
2638
2639   else if (GET_CODE (op) != CONST
2640            || GET_CODE (XEXP (op, 0)) != PLUS
2641            || GET_CODE (XEXP (XEXP (op, 0), 0)) != SYMBOL_REF
2642            || GET_CODE (XEXP (XEXP (op, 0), 1)) != CONST_INT)
2643     return 0;
2644
2645   else
2646     {
2647       rtx sum = XEXP (op, 0);
2648       HOST_WIDE_INT summand;
2649
2650       /* We have to be careful here, because it is the referenced address
2651          that must be 32k from _SDA_BASE_, not just the symbol.  */
2652       summand = INTVAL (XEXP (sum, 1));
2653       if (summand < 0 || (unsigned HOST_WIDE_INT) summand > g_switch_value)
2654         return 0;
2655
2656       sym_ref = XEXP (sum, 0);
2657     }
2658
2659   return SYMBOL_REF_SMALL_P (sym_ref);
2660 #else
2661   return 0;
2662 #endif
2663 }
2664
2665 /* Return true if either operand is a general purpose register.  */
2666
2667 bool
2668 gpr_or_gpr_p (rtx op0, rtx op1)
2669 {
2670   return ((REG_P (op0) && INT_REGNO_P (REGNO (op0)))
2671           || (REG_P (op1) && INT_REGNO_P (REGNO (op1))));
2672 }
2673
2674 \f
2675 /* Subroutines of rs6000_legitimize_address and rs6000_legitimate_address.  */
2676
2677 static int
2678 constant_pool_expr_1 (rtx op, int *have_sym, int *have_toc)
2679 {
2680   switch (GET_CODE (op))
2681     {
2682     case SYMBOL_REF:
2683       if (RS6000_SYMBOL_REF_TLS_P (op))
2684         return 0;
2685       else if (CONSTANT_POOL_ADDRESS_P (op))
2686         {
2687           if (ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (get_pool_constant (op), Pmode))
2688             {
2689               *have_sym = 1;
2690               return 1;
2691             }
2692           else
2693             return 0;
2694         }
2695       else if (! strcmp (XSTR (op, 0), toc_label_name))
2696         {
2697           *have_toc = 1;
2698           return 1;
2699         }
2700       else
2701         return 0;
2702     case PLUS:
2703     case MINUS:
2704       return (constant_pool_expr_1 (XEXP (op, 0), have_sym, have_toc)
2705               && constant_pool_expr_1 (XEXP (op, 1), have_sym, have_toc));
2706     case CONST:
2707       return constant_pool_expr_1 (XEXP (op, 0), have_sym, have_toc);
2708     case CONST_INT:
2709       return 1;
2710     default:
2711       return 0;
2712     }
2713 }
2714
2715 static bool
2716 constant_pool_expr_p (rtx op)
2717 {
2718   int have_sym = 0;
2719   int have_toc = 0;
2720   return constant_pool_expr_1 (op, &have_sym, &have_toc) && have_sym;
2721 }
2722
2723 bool
2724 toc_relative_expr_p (rtx op)
2725 {
2726   int have_sym = 0;
2727   int have_toc = 0;
2728   return constant_pool_expr_1 (op, &have_sym, &have_toc) && have_toc;
2729 }
2730
2731 bool
2732 legitimate_constant_pool_address_p (rtx x)
2733 {
2734   return (TARGET_TOC
2735           && GET_CODE (x) == PLUS
2736           && GET_CODE (XEXP (x, 0)) == REG
2737           && (TARGET_MINIMAL_TOC || REGNO (XEXP (x, 0)) == TOC_REGISTER)
2738           && constant_pool_expr_p (XEXP (x, 1)));
2739 }
2740
2741 static bool
2742 legitimate_small_data_p (enum machine_mode mode, rtx x)
2743 {
2744   return (DEFAULT_ABI == ABI_V4
2745           && !flag_pic && !TARGET_TOC
2746           && (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == CONST)
2747           && small_data_operand (x, mode));
2748 }
2749
2750 /* SPE offset addressing is limited to 5-bits worth of double words.  */
2751 #define SPE_CONST_OFFSET_OK(x) (((x) & ~0xf8) == 0)
2752
2753 bool
2754 rs6000_legitimate_offset_address_p (enum machine_mode mode, rtx x, int strict)
2755 {
2756   unsigned HOST_WIDE_INT offset, extra;
2757
2758   if (GET_CODE (x) != PLUS)
2759     return false;
2760   if (GET_CODE (XEXP (x, 0)) != REG)
2761     return false;
2762   if (!INT_REG_OK_FOR_BASE_P (XEXP (x, 0), strict))
2763     return false;
2764   if (legitimate_constant_pool_address_p (x))
2765     return true;
2766   if (GET_CODE (XEXP (x, 1)) != CONST_INT)
2767     return false;
2768
2769   offset = INTVAL (XEXP (x, 1));
2770   extra = 0;
2771   switch (mode)
2772     {
2773     case V16QImode:
2774     case V8HImode:
2775     case V4SFmode:
2776     case V4SImode:
2777       /* AltiVec vector modes.  Only reg+reg addressing is valid and
2778          constant offset zero should not occur due to canonicalization.
2779          Allow any offset when not strict before reload.  */
2780       return !strict;
2781
2782     case V4HImode:
2783     case V2SImode:
2784     case V1DImode:
2785     case V2SFmode:
2786       /* SPE vector modes.  */
2787       return SPE_CONST_OFFSET_OK (offset);
2788
2789     case DFmode:
2790       if (TARGET_E500_DOUBLE)
2791         return SPE_CONST_OFFSET_OK (offset);
2792
2793     case DImode:
2794       /* On e500v2, we may have:
2795
2796            (subreg:DF (mem:DI (plus (reg) (const_int))) 0).
2797
2798          Which gets addressed with evldd instructions.  */
2799       if (TARGET_E500_DOUBLE)
2800         return SPE_CONST_OFFSET_OK (offset);
2801
2802       if (mode == DFmode || !TARGET_POWERPC64)
2803         extra = 4;
2804       else if (offset & 3)
2805         return false;
2806       break;
2807
2808     case TFmode:
2809     case TImode:
2810       if (mode == TFmode || !TARGET_POWERPC64)
2811         extra = 12;
2812       else if (offset & 3)
2813         return false;
2814       else
2815         extra = 8;
2816       break;
2817
2818     default:
2819       break;
2820     }
2821
2822   offset += 0x8000;
2823   return (offset < 0x10000) && (offset + extra < 0x10000);
2824 }
2825
2826 static bool
2827 legitimate_indexed_address_p (rtx x, int strict)
2828 {
2829   rtx op0, op1;
2830
2831   if (GET_CODE (x) != PLUS)
2832     return false;
2833
2834   op0 = XEXP (x, 0);
2835   op1 = XEXP (x, 1);
2836
2837   /* Recognize the rtl generated by reload which we know will later be
2838      replaced with proper base and index regs.  */
2839   if (!strict
2840       && reload_in_progress
2841       && (REG_P (op0) || GET_CODE (op0) == PLUS)
2842       && REG_P (op1))
2843     return true;
2844
2845   return (REG_P (op0) && REG_P (op1)
2846           && ((INT_REG_OK_FOR_BASE_P (op0, strict)
2847                && INT_REG_OK_FOR_INDEX_P (op1, strict))
2848               || (INT_REG_OK_FOR_BASE_P (op1, strict)
2849                   && INT_REG_OK_FOR_INDEX_P (op0, strict))));
2850 }
2851
2852 inline bool
2853 legitimate_indirect_address_p (rtx x, int strict)
2854 {
2855   return GET_CODE (x) == REG && INT_REG_OK_FOR_BASE_P (x, strict);
2856 }
2857
2858 bool
2859 macho_lo_sum_memory_operand (rtx x, enum machine_mode mode)
2860 {
2861   if (!TARGET_MACHO || !flag_pic
2862       || mode != SImode || GET_CODE (x) != MEM)
2863     return false;
2864   x = XEXP (x, 0);
2865
2866   if (GET_CODE (x) != LO_SUM)
2867     return false;
2868   if (GET_CODE (XEXP (x, 0)) != REG)
2869     return false;
2870   if (!INT_REG_OK_FOR_BASE_P (XEXP (x, 0), 0))
2871     return false;
2872   x = XEXP (x, 1);
2873
2874   return CONSTANT_P (x);
2875 }
2876
2877 static bool
2878 legitimate_lo_sum_address_p (enum machine_mode mode, rtx x, int strict)
2879 {
2880   if (GET_CODE (x) != LO_SUM)
2881     return false;
2882   if (GET_CODE (XEXP (x, 0)) != REG)
2883     return false;
2884   if (!INT_REG_OK_FOR_BASE_P (XEXP (x, 0), strict))
2885     return false;
2886   /* Restrict addressing for DI because of our SUBREG hackery.  */
2887   if (TARGET_E500_DOUBLE && (mode == DFmode || mode == DImode))
2888     return false;
2889   x = XEXP (x, 1);
2890
2891   if (TARGET_ELF || TARGET_MACHO)
2892     {
2893       if (DEFAULT_ABI != ABI_AIX && DEFAULT_ABI != ABI_DARWIN && flag_pic)
2894         return false;
2895       if (TARGET_TOC)
2896         return false;
2897       if (GET_MODE_NUNITS (mode) != 1)
2898         return false;
2899       if (GET_MODE_BITSIZE (mode) > 64
2900           || (GET_MODE_BITSIZE (mode) > 32 && !TARGET_POWERPC64
2901               && !(TARGET_HARD_FLOAT && TARGET_FPRS && mode == DFmode)))
2902         return false;
2903
2904       return CONSTANT_P (x);
2905     }
2906
2907   return false;
2908 }
2909
2910
2911 /* Try machine-dependent ways of modifying an illegitimate address
2912    to be legitimate.  If we find one, return the new, valid address.
2913    This is used from only one place: `memory_address' in explow.c.
2914
2915    OLDX is the address as it was before break_out_memory_refs was
2916    called.  In some cases it is useful to look at this to decide what
2917    needs to be done.
2918
2919    MODE is passed so that this function can use GO_IF_LEGITIMATE_ADDRESS.
2920
2921    It is always safe for this function to do nothing.  It exists to
2922    recognize opportunities to optimize the output.
2923
2924    On RS/6000, first check for the sum of a register with a constant
2925    integer that is out of range.  If so, generate code to add the
2926    constant with the low-order 16 bits masked to the register and force
2927    this result into another register (this can be done with `cau').
2928    Then generate an address of REG+(CONST&0xffff), allowing for the
2929    possibility of bit 16 being a one.
2930
2931    Then check for the sum of a register and something not constant, try to
2932    load the other things into a register and return the sum.  */
2933
2934 rtx
2935 rs6000_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
2936                            enum machine_mode mode)
2937 {
2938   if (GET_CODE (x) == SYMBOL_REF)
2939     {
2940       enum tls_model model = SYMBOL_REF_TLS_MODEL (x);
2941       if (model != 0)
2942         return rs6000_legitimize_tls_address (x, model);
2943     }
2944
2945   if (GET_CODE (x) == PLUS
2946       && GET_CODE (XEXP (x, 0)) == REG
2947       && GET_CODE (XEXP (x, 1)) == CONST_INT
2948       && (unsigned HOST_WIDE_INT) (INTVAL (XEXP (x, 1)) + 0x8000) >= 0x10000)
2949     {
2950       HOST_WIDE_INT high_int, low_int;
2951       rtx sum;
2952       low_int = ((INTVAL (XEXP (x, 1)) & 0xffff) ^ 0x8000) - 0x8000;
2953       high_int = INTVAL (XEXP (x, 1)) - low_int;
2954       sum = force_operand (gen_rtx_PLUS (Pmode, XEXP (x, 0),
2955                                          GEN_INT (high_int)), 0);
2956       return gen_rtx_PLUS (Pmode, sum, GEN_INT (low_int));
2957     }
2958   else if (GET_CODE (x) == PLUS
2959            && GET_CODE (XEXP (x, 0)) == REG
2960            && GET_CODE (XEXP (x, 1)) != CONST_INT
2961            && GET_MODE_NUNITS (mode) == 1
2962            && ((TARGET_HARD_FLOAT && TARGET_FPRS)
2963                || TARGET_POWERPC64
2964                || (((mode != DImode && mode != DFmode) || TARGET_E500_DOUBLE)
2965                    && mode != TFmode))
2966            && (TARGET_POWERPC64 || mode != DImode)
2967            && mode != TImode)
2968     {
2969       return gen_rtx_PLUS (Pmode, XEXP (x, 0),
2970                            force_reg (Pmode, force_operand (XEXP (x, 1), 0)));
2971     }
2972   else if (ALTIVEC_VECTOR_MODE (mode))
2973     {
2974       rtx reg;
2975
2976       /* Make sure both operands are registers.  */
2977       if (GET_CODE (x) == PLUS)
2978         return gen_rtx_PLUS (Pmode, force_reg (Pmode, XEXP (x, 0)),
2979                              force_reg (Pmode, XEXP (x, 1)));
2980
2981       reg = force_reg (Pmode, x);
2982       return reg;
2983     }
2984   else if (SPE_VECTOR_MODE (mode)
2985            || (TARGET_E500_DOUBLE && (mode == DFmode
2986                                       || mode == DImode)))
2987     {
2988       if (mode == DImode)
2989         return NULL_RTX;
2990       /* We accept [reg + reg] and [reg + OFFSET].  */
2991
2992       if (GET_CODE (x) == PLUS)
2993         {
2994           rtx op1 = XEXP (x, 0);
2995           rtx op2 = XEXP (x, 1);
2996
2997           op1 = force_reg (Pmode, op1);
2998
2999           if (GET_CODE (op2) != REG
3000               && (GET_CODE (op2) != CONST_INT
3001                   || !SPE_CONST_OFFSET_OK (INTVAL (op2))))
3002             op2 = force_reg (Pmode, op2);
3003
3004           return gen_rtx_PLUS (Pmode, op1, op2);
3005         }
3006
3007       return force_reg (Pmode, x);
3008     }
3009   else if (TARGET_ELF
3010            && TARGET_32BIT
3011            && TARGET_NO_TOC
3012            && ! flag_pic
3013            && GET_CODE (x) != CONST_INT
3014            && GET_CODE (x) != CONST_DOUBLE
3015            && CONSTANT_P (x)
3016            && GET_MODE_NUNITS (mode) == 1
3017            && (GET_MODE_BITSIZE (mode) <= 32
3018                || ((TARGET_HARD_FLOAT && TARGET_FPRS) && mode == DFmode)))
3019     {
3020       rtx reg = gen_reg_rtx (Pmode);
3021       emit_insn (gen_elf_high (reg, x));
3022       return gen_rtx_LO_SUM (Pmode, reg, x);
3023     }
3024   else if (TARGET_MACHO && TARGET_32BIT && TARGET_NO_TOC
3025            && ! flag_pic
3026 #if TARGET_MACHO
3027            && ! MACHO_DYNAMIC_NO_PIC_P
3028 #endif
3029            && GET_CODE (x) != CONST_INT
3030            && GET_CODE (x) != CONST_DOUBLE
3031            && CONSTANT_P (x)
3032            && ((TARGET_HARD_FLOAT && TARGET_FPRS) || mode != DFmode)
3033            && mode != DImode
3034            && mode != TImode)
3035     {
3036       rtx reg = gen_reg_rtx (Pmode);
3037       emit_insn (gen_macho_high (reg, x));
3038       return gen_rtx_LO_SUM (Pmode, reg, x);
3039     }
3040   else if (TARGET_TOC
3041            && constant_pool_expr_p (x)
3042            && ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (get_pool_constant (x), Pmode))
3043     {
3044       return create_TOC_reference (x);
3045     }
3046   else
3047     return NULL_RTX;
3048 }
3049
3050 /* This is called from dwarf2out.c via TARGET_ASM_OUTPUT_DWARF_DTPREL.
3051    We need to emit DTP-relative relocations.  */
3052
3053 static void
3054 rs6000_output_dwarf_dtprel (FILE *file, int size, rtx x)
3055 {
3056   switch (size)
3057     {
3058     case 4:
3059       fputs ("\t.long\t", file);
3060       break;
3061     case 8:
3062       fputs (DOUBLE_INT_ASM_OP, file);
3063       break;
3064     default:
3065       gcc_unreachable ();
3066     }
3067   output_addr_const (file, x);
3068   fputs ("@dtprel+0x8000", file);
3069 }
3070
3071 /* Construct the SYMBOL_REF for the tls_get_addr function.  */
3072
3073 static GTY(()) rtx rs6000_tls_symbol;
3074 static rtx
3075 rs6000_tls_get_addr (void)
3076 {
3077   if (!rs6000_tls_symbol)
3078     rs6000_tls_symbol = init_one_libfunc ("__tls_get_addr");
3079
3080   return rs6000_tls_symbol;
3081 }
3082
3083 /* Construct the SYMBOL_REF for TLS GOT references.  */
3084
3085 static GTY(()) rtx rs6000_got_symbol;
3086 static rtx
3087 rs6000_got_sym (void)
3088 {
3089   if (!rs6000_got_symbol)
3090     {
3091       rs6000_got_symbol = gen_rtx_SYMBOL_REF (Pmode, "_GLOBAL_OFFSET_TABLE_");
3092       SYMBOL_REF_FLAGS (rs6000_got_symbol) |= SYMBOL_FLAG_LOCAL;
3093       SYMBOL_REF_FLAGS (rs6000_got_symbol) |= SYMBOL_FLAG_EXTERNAL;
3094     }
3095
3096   return rs6000_got_symbol;
3097 }
3098
3099 /* ADDR contains a thread-local SYMBOL_REF.  Generate code to compute
3100    this (thread-local) address.  */
3101
3102 static rtx
3103 rs6000_legitimize_tls_address (rtx addr, enum tls_model model)
3104 {
3105   rtx dest, insn;
3106
3107   dest = gen_reg_rtx (Pmode);
3108   if (model == TLS_MODEL_LOCAL_EXEC && rs6000_tls_size == 16)
3109     {
3110       rtx tlsreg;
3111
3112       if (TARGET_64BIT)
3113         {
3114           tlsreg = gen_rtx_REG (Pmode, 13);
3115           insn = gen_tls_tprel_64 (dest, tlsreg, addr);
3116         }
3117       else
3118         {
3119           tlsreg = gen_rtx_REG (Pmode, 2);
3120           insn = gen_tls_tprel_32 (dest, tlsreg, addr);
3121         }
3122       emit_insn (insn);
3123     }
3124   else if (model == TLS_MODEL_LOCAL_EXEC && rs6000_tls_size == 32)
3125     {
3126       rtx tlsreg, tmp;
3127
3128       tmp = gen_reg_rtx (Pmode);
3129       if (TARGET_64BIT)
3130         {
3131           tlsreg = gen_rtx_REG (Pmode, 13);
3132           insn = gen_tls_tprel_ha_64 (tmp, tlsreg, addr);
3133         }
3134       else
3135         {
3136           tlsreg = gen_rtx_REG (Pmode, 2);
3137           insn = gen_tls_tprel_ha_32 (tmp, tlsreg, addr);
3138         }
3139       emit_insn (insn);
3140       if (TARGET_64BIT)
3141         insn = gen_tls_tprel_lo_64 (dest, tmp, addr);
3142       else
3143         insn = gen_tls_tprel_lo_32 (dest, tmp, addr);
3144       emit_insn (insn);
3145     }
3146   else
3147     {
3148       rtx r3, got, tga, tmp1, tmp2, eqv;
3149
3150       /* We currently use relocations like @got@tlsgd for tls, which
3151          means the linker will handle allocation of tls entries, placing
3152          them in the .got section.  So use a pointer to the .got section,
3153          not one to secondary TOC sections used by 64-bit -mminimal-toc,
3154          or to secondary GOT sections used by 32-bit -fPIC.  */
3155       if (TARGET_64BIT)
3156         got = gen_rtx_REG (Pmode, 2);
3157       else
3158         {
3159           if (flag_pic == 1)
3160             got = gen_rtx_REG (Pmode, RS6000_PIC_OFFSET_TABLE_REGNUM);
3161           else
3162             {
3163               rtx gsym = rs6000_got_sym ();
3164               got = gen_reg_rtx (Pmode);
3165               if (flag_pic == 0)
3166                 rs6000_emit_move (got, gsym, Pmode);
3167               else
3168                 {
3169                   rtx tempLR, tmp3, mem;
3170                   rtx first, last;
3171
3172                   tempLR = gen_reg_rtx (Pmode);
3173                   tmp1 = gen_reg_rtx (Pmode);
3174                   tmp2 = gen_reg_rtx (Pmode);
3175                   tmp3 = gen_reg_rtx (Pmode);
3176                   mem = gen_const_mem (Pmode, tmp1);
3177
3178                   first = emit_insn (gen_load_toc_v4_PIC_1b (tempLR, gsym));
3179                   emit_move_insn (tmp1, tempLR);
3180                   emit_move_insn (tmp2, mem);
3181                   emit_insn (gen_addsi3 (tmp3, tmp1, tmp2));
3182                   last = emit_move_insn (got, tmp3);
3183                   REG_NOTES (last) = gen_rtx_EXPR_LIST (REG_EQUAL, gsym,
3184                                                         REG_NOTES (last));
3185                   REG_NOTES (first) = gen_rtx_INSN_LIST (REG_LIBCALL, last,
3186                                                          REG_NOTES (first));
3187                   REG_NOTES (last) = gen_rtx_INSN_LIST (REG_RETVAL, first,
3188                                                         REG_NOTES (last));
3189                 }
3190             }
3191         }
3192
3193       if (model == TLS_MODEL_GLOBAL_DYNAMIC)
3194         {
3195           r3 = gen_rtx_REG (Pmode, 3);
3196           if (TARGET_64BIT)
3197             insn = gen_tls_gd_64 (r3, got, addr);
3198           else
3199             insn = gen_tls_gd_32 (r3, got, addr);
3200           start_sequence ();
3201           emit_insn (insn);
3202           tga = gen_rtx_MEM (Pmode, rs6000_tls_get_addr ());
3203           insn = gen_call_value (r3, tga, const0_rtx, const0_rtx);
3204           insn = emit_call_insn (insn);
3205           CONST_OR_PURE_CALL_P (insn) = 1;
3206           use_reg (&CALL_INSN_FUNCTION_USAGE (insn), r3);
3207           insn = get_insns ();
3208           end_sequence ();
3209           emit_libcall_block (insn, dest, r3, addr);
3210         }
3211       else if (model == TLS_MODEL_LOCAL_DYNAMIC)
3212         {
3213           r3 = gen_rtx_REG (Pmode, 3);
3214           if (TARGET_64BIT)
3215             insn = gen_tls_ld_64 (r3, got);
3216           else
3217             insn = gen_tls_ld_32 (r3, got);
3218           start_sequence ();
3219           emit_insn (insn);
3220           tga = gen_rtx_MEM (Pmode, rs6000_tls_get_addr ());
3221           insn = gen_call_value (r3, tga, const0_rtx, const0_rtx);
3222           insn = emit_call_insn (insn);
3223           CONST_OR_PURE_CALL_P (insn) = 1;
3224           use_reg (&CALL_INSN_FUNCTION_USAGE (insn), r3);
3225           insn = get_insns ();
3226           end_sequence ();
3227           tmp1 = gen_reg_rtx (Pmode);
3228           eqv = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
3229                                 UNSPEC_TLSLD);
3230           emit_libcall_block (insn, tmp1, r3, eqv);
3231           if (rs6000_tls_size == 16)
3232             {
3233               if (TARGET_64BIT)
3234                 insn = gen_tls_dtprel_64 (dest, tmp1, addr);
3235               else
3236                 insn = gen_tls_dtprel_32 (dest, tmp1, addr);
3237             }
3238           else if (rs6000_tls_size == 32)
3239             {
3240               tmp2 = gen_reg_rtx (Pmode);
3241               if (TARGET_64BIT)
3242                 insn = gen_tls_dtprel_ha_64 (tmp2, tmp1, addr);
3243               else
3244                 insn = gen_tls_dtprel_ha_32 (tmp2, tmp1, addr);
3245               emit_insn (insn);
3246               if (TARGET_64BIT)
3247                 insn = gen_tls_dtprel_lo_64 (dest, tmp2, addr);
3248               else
3249                 insn = gen_tls_dtprel_lo_32 (dest, tmp2, addr);
3250             }
3251           else
3252             {
3253               tmp2 = gen_reg_rtx (Pmode);
3254               if (TARGET_64BIT)
3255                 insn = gen_tls_got_dtprel_64 (tmp2, got, addr);
3256               else
3257                 insn = gen_tls_got_dtprel_32 (tmp2, got, addr);
3258               emit_insn (insn);
3259               insn = gen_rtx_SET (Pmode, dest,
3260                                   gen_rtx_PLUS (Pmode, tmp2, tmp1));
3261             }
3262           emit_insn (insn);
3263         }
3264       else
3265         {
3266           /* IE, or 64 bit offset LE.  */
3267           tmp2 = gen_reg_rtx (Pmode);
3268           if (TARGET_64BIT)
3269             insn = gen_tls_got_tprel_64 (tmp2, got, addr);
3270           else
3271             insn = gen_tls_got_tprel_32 (tmp2, got, addr);
3272           emit_insn (insn);
3273           if (TARGET_64BIT)
3274             insn = gen_tls_tls_64 (dest, tmp2, addr);
3275           else
3276             insn = gen_tls_tls_32 (dest, tmp2, addr);
3277           emit_insn (insn);
3278         }
3279     }
3280
3281   return dest;
3282 }
3283
3284 /* Return 1 if X contains a thread-local symbol.  */
3285
3286 bool
3287 rs6000_tls_referenced_p (rtx x)
3288 {
3289   if (! TARGET_HAVE_TLS)
3290     return false;
3291
3292   return for_each_rtx (&x, &rs6000_tls_symbol_ref_1, 0);
3293 }
3294
3295 /* Return 1 if *X is a thread-local symbol.  This is the same as
3296    rs6000_tls_symbol_ref except for the type of the unused argument.  */
3297
3298 static int
3299 rs6000_tls_symbol_ref_1 (rtx *x, void *data ATTRIBUTE_UNUSED)
3300 {
3301   return RS6000_SYMBOL_REF_TLS_P (*x);
3302 }
3303
3304 /* The convention appears to be to define this wherever it is used.
3305    With legitimize_reload_address now defined here, REG_MODE_OK_FOR_BASE_P
3306    is now used here.  */
3307 #ifndef REG_MODE_OK_FOR_BASE_P
3308 #define REG_MODE_OK_FOR_BASE_P(REGNO, MODE) REG_OK_FOR_BASE_P (REGNO)
3309 #endif
3310
3311 /* Our implementation of LEGITIMIZE_RELOAD_ADDRESS.  Returns a value to
3312    replace the input X, or the original X if no replacement is called for.
3313    The output parameter *WIN is 1 if the calling macro should goto WIN,
3314    0 if it should not.
3315
3316    For RS/6000, we wish to handle large displacements off a base
3317    register by splitting the addend across an addiu/addis and the mem insn.
3318    This cuts number of extra insns needed from 3 to 1.
3319
3320    On Darwin, we use this to generate code for floating point constants.
3321    A movsf_low is generated so we wind up with 2 instructions rather than 3.
3322    The Darwin code is inside #if TARGET_MACHO because only then is
3323    machopic_function_base_name() defined.  */
3324 rtx
3325 rs6000_legitimize_reload_address (rtx x, enum machine_mode mode,
3326                                   int opnum, int type,
3327                                   int ind_levels ATTRIBUTE_UNUSED, int *win)
3328 {
3329   /* We must recognize output that we have already generated ourselves.  */
3330   if (GET_CODE (x) == PLUS
3331       && GET_CODE (XEXP (x, 0)) == PLUS
3332       && GET_CODE (XEXP (XEXP (x, 0), 0)) == REG
3333       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
3334       && GET_CODE (XEXP (x, 1)) == CONST_INT)
3335     {
3336       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
3337                    BASE_REG_CLASS, GET_MODE (x), VOIDmode, 0, 0,
3338                    opnum, (enum reload_type)type);
3339       *win = 1;
3340       return x;
3341     }
3342
3343 #if TARGET_MACHO
3344   if (DEFAULT_ABI == ABI_DARWIN && flag_pic
3345       && GET_CODE (x) == LO_SUM
3346       && GET_CODE (XEXP (x, 0)) == PLUS
3347       && XEXP (XEXP (x, 0), 0) == pic_offset_table_rtx
3348       && GET_CODE (XEXP (XEXP (x, 0), 1)) == HIGH
3349       && GET_CODE (XEXP (XEXP (XEXP (x, 0), 1), 0)) == CONST
3350       && XEXP (XEXP (XEXP (x, 0), 1), 0) == XEXP (x, 1)
3351       && GET_CODE (XEXP (XEXP (x, 1), 0)) == MINUS
3352       && GET_CODE (XEXP (XEXP (XEXP (x, 1), 0), 0)) == SYMBOL_REF
3353       && GET_CODE (XEXP (XEXP (XEXP (x, 1), 0), 1)) == SYMBOL_REF)
3354     {
3355       /* Result of previous invocation of this function on Darwin
3356          floating point constant.  */
3357       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
3358                    BASE_REG_CLASS, Pmode, VOIDmode, 0, 0,
3359                    opnum, (enum reload_type)type);
3360       *win = 1;
3361       return x;
3362     }
3363 #endif
3364
3365   /* Force ld/std non-word aligned offset into base register by wrapping
3366      in offset 0.  */
3367   if (GET_CODE (x) == PLUS
3368       && GET_CODE (XEXP (x, 0)) == REG
3369       && REGNO (XEXP (x, 0)) < 32
3370       && REG_MODE_OK_FOR_BASE_P (XEXP (x, 0), mode)
3371       && GET_CODE (XEXP (x, 1)) == CONST_INT
3372       && (INTVAL (XEXP (x, 1)) & 3) != 0
3373       && !ALTIVEC_VECTOR_MODE (mode)
3374       && GET_MODE_SIZE (mode) >= UNITS_PER_WORD
3375       && TARGET_POWERPC64)
3376     {
3377       x = gen_rtx_PLUS (GET_MODE (x), x, GEN_INT (0));
3378       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
3379                    BASE_REG_CLASS, GET_MODE (x), VOIDmode, 0, 0,
3380                    opnum, (enum reload_type) type);
3381       *win = 1;
3382       return x;
3383     }
3384
3385   if (GET_CODE (x) == PLUS
3386       && GET_CODE (XEXP (x, 0)) == REG
3387       && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER
3388       && REG_MODE_OK_FOR_BASE_P (XEXP (x, 0), mode)
3389       && GET_CODE (XEXP (x, 1)) == CONST_INT
3390       && !SPE_VECTOR_MODE (mode)
3391       && !(TARGET_E500_DOUBLE && (mode == DFmode
3392                                   || mode == DImode))
3393       && !ALTIVEC_VECTOR_MODE (mode))
3394     {
3395       HOST_WIDE_INT val = INTVAL (XEXP (x, 1));
3396       HOST_WIDE_INT low = ((val & 0xffff) ^ 0x8000) - 0x8000;
3397       HOST_WIDE_INT high
3398         = (((val - low) & 0xffffffff) ^ 0x80000000) - 0x80000000;
3399
3400       /* Check for 32-bit overflow.  */
3401       if (high + low != val)
3402         {
3403           *win = 0;
3404           return x;
3405         }
3406
3407       /* Reload the high part into a base reg; leave the low part
3408          in the mem directly.  */
3409
3410       x = gen_rtx_PLUS (GET_MODE (x),
3411                         gen_rtx_PLUS (GET_MODE (x), XEXP (x, 0),
3412                                       GEN_INT (high)),
3413                         GEN_INT (low));
3414
3415       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
3416                    BASE_REG_CLASS, GET_MODE (x), VOIDmode, 0, 0,
3417                    opnum, (enum reload_type)type);
3418       *win = 1;
3419       return x;
3420     }
3421
3422   if (GET_CODE (x) == SYMBOL_REF
3423       && !ALTIVEC_VECTOR_MODE (mode)
3424       && !SPE_VECTOR_MODE (mode)
3425 #if TARGET_MACHO
3426       && DEFAULT_ABI == ABI_DARWIN
3427       && (flag_pic || MACHO_DYNAMIC_NO_PIC_P)
3428 #else
3429       && DEFAULT_ABI == ABI_V4
3430       && !flag_pic
3431 #endif
3432       /* Don't do this for TFmode, since the result isn't offsettable.
3433          The same goes for DImode without 64-bit gprs and DFmode
3434          without fprs.  */
3435       && mode != TFmode
3436       && (mode != DImode || TARGET_POWERPC64)
3437       && (mode != DFmode || TARGET_POWERPC64
3438           || (TARGET_FPRS && TARGET_HARD_FLOAT)))
3439     {
3440 #if TARGET_MACHO
3441       if (flag_pic)
3442         {
3443           rtx offset = gen_rtx_CONST (Pmode,
3444                          gen_rtx_MINUS (Pmode, x,
3445                                         machopic_function_base_sym ()));
3446           x = gen_rtx_LO_SUM (GET_MODE (x),
3447                 gen_rtx_PLUS (Pmode, pic_offset_table_rtx,
3448                   gen_rtx_HIGH (Pmode, offset)), offset);
3449         }
3450       else
3451 #endif
3452         x = gen_rtx_LO_SUM (GET_MODE (x),
3453               gen_rtx_HIGH (Pmode, x), x);
3454
3455       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
3456                    BASE_REG_CLASS, Pmode, VOIDmode, 0, 0,
3457                    opnum, (enum reload_type)type);
3458       *win = 1;
3459       return x;
3460     }
3461
3462   /* Reload an offset address wrapped by an AND that represents the
3463      masking of the lower bits.  Strip the outer AND and let reload
3464      convert the offset address into an indirect address.  */
3465   if (TARGET_ALTIVEC
3466       && ALTIVEC_VECTOR_MODE (mode)
3467       && GET_CODE (x) == AND
3468       && GET_CODE (XEXP (x, 0)) == PLUS
3469       && GET_CODE (XEXP (XEXP (x, 0), 0)) == REG
3470       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
3471       && GET_CODE (XEXP (x, 1)) == CONST_INT
3472       && INTVAL (XEXP (x, 1)) == -16)
3473     {
3474       x = XEXP (x, 0);
3475       *win = 1;
3476       return x;
3477     }
3478
3479   if (TARGET_TOC
3480       && constant_pool_expr_p (x)
3481       && ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (get_pool_constant (x), mode))
3482     {
3483       x = create_TOC_reference (x);
3484       *win = 1;
3485       return x;
3486     }
3487   *win = 0;
3488   return x;
3489 }
3490
3491 /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression
3492    that is a valid memory address for an instruction.
3493    The MODE argument is the machine mode for the MEM expression
3494    that wants to use this address.
3495
3496    On the RS/6000, there are four valid address: a SYMBOL_REF that
3497    refers to a constant pool entry of an address (or the sum of it
3498    plus a constant), a short (16-bit signed) constant plus a register,
3499    the sum of two registers, or a register indirect, possibly with an
3500    auto-increment.  For DFmode and DImode with a constant plus register,
3501    we must ensure that both words are addressable or PowerPC64 with offset
3502    word aligned.
3503
3504    For modes spanning multiple registers (DFmode in 32-bit GPRs,
3505    32-bit DImode, TImode, TFmode), indexed addressing cannot be used because
3506    adjacent memory cells are accessed by adding word-sized offsets
3507    during assembly output.  */
3508 int
3509 rs6000_legitimate_address (enum machine_mode mode, rtx x, int reg_ok_strict)
3510 {
3511   /* If this is an unaligned stvx/ldvx type address, discard the outer AND.  */
3512   if (TARGET_ALTIVEC
3513       && ALTIVEC_VECTOR_MODE (mode)
3514       && GET_CODE (x) == AND
3515       && GET_CODE (XEXP (x, 1)) == CONST_INT
3516       && INTVAL (XEXP (x, 1)) == -16)
3517     x = XEXP (x, 0);
3518
3519   if (RS6000_SYMBOL_REF_TLS_P (x))
3520     return 0;
3521   if (legitimate_indirect_address_p (x, reg_ok_strict))
3522     return 1;
3523   if ((GET_CODE (x) == PRE_INC || GET_CODE (x) == PRE_DEC)
3524       && !ALTIVEC_VECTOR_MODE (mode)
3525       && !SPE_VECTOR_MODE (mode)
3526       && mode != TFmode
3527       /* Restrict addressing for DI because of our SUBREG hackery.  */
3528       && !(TARGET_E500_DOUBLE && (mode == DFmode || mode == DImode))
3529       && TARGET_UPDATE
3530       && legitimate_indirect_address_p (XEXP (x, 0), reg_ok_strict))
3531     return 1;
3532   if (legitimate_small_data_p (mode, x))
3533     return 1;
3534   if (legitimate_constant_pool_address_p (x))
3535     return 1;
3536   /* If not REG_OK_STRICT (before reload) let pass any stack offset.  */
3537   if (! reg_ok_strict
3538       && GET_CODE (x) == PLUS
3539       && GET_CODE (XEXP (x, 0)) == REG
3540       && (XEXP (x, 0) == virtual_stack_vars_rtx
3541           || XEXP (x, 0) == arg_pointer_rtx)
3542       && GET_CODE (XEXP (x, 1)) == CONST_INT)
3543     return 1;
3544   if (rs6000_legitimate_offset_address_p (mode, x, reg_ok_strict))
3545     return 1;
3546   if (mode != TImode
3547       && mode != TFmode
3548       && ((TARGET_HARD_FLOAT && TARGET_FPRS)
3549           || TARGET_POWERPC64
3550           || ((mode != DFmode || TARGET_E500_DOUBLE) && mode != TFmode))
3551       && (TARGET_POWERPC64 || mode != DImode)
3552       && legitimate_indexed_address_p (x, reg_ok_strict))
3553     return 1;
3554   if (legitimate_lo_sum_address_p (mode, x, reg_ok_strict))
3555     return 1;
3556   return 0;
3557 }
3558
3559 /* Go to LABEL if ADDR (a legitimate address expression)
3560    has an effect that depends on the machine mode it is used for.
3561
3562    On the RS/6000 this is true of all integral offsets (since AltiVec
3563    modes don't allow them) or is a pre-increment or decrement.
3564
3565    ??? Except that due to conceptual problems in offsettable_address_p
3566    we can't really report the problems of integral offsets.  So leave
3567    this assuming that the adjustable offset must be valid for the
3568    sub-words of a TFmode operand, which is what we had before.  */
3569
3570 bool
3571 rs6000_mode_dependent_address (rtx addr)
3572 {
3573   switch (GET_CODE (addr))
3574     {
3575     case PLUS:
3576       if (GET_CODE (XEXP (addr, 1)) == CONST_INT)
3577         {
3578           unsigned HOST_WIDE_INT val = INTVAL (XEXP (addr, 1));
3579           return val + 12 + 0x8000 >= 0x10000;
3580         }
3581       break;
3582
3583     case LO_SUM:
3584       return true;
3585
3586     case PRE_INC:
3587     case PRE_DEC:
3588       return TARGET_UPDATE;
3589
3590     default:
3591       break;
3592     }
3593
3594   return false;
3595 }
3596
3597 /* More elaborate version of recog's offsettable_memref_p predicate
3598    that works around the ??? note of rs6000_mode_dependent_address.
3599    In particular it accepts
3600
3601      (mem:DI (plus:SI (reg/f:SI 31 31) (const_int 32760 [0x7ff8])))
3602
3603    in 32-bit mode, that the recog predicate rejects.  */
3604
3605 bool
3606 rs6000_offsettable_memref_p (rtx op)
3607 {
3608   if (!MEM_P (op))
3609     return false;
3610
3611   /* First mimic offsettable_memref_p.  */
3612   if (offsettable_address_p (1, GET_MODE (op), XEXP (op, 0)))
3613     return true;
3614
3615   /* offsettable_address_p invokes rs6000_mode_dependent_address, but
3616      the latter predicate knows nothing about the mode of the memory
3617      reference and, therefore, assumes that it is the largest supported
3618      mode (TFmode).  As a consequence, legitimate offsettable memory
3619      references are rejected.  rs6000_legitimate_offset_address_p contains
3620      the correct logic for the PLUS case of rs6000_mode_dependent_address.  */
3621   return rs6000_legitimate_offset_address_p (GET_MODE (op), XEXP (op, 0), 1);
3622 }
3623
3624 /* Return number of consecutive hard regs needed starting at reg REGNO
3625    to hold something of mode MODE.
3626    This is ordinarily the length in words of a value of mode MODE
3627    but can be less for certain modes in special long registers.
3628
3629    For the SPE, GPRs are 64 bits but only 32 bits are visible in
3630    scalar instructions.  The upper 32 bits are only available to the
3631    SIMD instructions.
3632
3633    POWER and PowerPC GPRs hold 32 bits worth;
3634    PowerPC64 GPRs and FPRs point register holds 64 bits worth.  */
3635
3636 int
3637 rs6000_hard_regno_nregs (int regno, enum machine_mode mode)
3638 {
3639   if (FP_REGNO_P (regno))
3640     return (GET_MODE_SIZE (mode) + UNITS_PER_FP_WORD - 1) / UNITS_PER_FP_WORD;
3641
3642   if (TARGET_E500_DOUBLE && mode == DFmode)
3643     return 1;
3644
3645   if (SPE_SIMD_REGNO_P (regno) && TARGET_SPE && SPE_VECTOR_MODE (mode))
3646     return (GET_MODE_SIZE (mode) + UNITS_PER_SPE_WORD - 1) / UNITS_PER_SPE_WORD;
3647
3648   if (ALTIVEC_REGNO_P (regno))
3649     return
3650       (GET_MODE_SIZE (mode) + UNITS_PER_ALTIVEC_WORD - 1) / UNITS_PER_ALTIVEC_WORD;
3651
3652   return (GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
3653 }
3654
3655 /* Change register usage conditional on target flags.  */
3656 void
3657 rs6000_conditional_register_usage (void)
3658 {
3659   int i;
3660
3661   /* Set MQ register fixed (already call_used) if not POWER
3662      architecture (RIOS1, RIOS2, RSC, and PPC601) so that it will not
3663      be allocated.  */
3664   if (! TARGET_POWER)
3665     fixed_regs[64] = 1;
3666
3667   /* 64-bit AIX and Linux reserve GPR13 for thread-private data.  */
3668   if (TARGET_64BIT)
3669     fixed_regs[13] = call_used_regs[13]
3670       = call_really_used_regs[13] = 1;
3671
3672   /* Conditionally disable FPRs.  */
3673   if (TARGET_SOFT_FLOAT || !TARGET_FPRS)
3674     for (i = 32; i < 64; i++)
3675       fixed_regs[i] = call_used_regs[i]
3676         = call_really_used_regs[i] = 1;
3677
3678   /* The TOC register is not killed across calls in a way that is
3679      visible to the compiler.  */
3680   if (DEFAULT_ABI == ABI_AIX)
3681     call_really_used_regs[2] = 0;
3682
3683   if (DEFAULT_ABI == ABI_V4
3684       && PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
3685       && flag_pic == 2)
3686     fixed_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] = 1;
3687
3688   if (DEFAULT_ABI == ABI_V4
3689       && PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
3690       && flag_pic == 1)
3691     fixed_regs[RS6000_PIC_OFFSET_TABLE_REGNUM]
3692       = call_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM]
3693       = call_really_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] = 1;
3694
3695   if (DEFAULT_ABI == ABI_DARWIN
3696       && PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM)
3697       fixed_regs[RS6000_PIC_OFFSET_TABLE_REGNUM]
3698       = call_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM]
3699       = call_really_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] = 1;
3700
3701   if (TARGET_TOC && TARGET_MINIMAL_TOC)
3702     fixed_regs[RS6000_PIC_OFFSET_TABLE_REGNUM]
3703       = call_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] = 1;
3704
3705   if (TARGET_ALTIVEC)
3706     global_regs[VSCR_REGNO] = 1;
3707
3708   if (TARGET_SPE)
3709     {
3710       global_regs[SPEFSCR_REGNO] = 1;
3711       fixed_regs[FIXED_SCRATCH]
3712         = call_used_regs[FIXED_SCRATCH]
3713         = call_really_used_regs[FIXED_SCRATCH] = 1;
3714     }
3715
3716   if (! TARGET_ALTIVEC)
3717     {
3718       for (i = FIRST_ALTIVEC_REGNO; i <= LAST_ALTIVEC_REGNO; ++i)
3719         fixed_regs[i] = call_used_regs[i] = call_really_used_regs[i] = 1;
3720       call_really_used_regs[VRSAVE_REGNO] = 1;
3721     }
3722
3723   if (TARGET_ALTIVEC_ABI)
3724     for (i = FIRST_ALTIVEC_REGNO; i < FIRST_ALTIVEC_REGNO + 20; ++i)
3725       call_used_regs[i] = call_really_used_regs[i] = 1;
3726 }
3727 \f
3728 /* Try to output insns to set TARGET equal to the constant C if it can
3729    be done in less than N insns.  Do all computations in MODE.
3730    Returns the place where the output has been placed if it can be
3731    done and the insns have been emitted.  If it would take more than N
3732    insns, zero is returned and no insns and emitted.  */
3733
3734 rtx
3735 rs6000_emit_set_const (rtx dest, enum machine_mode mode,
3736                        rtx source, int n ATTRIBUTE_UNUSED)
3737 {
3738   rtx result, insn, set;
3739   HOST_WIDE_INT c0, c1;
3740
3741   switch (mode)
3742     {
3743       case  QImode:
3744     case HImode:
3745       if (dest == NULL)
3746         dest = gen_reg_rtx (mode);
3747       emit_insn (gen_rtx_SET (VOIDmode, dest, source));
3748       return dest;
3749
3750     case SImode:
3751       result = no_new_pseudos ? dest : gen_reg_rtx (SImode);
3752
3753       emit_insn (gen_rtx_SET (VOIDmode, result,
3754                               GEN_INT (INTVAL (source)
3755                                        & (~ (HOST_WIDE_INT) 0xffff))));
3756       emit_insn (gen_rtx_SET (VOIDmode, dest,
3757                               gen_rtx_IOR (SImode, result,
3758                                            GEN_INT (INTVAL (source) & 0xffff))));
3759       result = dest;
3760       break;
3761
3762     case DImode:
3763       switch (GET_CODE (source))
3764         {
3765         case CONST_INT:
3766           c0 = INTVAL (source);
3767           c1 = -(c0 < 0);
3768           break;
3769
3770         case CONST_DOUBLE:
3771 #if HOST_BITS_PER_WIDE_INT >= 64
3772           c0 = CONST_DOUBLE_LOW (source);
3773           c1 = -(c0 < 0);
3774 #else
3775           c0 = CONST_DOUBLE_LOW (source);
3776           c1 = CONST_DOUBLE_HIGH (source);
3777 #endif
3778           break;
3779
3780         default:
3781           gcc_unreachable ();
3782         }
3783
3784       result = rs6000_emit_set_long_const (dest, c0, c1);
3785       break;
3786
3787     default:
3788       gcc_unreachable ();
3789     }
3790
3791   insn = get_last_insn ();
3792   set = single_set (insn);
3793   if (! CONSTANT_P (SET_SRC (set)))
3794     set_unique_reg_note (insn, REG_EQUAL, source);
3795
3796   return result;
3797 }
3798
3799 /* Having failed to find a 3 insn sequence in rs6000_emit_set_const,
3800    fall back to a straight forward decomposition.  We do this to avoid
3801    exponential run times encountered when looking for longer sequences
3802    with rs6000_emit_set_const.  */
3803 static rtx
3804 rs6000_emit_set_long_const (rtx dest, HOST_WIDE_INT c1, HOST_WIDE_INT c2)
3805 {
3806   if (!TARGET_POWERPC64)
3807     {
3808       rtx operand1, operand2;
3809
3810       operand1 = operand_subword_force (dest, WORDS_BIG_ENDIAN == 0,
3811                                         DImode);
3812       operand2 = operand_subword_force (dest, WORDS_BIG_ENDIAN != 0,
3813                                         DImode);
3814       emit_move_insn (operand1, GEN_INT (c1));
3815       emit_move_insn (operand2, GEN_INT (c2));
3816     }
3817   else
3818     {
3819       HOST_WIDE_INT ud1, ud2, ud3, ud4;
3820
3821       ud1 = c1 & 0xffff;
3822       ud2 = (c1 & 0xffff0000) >> 16;
3823 #if HOST_BITS_PER_WIDE_INT >= 64
3824       c2 = c1 >> 32;
3825 #endif
3826       ud3 = c2 & 0xffff;
3827       ud4 = (c2 & 0xffff0000) >> 16;
3828
3829       if ((ud4 == 0xffff && ud3 == 0xffff && ud2 == 0xffff && (ud1 & 0x8000))
3830           || (ud4 == 0 && ud3 == 0 && ud2 == 0 && ! (ud1 & 0x8000)))
3831         {
3832           if (ud1 & 0x8000)
3833             emit_move_insn (dest, GEN_INT (((ud1 ^ 0x8000) -  0x8000)));
3834           else
3835             emit_move_insn (dest, GEN_INT (ud1));
3836         }
3837
3838       else if ((ud4 == 0xffff && ud3 == 0xffff && (ud2 & 0x8000))
3839                || (ud4 == 0 && ud3 == 0 && ! (ud2 & 0x8000)))
3840         {
3841           if (ud2 & 0x8000)
3842             emit_move_insn (dest, GEN_INT (((ud2 << 16) ^ 0x80000000)
3843                                            - 0x80000000));
3844           else
3845             emit_move_insn (dest, GEN_INT (ud2 << 16));
3846           if (ud1 != 0)
3847             emit_move_insn (dest, gen_rtx_IOR (DImode, dest, GEN_INT (ud1)));
3848         }
3849       else if ((ud4 == 0xffff && (ud3 & 0x8000))
3850                || (ud4 == 0 && ! (ud3 & 0x8000)))
3851         {
3852           if (ud3 & 0x8000)
3853             emit_move_insn (dest, GEN_INT (((ud3 << 16) ^ 0x80000000)
3854                                            - 0x80000000));
3855           else
3856             emit_move_insn (dest, GEN_INT (ud3 << 16));
3857
3858           if (ud2 != 0)
3859             emit_move_insn (dest, gen_rtx_IOR (DImode, dest, GEN_INT (ud2)));
3860           emit_move_insn (dest, gen_rtx_ASHIFT (DImode, dest, GEN_INT (16)));
3861           if (ud1 != 0)
3862             emit_move_insn (dest, gen_rtx_IOR (DImode, dest, GEN_INT (ud1)));
3863         }
3864       else
3865         {
3866           if (ud4 & 0x8000)
3867             emit_move_insn (dest, GEN_INT (((ud4 << 16) ^ 0x80000000)
3868                                            - 0x80000000));
3869           else
3870             emit_move_insn (dest, GEN_INT (ud4 << 16));
3871
3872           if (ud3 != 0)
3873             emit_move_insn (dest, gen_rtx_IOR (DImode, dest, GEN_INT (ud3)));
3874
3875           emit_move_insn (dest, gen_rtx_ASHIFT (DImode, dest, GEN_INT (32)));
3876           if (ud2 != 0)
3877             emit_move_insn (dest, gen_rtx_IOR (DImode, dest,
3878                                                GEN_INT (ud2 << 16)));
3879           if (ud1 != 0)
3880             emit_move_insn (dest, gen_rtx_IOR (DImode, dest, GEN_INT (ud1)));
3881         }
3882     }
3883   return dest;
3884 }
3885
3886 /* Helper for the following.  Get rid of [r+r] memory refs
3887    in cases where it won't work (TImode, TFmode).  */
3888
3889 static void
3890 rs6000_eliminate_indexed_memrefs (rtx operands[2])
3891 {
3892   if (GET_CODE (operands[0]) == MEM
3893       && GET_CODE (XEXP (operands[0], 0)) != REG
3894       && ! legitimate_constant_pool_address_p (XEXP (operands[0], 0))
3895       && ! reload_in_progress)
3896     operands[0]
3897       = replace_equiv_address (operands[0],
3898                                copy_addr_to_reg (XEXP (operands[0], 0)));
3899
3900   if (GET_CODE (operands[1]) == MEM
3901       && GET_CODE (XEXP (operands[1], 0)) != REG
3902       && ! legitimate_constant_pool_address_p (XEXP (operands[1], 0))
3903       && ! reload_in_progress)
3904     operands[1]
3905       = replace_equiv_address (operands[1],
3906                                copy_addr_to_reg (XEXP (operands[1], 0)));
3907 }
3908
3909 /* Emit a move from SOURCE to DEST in mode MODE.  */
3910 void
3911 rs6000_emit_move (rtx dest, rtx source, enum machine_mode mode)
3912 {
3913   rtx operands[2];
3914   operands[0] = dest;
3915   operands[1] = source;
3916
3917   /* Sanity checks.  Check that we get CONST_DOUBLE only when we should.  */
3918   if (GET_CODE (operands[1]) == CONST_DOUBLE
3919       && ! FLOAT_MODE_P (mode)
3920       && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
3921     {
3922       /* FIXME.  This should never happen.  */
3923       /* Since it seems that it does, do the safe thing and convert
3924          to a CONST_INT.  */
3925       operands[1] = gen_int_mode (CONST_DOUBLE_LOW (operands[1]), mode);
3926     }
3927   gcc_assert (GET_CODE (operands[1]) != CONST_DOUBLE
3928               || FLOAT_MODE_P (mode)
3929               || ((CONST_DOUBLE_HIGH (operands[1]) != 0
3930                    || CONST_DOUBLE_LOW (operands[1]) < 0)
3931                   && (CONST_DOUBLE_HIGH (operands[1]) != -1
3932                       || CONST_DOUBLE_LOW (operands[1]) >= 0)));
3933
3934   /* Check if GCC is setting up a block move that will end up using FP
3935      registers as temporaries.  We must make sure this is acceptable.  */
3936   if (GET_CODE (operands[0]) == MEM
3937       && GET_CODE (operands[1]) == MEM
3938       && mode == DImode
3939       && (SLOW_UNALIGNED_ACCESS (DImode, MEM_ALIGN (operands[0]))
3940           || SLOW_UNALIGNED_ACCESS (DImode, MEM_ALIGN (operands[1])))
3941       && ! (SLOW_UNALIGNED_ACCESS (SImode, (MEM_ALIGN (operands[0]) > 32
3942                                             ? 32 : MEM_ALIGN (operands[0])))
3943             || SLOW_UNALIGNED_ACCESS (SImode, (MEM_ALIGN (operands[1]) > 32
3944                                                ? 32
3945                                                : MEM_ALIGN (operands[1]))))
3946       && ! MEM_VOLATILE_P (operands [0])
3947       && ! MEM_VOLATILE_P (operands [1]))
3948     {
3949       emit_move_insn (adjust_address (operands[0], SImode, 0),
3950                       adjust_address (operands[1], SImode, 0));
3951       emit_move_insn (adjust_address (operands[0], SImode, 4),
3952                       adjust_address (operands[1], SImode, 4));
3953       return;
3954     }
3955
3956   if (!no_new_pseudos && GET_CODE (operands[0]) == MEM
3957       && !gpc_reg_operand (operands[1], mode))
3958     operands[1] = force_reg (mode, operands[1]);
3959
3960   if (mode == SFmode && ! TARGET_POWERPC
3961       && TARGET_HARD_FLOAT && TARGET_FPRS
3962       && GET_CODE (operands[0]) == MEM)
3963     {
3964       int regnum;
3965
3966       if (reload_in_progress || reload_completed)
3967         regnum = true_regnum (operands[1]);
3968       else if (GET_CODE (operands[1]) == REG)
3969         regnum = REGNO (operands[1]);
3970       else
3971         regnum = -1;
3972
3973       /* If operands[1] is a register, on POWER it may have
3974          double-precision data in it, so truncate it to single
3975          precision.  */
3976       if (FP_REGNO_P (regnum) || regnum >= FIRST_PSEUDO_REGISTER)
3977         {
3978           rtx newreg;
3979           newreg = (no_new_pseudos ? operands[1] : gen_reg_rtx (mode));
3980           emit_insn (gen_aux_truncdfsf2 (newreg, operands[1]));
3981           operands[1] = newreg;
3982         }
3983     }
3984
3985   /* Recognize the case where operand[1] is a reference to thread-local
3986      data and load its address to a register.  */
3987   if (rs6000_tls_referenced_p (operands[1]))
3988     {
3989       enum tls_model model;
3990       rtx tmp = operands[1];
3991       rtx addend = NULL;
3992
3993       if (GET_CODE (tmp) == CONST && GET_CODE (XEXP (tmp, 0)) == PLUS)
3994         {
3995           addend = XEXP (XEXP (tmp, 0), 1);
3996           tmp = XEXP (XEXP (tmp, 0), 0);
3997         }
3998
3999       gcc_assert (GET_CODE (tmp) == SYMBOL_REF);
4000       model = SYMBOL_REF_TLS_MODEL (tmp);
4001       gcc_assert (model != 0);
4002
4003       tmp = rs6000_legitimize_tls_address (tmp, model);
4004       if (addend)
4005         {
4006        &nb