OSDN Git Service

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