OSDN Git Service

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