OSDN Git Service

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