OSDN Git Service

* config/rs6000/rs6000.h (CLASS_MAX_NREGS): DF goes in 1 register
[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 bool invalid_e500_subreg (rtx, enum machine_mode);
714 static int rs6000_emit_int_cmove (rtx, rtx, rtx, rtx);
715 static rs6000_stack_t *rs6000_stack_info (void);
716 static void debug_stack_info (rs6000_stack_t *);
717
718 static rtx altivec_expand_builtin (tree, rtx, bool *);
719 static rtx altivec_expand_ld_builtin (tree, rtx, bool *);
720 static rtx altivec_expand_st_builtin (tree, rtx, bool *);
721 static rtx altivec_expand_dst_builtin (tree, rtx, bool *);
722 static rtx altivec_expand_abs_builtin (enum insn_code, tree, rtx);
723 static rtx altivec_expand_predicate_builtin (enum insn_code,
724                                              const char *, tree, rtx);
725 static rtx altivec_expand_lv_builtin (enum insn_code, tree, rtx);
726 static rtx altivec_expand_stv_builtin (enum insn_code, tree);
727 static void rs6000_parse_abi_options (void);
728 static void rs6000_parse_alignment_option (void);
729 static void rs6000_parse_tls_size_option (void);
730 static void rs6000_parse_yes_no_option (const char *, const char *, int *);
731 static void rs6000_parse_float_gprs_option (void);
732 static int first_altivec_reg_to_save (void);
733 static unsigned int compute_vrsave_mask (void);
734 static void compute_save_world_info(rs6000_stack_t *info_ptr);
735 static void is_altivec_return_reg (rtx, void *);
736 static rtx generate_set_vrsave (rtx, rs6000_stack_t *, int);
737 int easy_vector_constant (rtx, enum machine_mode);
738 static int easy_vector_same (rtx, enum machine_mode);
739 static int easy_vector_splat_const (int, enum machine_mode);
740 static bool is_ev64_opaque_type (tree);
741 static rtx rs6000_dwarf_register_span (rtx);
742 static rtx rs6000_legitimize_tls_address (rtx, enum tls_model);
743 static rtx rs6000_tls_get_addr (void);
744 static rtx rs6000_got_sym (void);
745 static inline int rs6000_tls_symbol_ref_1 (rtx *, void *);
746 static const char *rs6000_get_some_local_dynamic_name (void);
747 static int rs6000_get_some_local_dynamic_name_1 (rtx *, void *);
748 static rtx rs6000_complex_function_value (enum machine_mode);
749 static rtx rs6000_spe_function_arg (CUMULATIVE_ARGS *,
750                                     enum machine_mode, tree);
751 static rtx rs6000_darwin64_function_arg (CUMULATIVE_ARGS *,
752                                          enum machine_mode, tree, int);
753 static rtx rs6000_mixed_function_arg (enum machine_mode, tree, int);
754 static void rs6000_move_block_from_reg (int regno, rtx x, int nregs);
755 static void setup_incoming_varargs (CUMULATIVE_ARGS *,
756                                     enum machine_mode, tree,
757                                     int *, int);
758 static bool rs6000_pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode,
759                                       tree, bool);
760 static int rs6000_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode,
761                                      tree, bool);
762 #if TARGET_MACHO
763 static void macho_branch_islands (void);
764 static void add_compiler_branch_island (tree, tree, int);
765 static int no_previous_def (tree function_name);
766 static tree get_prev_label (tree function_name);
767 static void rs6000_darwin_file_start (void);
768 #endif
769
770 static tree rs6000_build_builtin_va_list (void);
771 static tree rs6000_gimplify_va_arg (tree, tree, tree *, tree *);
772 static bool rs6000_must_pass_in_stack (enum machine_mode, tree);
773 static bool rs6000_vector_mode_supported_p (enum machine_mode);
774 static int get_vec_cmp_insn (enum rtx_code, enum machine_mode,
775                              enum machine_mode);
776 static rtx rs6000_emit_vector_compare (enum rtx_code, rtx, rtx,
777                                        enum machine_mode);
778 static int get_vsel_insn (enum machine_mode);
779 static void rs6000_emit_vector_select (rtx, rtx, rtx, rtx);
780
781
782 const int INSN_NOT_AVAILABLE = -1;
783 static enum machine_mode rs6000_eh_return_filter_mode (void);
784
785 /* Hash table stuff for keeping track of TOC entries.  */
786
787 struct toc_hash_struct GTY(())
788 {
789   /* `key' will satisfy CONSTANT_P; in fact, it will satisfy
790      ASM_OUTPUT_SPECIAL_POOL_ENTRY_P.  */
791   rtx key;
792   enum machine_mode key_mode;
793   int labelno;
794 };
795
796 static GTY ((param_is (struct toc_hash_struct))) htab_t toc_hash_table;
797 \f
798 /* Default register names.  */
799 char rs6000_reg_names[][8] =
800 {
801       "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",
802       "8",  "9", "10", "11", "12", "13", "14", "15",
803      "16", "17", "18", "19", "20", "21", "22", "23",
804      "24", "25", "26", "27", "28", "29", "30", "31",
805       "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",
806       "8",  "9", "10", "11", "12", "13", "14", "15",
807      "16", "17", "18", "19", "20", "21", "22", "23",
808      "24", "25", "26", "27", "28", "29", "30", "31",
809      "mq", "lr", "ctr","ap",
810       "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",
811       "xer",
812       /* AltiVec registers.  */
813       "0",  "1",  "2",  "3",  "4",  "5",  "6", "7",
814       "8",  "9",  "10", "11", "12", "13", "14", "15",
815       "16", "17", "18", "19", "20", "21", "22", "23",
816       "24", "25", "26", "27", "28", "29", "30", "31",
817       "vrsave", "vscr",
818       /* SPE registers.  */
819       "spe_acc", "spefscr"
820 };
821
822 #ifdef TARGET_REGNAMES
823 static const char alt_reg_names[][8] =
824 {
825    "%r0",   "%r1",  "%r2",  "%r3",  "%r4",  "%r5",  "%r6",  "%r7",
826    "%r8",   "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15",
827   "%r16",  "%r17", "%r18", "%r19", "%r20", "%r21", "%r22", "%r23",
828   "%r24",  "%r25", "%r26", "%r27", "%r28", "%r29", "%r30", "%r31",
829    "%f0",   "%f1",  "%f2",  "%f3",  "%f4",  "%f5",  "%f6",  "%f7",
830    "%f8",   "%f9", "%f10", "%f11", "%f12", "%f13", "%f14", "%f15",
831   "%f16",  "%f17", "%f18", "%f19", "%f20", "%f21", "%f22", "%f23",
832   "%f24",  "%f25", "%f26", "%f27", "%f28", "%f29", "%f30", "%f31",
833     "mq",    "lr",  "ctr",   "ap",
834   "%cr0",  "%cr1", "%cr2", "%cr3", "%cr4", "%cr5", "%cr6", "%cr7",
835    "xer",
836   /* AltiVec registers.  */
837    "%v0",  "%v1",  "%v2",  "%v3",  "%v4",  "%v5",  "%v6", "%v7",
838    "%v8",  "%v9", "%v10", "%v11", "%v12", "%v13", "%v14", "%v15",
839   "%v16", "%v17", "%v18", "%v19", "%v20", "%v21", "%v22", "%v23",
840   "%v24", "%v25", "%v26", "%v27", "%v28", "%v29", "%v30", "%v31",
841   "vrsave", "vscr",
842   /* SPE registers.  */
843   "spe_acc", "spefscr"
844 };
845 #endif
846 \f
847 #ifndef MASK_STRICT_ALIGN
848 #define MASK_STRICT_ALIGN 0
849 #endif
850 #ifndef TARGET_PROFILE_KERNEL
851 #define TARGET_PROFILE_KERNEL 0
852 #endif
853
854 /* The VRSAVE bitmask puts bit %v0 as the most significant bit.  */
855 #define ALTIVEC_REG_BIT(REGNO) (0x80000000 >> ((REGNO) - FIRST_ALTIVEC_REGNO))
856
857 /* Return 1 for a symbol ref for a thread-local storage symbol.  */
858 #define RS6000_SYMBOL_REF_TLS_P(RTX) \
859   (GET_CODE (RTX) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (RTX) != 0)
860 \f
861 /* Initialize the GCC target structure.  */
862 #undef TARGET_ATTRIBUTE_TABLE
863 #define TARGET_ATTRIBUTE_TABLE rs6000_attribute_table
864 #undef TARGET_SET_DEFAULT_TYPE_ATTRIBUTES
865 #define TARGET_SET_DEFAULT_TYPE_ATTRIBUTES rs6000_set_default_type_attributes
866
867 #undef TARGET_ASM_ALIGNED_DI_OP
868 #define TARGET_ASM_ALIGNED_DI_OP DOUBLE_INT_ASM_OP
869
870 /* Default unaligned ops are only provided for ELF.  Find the ops needed
871    for non-ELF systems.  */
872 #ifndef OBJECT_FORMAT_ELF
873 #if TARGET_XCOFF
874 /* For XCOFF.  rs6000_assemble_integer will handle unaligned DIs on
875    64-bit targets.  */
876 #undef TARGET_ASM_UNALIGNED_HI_OP
877 #define TARGET_ASM_UNALIGNED_HI_OP "\t.vbyte\t2,"
878 #undef TARGET_ASM_UNALIGNED_SI_OP
879 #define TARGET_ASM_UNALIGNED_SI_OP "\t.vbyte\t4,"
880 #undef TARGET_ASM_UNALIGNED_DI_OP
881 #define TARGET_ASM_UNALIGNED_DI_OP "\t.vbyte\t8,"
882 #else
883 /* For Darwin.  */
884 #undef TARGET_ASM_UNALIGNED_HI_OP
885 #define TARGET_ASM_UNALIGNED_HI_OP "\t.short\t"
886 #undef TARGET_ASM_UNALIGNED_SI_OP
887 #define TARGET_ASM_UNALIGNED_SI_OP "\t.long\t"
888 #undef TARGET_ASM_UNALIGNED_DI_OP
889 #define TARGET_ASM_UNALIGNED_DI_OP "\t.quad\t"
890 #undef TARGET_ASM_ALIGNED_DI_OP
891 #define TARGET_ASM_ALIGNED_DI_OP "\t.quad\t"
892 #endif
893 #endif
894
895 /* This hook deals with fixups for relocatable code and DI-mode objects
896    in 64-bit code.  */
897 #undef TARGET_ASM_INTEGER
898 #define TARGET_ASM_INTEGER rs6000_assemble_integer
899
900 #ifdef HAVE_GAS_HIDDEN
901 #undef TARGET_ASM_ASSEMBLE_VISIBILITY
902 #define TARGET_ASM_ASSEMBLE_VISIBILITY rs6000_assemble_visibility
903 #endif
904
905 #undef TARGET_HAVE_TLS
906 #define TARGET_HAVE_TLS HAVE_AS_TLS
907
908 #undef TARGET_CANNOT_FORCE_CONST_MEM
909 #define TARGET_CANNOT_FORCE_CONST_MEM rs6000_tls_referenced_p
910
911 #undef TARGET_ASM_FUNCTION_PROLOGUE
912 #define TARGET_ASM_FUNCTION_PROLOGUE rs6000_output_function_prologue
913 #undef TARGET_ASM_FUNCTION_EPILOGUE
914 #define TARGET_ASM_FUNCTION_EPILOGUE rs6000_output_function_epilogue
915
916 #undef  TARGET_SCHED_VARIABLE_ISSUE
917 #define TARGET_SCHED_VARIABLE_ISSUE rs6000_variable_issue
918
919 #undef TARGET_SCHED_ISSUE_RATE
920 #define TARGET_SCHED_ISSUE_RATE rs6000_issue_rate
921 #undef TARGET_SCHED_ADJUST_COST
922 #define TARGET_SCHED_ADJUST_COST rs6000_adjust_cost
923 #undef TARGET_SCHED_ADJUST_PRIORITY
924 #define TARGET_SCHED_ADJUST_PRIORITY rs6000_adjust_priority
925 #undef TARGET_SCHED_IS_COSTLY_DEPENDENCE
926 #define TARGET_SCHED_IS_COSTLY_DEPENDENCE rs6000_is_costly_dependence
927 #undef TARGET_SCHED_FINISH
928 #define TARGET_SCHED_FINISH rs6000_sched_finish
929
930 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
931 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD rs6000_use_sched_lookahead
932
933 #undef TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD
934 #define TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD rs6000_builtin_mask_for_load
935
936 #undef TARGET_INIT_BUILTINS
937 #define TARGET_INIT_BUILTINS rs6000_init_builtins
938
939 #undef TARGET_EXPAND_BUILTIN
940 #define TARGET_EXPAND_BUILTIN rs6000_expand_builtin
941
942 #undef TARGET_MANGLE_FUNDAMENTAL_TYPE
943 #define TARGET_MANGLE_FUNDAMENTAL_TYPE rs6000_mangle_fundamental_type
944
945 #undef TARGET_INIT_LIBFUNCS
946 #define TARGET_INIT_LIBFUNCS rs6000_init_libfuncs
947
948 #if TARGET_MACHO
949 #undef TARGET_BINDS_LOCAL_P
950 #define TARGET_BINDS_LOCAL_P rs6000_binds_local_p
951 #endif
952
953 #undef TARGET_ASM_OUTPUT_MI_THUNK
954 #define TARGET_ASM_OUTPUT_MI_THUNK rs6000_output_mi_thunk
955
956 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
957 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK hook_bool_tree_hwi_hwi_tree_true
958
959 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
960 #define TARGET_FUNCTION_OK_FOR_SIBCALL rs6000_function_ok_for_sibcall
961
962 #undef TARGET_RTX_COSTS
963 #define TARGET_RTX_COSTS rs6000_rtx_costs
964 #undef TARGET_ADDRESS_COST
965 #define TARGET_ADDRESS_COST hook_int_rtx_0
966
967 #undef TARGET_VECTOR_OPAQUE_P
968 #define TARGET_VECTOR_OPAQUE_P is_ev64_opaque_type
969
970 #undef TARGET_DWARF_REGISTER_SPAN
971 #define TARGET_DWARF_REGISTER_SPAN rs6000_dwarf_register_span
972
973 /* On rs6000, function arguments are promoted, as are function return
974    values.  */
975 #undef TARGET_PROMOTE_FUNCTION_ARGS
976 #define TARGET_PROMOTE_FUNCTION_ARGS hook_bool_tree_true
977 #undef TARGET_PROMOTE_FUNCTION_RETURN
978 #define TARGET_PROMOTE_FUNCTION_RETURN hook_bool_tree_true
979
980 #undef TARGET_RETURN_IN_MEMORY
981 #define TARGET_RETURN_IN_MEMORY rs6000_return_in_memory
982
983 #undef TARGET_SETUP_INCOMING_VARARGS
984 #define TARGET_SETUP_INCOMING_VARARGS setup_incoming_varargs
985
986 /* Always strict argument naming on rs6000.  */
987 #undef TARGET_STRICT_ARGUMENT_NAMING
988 #define TARGET_STRICT_ARGUMENT_NAMING hook_bool_CUMULATIVE_ARGS_true
989 #undef TARGET_PRETEND_OUTGOING_VARARGS_NAMED
990 #define TARGET_PRETEND_OUTGOING_VARARGS_NAMED hook_bool_CUMULATIVE_ARGS_true
991 #undef TARGET_SPLIT_COMPLEX_ARG
992 #define TARGET_SPLIT_COMPLEX_ARG hook_bool_tree_true
993 #undef TARGET_MUST_PASS_IN_STACK
994 #define TARGET_MUST_PASS_IN_STACK rs6000_must_pass_in_stack
995 #undef TARGET_PASS_BY_REFERENCE
996 #define TARGET_PASS_BY_REFERENCE rs6000_pass_by_reference
997 #undef TARGET_ARG_PARTIAL_BYTES
998 #define TARGET_ARG_PARTIAL_BYTES rs6000_arg_partial_bytes
999
1000 #undef TARGET_BUILD_BUILTIN_VA_LIST
1001 #define TARGET_BUILD_BUILTIN_VA_LIST rs6000_build_builtin_va_list
1002
1003 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
1004 #define TARGET_GIMPLIFY_VA_ARG_EXPR rs6000_gimplify_va_arg
1005
1006 #undef TARGET_EH_RETURN_FILTER_MODE
1007 #define TARGET_EH_RETURN_FILTER_MODE rs6000_eh_return_filter_mode
1008
1009 #undef TARGET_VECTOR_MODE_SUPPORTED_P
1010 #define TARGET_VECTOR_MODE_SUPPORTED_P rs6000_vector_mode_supported_p
1011
1012 /* MPC604EUM 3.5.2 Weak Consistency between Multiple Processors
1013    The PowerPC architecture requires only weak consistency among
1014    processors--that is, memory accesses between processors need not be
1015    sequentially consistent and memory accesses among processors can occur
1016    in any order. The ability to order memory accesses weakly provides
1017    opportunities for more efficient use of the system bus. Unless a
1018    dependency exists, the 604e allows read operations to precede store
1019    operations.  */
1020 #undef TARGET_RELAXED_ORDERING
1021 #define TARGET_RELAXED_ORDERING true
1022
1023 struct gcc_target targetm = TARGET_INITIALIZER;
1024 \f
1025
1026 /* Value is 1 if hard register REGNO can hold a value of machine-mode
1027    MODE.  */
1028 static int
1029 rs6000_hard_regno_mode_ok (int regno, enum machine_mode mode)
1030 {
1031   /* The GPRs can hold any mode, but values bigger than one register
1032      cannot go past R31.  */
1033   if (INT_REGNO_P (regno))
1034     return INT_REGNO_P (regno + HARD_REGNO_NREGS (regno, mode) - 1);
1035
1036   /* The float registers can only hold floating modes and DImode.  */
1037   if (FP_REGNO_P (regno))
1038     return
1039       (GET_MODE_CLASS (mode) == MODE_FLOAT
1040        && FP_REGNO_P (regno + HARD_REGNO_NREGS (regno, mode) - 1))
1041       || (GET_MODE_CLASS (mode) == MODE_INT
1042           && GET_MODE_SIZE (mode) == UNITS_PER_FP_WORD);
1043
1044   /* The CR register can only hold CC modes.  */
1045   if (CR_REGNO_P (regno))
1046     return GET_MODE_CLASS (mode) == MODE_CC;
1047
1048   if (XER_REGNO_P (regno))
1049     return mode == PSImode;
1050
1051   /* AltiVec only in AldyVec registers.  */
1052   if (ALTIVEC_REGNO_P (regno))
1053     return ALTIVEC_VECTOR_MODE (mode);
1054
1055   /* ...but GPRs can hold SIMD data on the SPE in one register.  */
1056   if (SPE_SIMD_REGNO_P (regno) && TARGET_SPE && SPE_VECTOR_MODE (mode))
1057     return 1;
1058
1059   /* We cannot put TImode anywhere except general register and it must be
1060      able to fit within the register set.  */
1061
1062   return GET_MODE_SIZE (mode) <= UNITS_PER_WORD;
1063 }
1064
1065 /* Initialize rs6000_hard_regno_mode_ok_p table.  */
1066 static void
1067 rs6000_init_hard_regno_mode_ok (void)
1068 {
1069   int r, m;
1070
1071   for (r = 0; r < FIRST_PSEUDO_REGISTER; ++r)
1072     for (m = 0; m < NUM_MACHINE_MODES; ++m)
1073       if (rs6000_hard_regno_mode_ok (r, m))
1074         rs6000_hard_regno_mode_ok_p[m][r] = true;
1075 }
1076
1077 /* If not otherwise specified by a target, make 'long double' equivalent to
1078    'double'.  */
1079
1080 #ifndef RS6000_DEFAULT_LONG_DOUBLE_SIZE
1081 #define RS6000_DEFAULT_LONG_DOUBLE_SIZE 64
1082 #endif
1083
1084 /* Override command line options.  Mostly we process the processor
1085    type and sometimes adjust other TARGET_ options.  */
1086
1087 void
1088 rs6000_override_options (const char *default_cpu)
1089 {
1090   size_t i, j;
1091   struct rs6000_cpu_select *ptr;
1092   int set_masks;
1093
1094   /* Simplifications for entries below.  */
1095
1096   enum {
1097     POWERPC_BASE_MASK = MASK_POWERPC | MASK_NEW_MNEMONICS,
1098     POWERPC_7400_MASK = POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_ALTIVEC
1099   };
1100
1101   /* This table occasionally claims that a processor does not support
1102      a particular feature even though it does, but the feature is slower
1103      than the alternative.  Thus, it shouldn't be relied on as a
1104      complete description of the processor's support.
1105
1106      Please keep this list in order, and don't forget to update the
1107      documentation in invoke.texi when adding a new processor or
1108      flag.  */
1109   static struct ptt
1110     {
1111       const char *const name;           /* Canonical processor name.  */
1112       const enum processor_type processor; /* Processor type enum value.  */
1113       const int target_enable;  /* Target flags to enable.  */
1114     } const processor_target_table[]
1115       = {{"401", PROCESSOR_PPC403, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1116          {"403", PROCESSOR_PPC403,
1117           POWERPC_BASE_MASK | MASK_SOFT_FLOAT | MASK_STRICT_ALIGN},
1118          {"405", PROCESSOR_PPC405, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1119          {"405fp", PROCESSOR_PPC405, POWERPC_BASE_MASK},
1120          {"440", PROCESSOR_PPC440, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1121          {"440fp", PROCESSOR_PPC440, POWERPC_BASE_MASK},
1122          {"505", PROCESSOR_MPCCORE, POWERPC_BASE_MASK},
1123          {"601", PROCESSOR_PPC601,
1124           MASK_POWER | POWERPC_BASE_MASK | MASK_MULTIPLE | MASK_STRING},
1125          {"602", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1126          {"603", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1127          {"603e", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1128          {"604", PROCESSOR_PPC604, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1129          {"604e", PROCESSOR_PPC604e, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1130          {"620", PROCESSOR_PPC620,
1131           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
1132          {"630", PROCESSOR_PPC630,
1133           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
1134          {"740", PROCESSOR_PPC750, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1135          {"7400", PROCESSOR_PPC7400, POWERPC_7400_MASK},
1136          {"7450", PROCESSOR_PPC7450, POWERPC_7400_MASK},
1137          {"750", PROCESSOR_PPC750, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1138          {"801", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1139          {"821", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1140          {"823", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1141          {"8540", PROCESSOR_PPC8540, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1142          /* 8548 has a dummy entry for now.  */
1143          {"8548", PROCESSOR_PPC8540, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1144          {"860", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1145          {"970", PROCESSOR_POWER4,
1146           POWERPC_7400_MASK | MASK_PPC_GPOPT | MASK_MFCRF | MASK_POWERPC64},
1147          {"common", PROCESSOR_COMMON, MASK_NEW_MNEMONICS},
1148          {"ec603e", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1149          {"G3", PROCESSOR_PPC750, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1150          {"G4",  PROCESSOR_PPC7450, POWERPC_7400_MASK},
1151          {"G5", PROCESSOR_POWER4,
1152           POWERPC_7400_MASK | MASK_PPC_GPOPT | MASK_MFCRF | MASK_POWERPC64},
1153          {"power", PROCESSOR_POWER, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
1154          {"power2", PROCESSOR_POWER,
1155           MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING},
1156          {"power3", PROCESSOR_PPC630,
1157           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
1158          {"power4", PROCESSOR_POWER4,
1159           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_MFCRF | MASK_POWERPC64},
1160          {"power5", PROCESSOR_POWER5,
1161           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_MFCRF | MASK_POWERPC64},
1162          {"powerpc", PROCESSOR_POWERPC, POWERPC_BASE_MASK},
1163          {"powerpc64", PROCESSOR_POWERPC64,
1164           POWERPC_BASE_MASK | MASK_POWERPC64},
1165          {"rios", PROCESSOR_RIOS1, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
1166          {"rios1", PROCESSOR_RIOS1, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
1167          {"rios2", PROCESSOR_RIOS2,
1168           MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING},
1169          {"rsc", PROCESSOR_PPC601, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
1170          {"rsc1", PROCESSOR_PPC601, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
1171          {"rs64a", PROCESSOR_RS64A, POWERPC_BASE_MASK | MASK_POWERPC64},
1172       };
1173
1174   const size_t ptt_size = ARRAY_SIZE (processor_target_table);
1175
1176   /* Some OSs don't support saving the high part of 64-bit registers on
1177      context switch.  Other OSs don't support saving Altivec registers.
1178      On those OSs, we don't touch the MASK_POWERPC64 or MASK_ALTIVEC
1179      settings; if the user wants either, the user must explicitly specify
1180      them and we won't interfere with the user's specification.  */
1181
1182   enum {
1183     POWER_MASKS = MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING,
1184     POWERPC_MASKS = (POWERPC_BASE_MASK | MASK_PPC_GPOPT
1185                      | MASK_PPC_GFXOPT | MASK_POWERPC64 | MASK_ALTIVEC
1186                      | MASK_MFCRF)
1187   };
1188
1189   rs6000_init_hard_regno_mode_ok ();
1190
1191   set_masks = POWER_MASKS | POWERPC_MASKS | MASK_SOFT_FLOAT;
1192 #ifdef OS_MISSING_POWERPC64
1193   if (OS_MISSING_POWERPC64)
1194     set_masks &= ~MASK_POWERPC64;
1195 #endif
1196 #ifdef OS_MISSING_ALTIVEC
1197   if (OS_MISSING_ALTIVEC)
1198     set_masks &= ~MASK_ALTIVEC;
1199 #endif
1200
1201   /* Don't override these by the processor default if given explicitly.  */
1202   set_masks &= ~(target_flags_explicit
1203                  & (MASK_MULTIPLE | MASK_STRING | MASK_SOFT_FLOAT));
1204
1205   /* Identify the processor type.  */
1206   rs6000_select[0].string = default_cpu;
1207   rs6000_cpu = TARGET_POWERPC64 ? PROCESSOR_DEFAULT64 : PROCESSOR_DEFAULT;
1208
1209   for (i = 0; i < ARRAY_SIZE (rs6000_select); i++)
1210     {
1211       ptr = &rs6000_select[i];
1212       if (ptr->string != (char *)0 && ptr->string[0] != '\0')
1213         {
1214           for (j = 0; j < ptt_size; j++)
1215             if (! strcmp (ptr->string, processor_target_table[j].name))
1216               {
1217                 if (ptr->set_tune_p)
1218                   rs6000_cpu = processor_target_table[j].processor;
1219
1220                 if (ptr->set_arch_p)
1221                   {
1222                     target_flags &= ~set_masks;
1223                     target_flags |= (processor_target_table[j].target_enable
1224                                      & set_masks);
1225                   }
1226                 break;
1227               }
1228
1229           if (j == ptt_size)
1230             error ("bad value (%s) for %s switch", ptr->string, ptr->name);
1231         }
1232     }
1233
1234   if (TARGET_E500)
1235     rs6000_isel = 1;
1236
1237   /* If we are optimizing big endian systems for space, use the load/store
1238      multiple and string instructions.  */
1239   if (BYTES_BIG_ENDIAN && optimize_size)
1240     target_flags |= ~target_flags_explicit & (MASK_MULTIPLE | MASK_STRING);
1241
1242   /* Don't allow -mmultiple or -mstring on little endian systems
1243      unless the cpu is a 750, because the hardware doesn't support the
1244      instructions used in little endian mode, and causes an alignment
1245      trap.  The 750 does not cause an alignment trap (except when the
1246      target is unaligned).  */
1247
1248   if (!BYTES_BIG_ENDIAN && rs6000_cpu != PROCESSOR_PPC750)
1249     {
1250       if (TARGET_MULTIPLE)
1251         {
1252           target_flags &= ~MASK_MULTIPLE;
1253           if ((target_flags_explicit & MASK_MULTIPLE) != 0)
1254             warning ("-mmultiple is not supported on little endian systems");
1255         }
1256
1257       if (TARGET_STRING)
1258         {
1259           target_flags &= ~MASK_STRING;
1260           if ((target_flags_explicit & MASK_STRING) != 0)
1261             warning ("-mstring is not supported on little endian systems");
1262         }
1263     }
1264
1265   /* Set debug flags */
1266   if (rs6000_debug_name)
1267     {
1268       if (! strcmp (rs6000_debug_name, "all"))
1269         rs6000_debug_stack = rs6000_debug_arg = 1;
1270       else if (! strcmp (rs6000_debug_name, "stack"))
1271         rs6000_debug_stack = 1;
1272       else if (! strcmp (rs6000_debug_name, "arg"))
1273         rs6000_debug_arg = 1;
1274       else
1275         error ("unknown -mdebug-%s switch", rs6000_debug_name);
1276     }
1277
1278   if (rs6000_traceback_name)
1279     {
1280       if (! strncmp (rs6000_traceback_name, "full", 4))
1281         rs6000_traceback = traceback_full;
1282       else if (! strncmp (rs6000_traceback_name, "part", 4))
1283         rs6000_traceback = traceback_part;
1284       else if (! strncmp (rs6000_traceback_name, "no", 2))
1285         rs6000_traceback = traceback_none;
1286       else
1287         error ("unknown -mtraceback arg %qs; expecting %<full%>, %<partial%> or %<none%>",
1288                rs6000_traceback_name);
1289     }
1290
1291   /* Set size of long double */
1292   rs6000_long_double_type_size = RS6000_DEFAULT_LONG_DOUBLE_SIZE;
1293   if (rs6000_long_double_size_string)
1294     {
1295       char *tail;
1296       int size = strtol (rs6000_long_double_size_string, &tail, 10);
1297       if (*tail != '\0' || (size != 64 && size != 128))
1298         error ("Unknown switch -mlong-double-%s",
1299                rs6000_long_double_size_string);
1300       else
1301         rs6000_long_double_type_size = size;
1302     }
1303
1304   /* Set Altivec ABI as default for powerpc64 linux.  */
1305   if (TARGET_ELF && TARGET_64BIT)
1306     {
1307       rs6000_altivec_abi = 1;
1308       rs6000_altivec_vrsave = 1;
1309     }
1310
1311   /* Set the Darwin64 ABI as default for 64-bit Darwin.  */
1312   if (DEFAULT_ABI == ABI_DARWIN && TARGET_64BIT)
1313     {
1314       rs6000_darwin64_abi = 1;
1315       /* Setting to empty string is same as "-mone-byte-bool".  */
1316 #if TARGET_MACHO
1317       darwin_one_byte_bool = "";
1318 #endif
1319     }
1320
1321   /* Handle -mabi= options.  */
1322   rs6000_parse_abi_options ();
1323
1324   /* Handle -malign-XXXXX option.  */
1325   rs6000_parse_alignment_option ();
1326
1327   rs6000_parse_float_gprs_option ();
1328
1329   /* Handle generic -mFOO=YES/NO options.  */
1330   rs6000_parse_yes_no_option ("vrsave", rs6000_altivec_vrsave_string,
1331                               &rs6000_altivec_vrsave);
1332   rs6000_parse_yes_no_option ("isel", rs6000_isel_string,
1333                               &rs6000_isel);
1334   rs6000_parse_yes_no_option ("spe", rs6000_spe_string, &rs6000_spe);
1335
1336   /* Handle -mtls-size option.  */
1337   rs6000_parse_tls_size_option ();
1338
1339 #ifdef SUBTARGET_OVERRIDE_OPTIONS
1340   SUBTARGET_OVERRIDE_OPTIONS;
1341 #endif
1342 #ifdef SUBSUBTARGET_OVERRIDE_OPTIONS
1343   SUBSUBTARGET_OVERRIDE_OPTIONS;
1344 #endif
1345 #ifdef SUB3TARGET_OVERRIDE_OPTIONS
1346   SUB3TARGET_OVERRIDE_OPTIONS;
1347 #endif
1348
1349   if (TARGET_E500)
1350     {
1351       if (TARGET_ALTIVEC)
1352         error ("AltiVec and E500 instructions cannot coexist");
1353
1354       /* The e500 does not have string instructions, and we set
1355          MASK_STRING above when optimizing for size.  */
1356       if ((target_flags & MASK_STRING) != 0)
1357         target_flags = target_flags & ~MASK_STRING;
1358
1359       /* No SPE means 64-bit long doubles, even if an E500.  */
1360       if (rs6000_spe_string != 0
1361           && !strcmp (rs6000_spe_string, "no"))
1362         rs6000_long_double_type_size = 64;
1363     }
1364   else if (rs6000_select[1].string != NULL)
1365     {
1366       /* For the powerpc-eabispe configuration, we set all these by
1367          default, so let's unset them if we manually set another
1368          CPU that is not the E500.  */
1369       if (rs6000_abi_string == 0)
1370         rs6000_spe_abi = 0;
1371       if (rs6000_spe_string == 0)
1372         rs6000_spe = 0;
1373       if (rs6000_float_gprs_string == 0)
1374         rs6000_float_gprs = 0;
1375       if (rs6000_isel_string == 0)
1376         rs6000_isel = 0;
1377       if (rs6000_long_double_size_string == 0)
1378         rs6000_long_double_type_size = RS6000_DEFAULT_LONG_DOUBLE_SIZE;
1379     }
1380
1381   rs6000_always_hint = (rs6000_cpu != PROCESSOR_POWER4
1382                         && rs6000_cpu != PROCESSOR_POWER5);
1383   rs6000_sched_groups = (rs6000_cpu == PROCESSOR_POWER4
1384                          || rs6000_cpu == PROCESSOR_POWER5);
1385
1386   /* Handle -m(no-)longcall option.  This is a bit of a cheap hack,
1387      using TARGET_OPTIONS to handle a toggle switch, but we're out of
1388      bits in target_flags so TARGET_SWITCHES cannot be used.
1389      Assumption here is that rs6000_longcall_switch points into the
1390      text of the complete option, rather than being a copy, so we can
1391      scan back for the presence or absence of the no- modifier.  */
1392   if (rs6000_longcall_switch)
1393     {
1394       const char *base = rs6000_longcall_switch;
1395       while (base[-1] != 'm') base--;
1396
1397       if (*rs6000_longcall_switch != '\0')
1398         error ("invalid option %qs", base);
1399       rs6000_default_long_calls = (base[0] != 'n');
1400     }
1401
1402   /* Handle -m(no-)warn-altivec-long similarly.  */
1403   if (rs6000_warn_altivec_long_switch)
1404     {
1405       const char *base = rs6000_warn_altivec_long_switch;
1406       while (base[-1] != 'm') base--;
1407
1408       if (*rs6000_warn_altivec_long_switch != '\0')
1409         error ("invalid option %qs", base);
1410       rs6000_warn_altivec_long = (base[0] != 'n');
1411     }
1412
1413   /* Handle -mprioritize-restricted-insns option.  */
1414   rs6000_sched_restricted_insns_priority
1415     = (rs6000_sched_groups ? 1 : 0);
1416   if (rs6000_sched_restricted_insns_priority_str)
1417     rs6000_sched_restricted_insns_priority =
1418       atoi (rs6000_sched_restricted_insns_priority_str);
1419
1420   /* Handle -msched-costly-dep option.  */
1421   rs6000_sched_costly_dep
1422     = (rs6000_sched_groups ? store_to_load_dep_costly : no_dep_costly);
1423   if (rs6000_sched_costly_dep_str)
1424     {
1425       if (! strcmp (rs6000_sched_costly_dep_str, "no"))
1426         rs6000_sched_costly_dep = no_dep_costly;
1427       else if (! strcmp (rs6000_sched_costly_dep_str, "all"))
1428         rs6000_sched_costly_dep = all_deps_costly;
1429       else if (! strcmp (rs6000_sched_costly_dep_str, "true_store_to_load"))
1430         rs6000_sched_costly_dep = true_store_to_load_dep_costly;
1431       else if (! strcmp (rs6000_sched_costly_dep_str, "store_to_load"))
1432         rs6000_sched_costly_dep = store_to_load_dep_costly;
1433       else
1434         rs6000_sched_costly_dep = atoi (rs6000_sched_costly_dep_str);
1435     }
1436
1437   /* Handle -minsert-sched-nops option.  */
1438   rs6000_sched_insert_nops
1439     = (rs6000_sched_groups ? sched_finish_regroup_exact : sched_finish_none);
1440   if (rs6000_sched_insert_nops_str)
1441     {
1442       if (! strcmp (rs6000_sched_insert_nops_str, "no"))
1443         rs6000_sched_insert_nops = sched_finish_none;
1444       else if (! strcmp (rs6000_sched_insert_nops_str, "pad"))
1445         rs6000_sched_insert_nops = sched_finish_pad_groups;
1446       else if (! strcmp (rs6000_sched_insert_nops_str, "regroup_exact"))
1447         rs6000_sched_insert_nops = sched_finish_regroup_exact;
1448       else
1449         rs6000_sched_insert_nops = atoi (rs6000_sched_insert_nops_str);
1450     }
1451
1452 #ifdef TARGET_REGNAMES
1453   /* If the user desires alternate register names, copy in the
1454      alternate names now.  */
1455   if (TARGET_REGNAMES)
1456     memcpy (rs6000_reg_names, alt_reg_names, sizeof (rs6000_reg_names));
1457 #endif
1458
1459   /* Set TARGET_AIX_STRUCT_RET last, after the ABI is determined.
1460      If -maix-struct-return or -msvr4-struct-return was explicitly
1461      used, don't override with the ABI default.  */
1462   if ((target_flags_explicit & MASK_AIX_STRUCT_RET) == 0)
1463     {
1464       if (DEFAULT_ABI == ABI_V4 && !DRAFT_V4_STRUCT_RET)
1465         target_flags = (target_flags & ~MASK_AIX_STRUCT_RET);
1466       else
1467         target_flags |= MASK_AIX_STRUCT_RET;
1468     }
1469
1470   if (TARGET_LONG_DOUBLE_128
1471       && (DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_DARWIN))
1472     REAL_MODE_FORMAT (TFmode) = &ibm_extended_format;
1473
1474   /* Allocate an alias set for register saves & restores from stack.  */
1475   rs6000_sr_alias_set = new_alias_set ();
1476
1477   if (TARGET_TOC)
1478     ASM_GENERATE_INTERNAL_LABEL (toc_label_name, "LCTOC", 1);
1479
1480   /* We can only guarantee the availability of DI pseudo-ops when
1481      assembling for 64-bit targets.  */
1482   if (!TARGET_64BIT)
1483     {
1484       targetm.asm_out.aligned_op.di = NULL;
1485       targetm.asm_out.unaligned_op.di = NULL;
1486     }
1487
1488   /* Set branch target alignment, if not optimizing for size.  */
1489   if (!optimize_size)
1490     {
1491       if (rs6000_sched_groups)
1492         {
1493           if (align_functions <= 0)
1494             align_functions = 16;
1495           if (align_jumps <= 0)
1496             align_jumps = 16;
1497           if (align_loops <= 0)
1498             align_loops = 16;
1499         }
1500       if (align_jumps_max_skip <= 0)
1501         align_jumps_max_skip = 15;
1502       if (align_loops_max_skip <= 0)
1503         align_loops_max_skip = 15;
1504     }
1505
1506   /* Arrange to save and restore machine status around nested functions.  */
1507   init_machine_status = rs6000_init_machine_status;
1508
1509   /* We should always be splitting complex arguments, but we can't break
1510      Linux and Darwin ABIs at the moment.  For now, only AIX is fixed.  */
1511   if (DEFAULT_ABI != ABI_AIX)
1512     targetm.calls.split_complex_arg = NULL;
1513
1514   /* Initialize rs6000_cost with the appropriate target costs.  */
1515   if (optimize_size)
1516     rs6000_cost = TARGET_POWERPC64 ? &size64_cost : &size32_cost;
1517   else
1518     switch (rs6000_cpu)
1519       {
1520       case PROCESSOR_RIOS1:
1521         rs6000_cost = &rios1_cost;
1522         break;
1523
1524       case PROCESSOR_RIOS2:
1525         rs6000_cost = &rios2_cost;
1526         break;
1527
1528       case PROCESSOR_RS64A:
1529         rs6000_cost = &rs64a_cost;
1530         break;
1531
1532       case PROCESSOR_MPCCORE:
1533         rs6000_cost = &mpccore_cost;
1534         break;
1535
1536       case PROCESSOR_PPC403:
1537         rs6000_cost = &ppc403_cost;
1538         break;
1539
1540       case PROCESSOR_PPC405:
1541         rs6000_cost = &ppc405_cost;
1542         break;
1543
1544       case PROCESSOR_PPC440:
1545         rs6000_cost = &ppc440_cost;
1546         break;
1547
1548       case PROCESSOR_PPC601:
1549         rs6000_cost = &ppc601_cost;
1550         break;
1551
1552       case PROCESSOR_PPC603:
1553         rs6000_cost = &ppc603_cost;
1554         break;
1555
1556       case PROCESSOR_PPC604:
1557         rs6000_cost = &ppc604_cost;
1558         break;
1559
1560       case PROCESSOR_PPC604e:
1561         rs6000_cost = &ppc604e_cost;
1562         break;
1563
1564       case PROCESSOR_PPC620:
1565         rs6000_cost = &ppc620_cost;
1566         break;
1567
1568       case PROCESSOR_PPC630:
1569         rs6000_cost = &ppc630_cost;
1570         break;
1571
1572       case PROCESSOR_PPC750:
1573       case PROCESSOR_PPC7400:
1574         rs6000_cost = &ppc750_cost;
1575         break;
1576
1577       case PROCESSOR_PPC7450:
1578         rs6000_cost = &ppc7450_cost;
1579         break;
1580
1581       case PROCESSOR_PPC8540:
1582         rs6000_cost = &ppc8540_cost;
1583         break;
1584
1585       case PROCESSOR_POWER4:
1586       case PROCESSOR_POWER5:
1587         rs6000_cost = &power4_cost;
1588         break;
1589
1590       default:
1591         abort ();
1592       }
1593 }
1594
1595 /* Implement targetm.vectorize.builtin_mask_for_load.  */
1596 static tree
1597 rs6000_builtin_mask_for_load (void)
1598 {
1599   if (TARGET_ALTIVEC)
1600     return altivec_builtin_mask_for_load;
1601   else
1602     return 0;
1603 }
1604
1605 /* Handle generic options of the form -mfoo=yes/no.
1606    NAME is the option name.
1607    VALUE is the option value.
1608    FLAG is the pointer to the flag where to store a 1 or 0, depending on
1609    whether the option value is 'yes' or 'no' respectively.  */
1610 static void
1611 rs6000_parse_yes_no_option (const char *name, const char *value, int *flag)
1612 {
1613   if (value == 0)
1614     return;
1615   else if (!strcmp (value, "yes"))
1616     *flag = 1;
1617   else if (!strcmp (value, "no"))
1618     *flag = 0;
1619   else
1620     error ("unknown -m%s= option specified: '%s'", name, value);
1621 }
1622
1623 /* Handle -mabi= options.  */
1624 static void
1625 rs6000_parse_abi_options (void)
1626 {
1627   if (rs6000_abi_string == 0)
1628     return;
1629   else if (! strcmp (rs6000_abi_string, "altivec"))
1630     {
1631       rs6000_altivec_abi = 1;
1632       rs6000_spe_abi = 0;
1633     }
1634   else if (! strcmp (rs6000_abi_string, "no-altivec"))
1635     rs6000_altivec_abi = 0;
1636   else if (! strcmp (rs6000_abi_string, "spe"))
1637     {
1638       rs6000_spe_abi = 1;
1639       rs6000_altivec_abi = 0;
1640       if (!TARGET_SPE_ABI)
1641         error ("not configured for ABI: '%s'", rs6000_abi_string);
1642     }
1643
1644   /* These are here for testing during development only, do not
1645      document in the manual please.  */
1646   else if (! strcmp (rs6000_abi_string, "d64"))
1647     {
1648       rs6000_darwin64_abi = 1;
1649       warning ("Using darwin64 ABI");
1650     }
1651   else if (! strcmp (rs6000_abi_string, "d32"))
1652     {
1653       rs6000_darwin64_abi = 0;
1654       warning ("Using old darwin ABI");
1655     }
1656
1657   else if (! strcmp (rs6000_abi_string, "no-spe"))
1658     rs6000_spe_abi = 0;
1659   else
1660     error ("unknown ABI specified: '%s'", rs6000_abi_string);
1661 }
1662
1663 /* Handle -mfloat-gprs= options.  */
1664 static void
1665 rs6000_parse_float_gprs_option (void)
1666 {
1667   if (rs6000_float_gprs_string == 0)
1668     return;
1669   else if (! strcmp (rs6000_float_gprs_string, "yes")
1670            || ! strcmp (rs6000_float_gprs_string, "single"))
1671     rs6000_float_gprs = 1;
1672   else if (! strcmp (rs6000_float_gprs_string, "double"))
1673     rs6000_float_gprs = 2;
1674   else if (! strcmp (rs6000_float_gprs_string, "no"))
1675     rs6000_float_gprs = 0;
1676   else
1677     error ("invalid option for -mfloat-gprs");
1678 }
1679
1680 /* Handle -malign-XXXXXX options.  */
1681 static void
1682 rs6000_parse_alignment_option (void)
1683 {
1684   if (rs6000_alignment_string == 0)
1685     return;
1686   else if (! strcmp (rs6000_alignment_string, "power"))
1687     rs6000_alignment_flags = MASK_ALIGN_POWER;
1688   else if (! strcmp (rs6000_alignment_string, "natural"))
1689     rs6000_alignment_flags = MASK_ALIGN_NATURAL;
1690   else
1691     error ("unknown -malign-XXXXX option specified: '%s'",
1692            rs6000_alignment_string);
1693 }
1694
1695 /* Validate and record the size specified with the -mtls-size option.  */
1696
1697 static void
1698 rs6000_parse_tls_size_option (void)
1699 {
1700   if (rs6000_tls_size_string == 0)
1701     return;
1702   else if (strcmp (rs6000_tls_size_string, "16") == 0)
1703     rs6000_tls_size = 16;
1704   else if (strcmp (rs6000_tls_size_string, "32") == 0)
1705     rs6000_tls_size = 32;
1706   else if (strcmp (rs6000_tls_size_string, "64") == 0)
1707     rs6000_tls_size = 64;
1708   else
1709     error ("bad value %qs for -mtls-size switch", rs6000_tls_size_string);
1710 }
1711
1712 void
1713 optimization_options (int level ATTRIBUTE_UNUSED, int size ATTRIBUTE_UNUSED)
1714 {
1715 }
1716 \f
1717 /* Do anything needed at the start of the asm file.  */
1718
1719 static void
1720 rs6000_file_start (void)
1721 {
1722   size_t i;
1723   char buffer[80];
1724   const char *start = buffer;
1725   struct rs6000_cpu_select *ptr;
1726   const char *default_cpu = TARGET_CPU_DEFAULT;
1727   FILE *file = asm_out_file;
1728
1729   default_file_start ();
1730
1731 #ifdef TARGET_BI_ARCH
1732   if ((TARGET_DEFAULT ^ target_flags) & MASK_64BIT)
1733     default_cpu = 0;
1734 #endif
1735
1736   if (flag_verbose_asm)
1737     {
1738       sprintf (buffer, "\n%s rs6000/powerpc options:", ASM_COMMENT_START);
1739       rs6000_select[0].string = default_cpu;
1740
1741       for (i = 0; i < ARRAY_SIZE (rs6000_select); i++)
1742         {
1743           ptr = &rs6000_select[i];
1744           if (ptr->string != (char *)0 && ptr->string[0] != '\0')
1745             {
1746               fprintf (file, "%s %s%s", start, ptr->name, ptr->string);
1747               start = "";
1748             }
1749         }
1750
1751 #ifdef USING_ELFOS_H
1752       switch (rs6000_sdata)
1753         {
1754         case SDATA_NONE: fprintf (file, "%s -msdata=none", start); start = ""; break;
1755         case SDATA_DATA: fprintf (file, "%s -msdata=data", start); start = ""; break;
1756         case SDATA_SYSV: fprintf (file, "%s -msdata=sysv", start); start = ""; break;
1757         case SDATA_EABI: fprintf (file, "%s -msdata=eabi", start); start = ""; break;
1758         }
1759
1760       if (rs6000_sdata && g_switch_value)
1761         {
1762           fprintf (file, "%s -G " HOST_WIDE_INT_PRINT_UNSIGNED, start,
1763                    g_switch_value);
1764           start = "";
1765         }
1766 #endif
1767
1768       if (*start == '\0')
1769         putc ('\n', file);
1770     }
1771 }
1772
1773 \f
1774 /* Return nonzero if this function is known to have a null epilogue.  */
1775
1776 int
1777 direct_return (void)
1778 {
1779   if (reload_completed)
1780     {
1781       rs6000_stack_t *info = rs6000_stack_info ();
1782
1783       if (info->first_gp_reg_save == 32
1784           && info->first_fp_reg_save == 64
1785           && info->first_altivec_reg_save == LAST_ALTIVEC_REGNO + 1
1786           && ! info->lr_save_p
1787           && ! info->cr_save_p
1788           && info->vrsave_mask == 0
1789           && ! info->push_p)
1790         return 1;
1791     }
1792
1793   return 0;
1794 }
1795
1796 /* Returns 1 always.  */
1797
1798 int
1799 any_operand (rtx op ATTRIBUTE_UNUSED,
1800              enum machine_mode mode ATTRIBUTE_UNUSED)
1801 {
1802   return 1;
1803 }
1804
1805 /* Returns 1 always.  */
1806
1807 int
1808 any_parallel_operand (rtx op ATTRIBUTE_UNUSED,
1809                       enum machine_mode mode ATTRIBUTE_UNUSED)
1810 {
1811   return 1;
1812 }
1813
1814 /* Returns 1 if op is the count register.  */
1815
1816 int
1817 count_register_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1818 {
1819   if (GET_CODE (op) != REG)
1820     return 0;
1821
1822   if (REGNO (op) == COUNT_REGISTER_REGNUM)
1823     return 1;
1824
1825   if (REGNO (op) > FIRST_PSEUDO_REGISTER)
1826     return 1;
1827
1828   return 0;
1829 }
1830
1831 /* Returns 1 if op is an altivec register.  */
1832
1833 int
1834 altivec_register_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1835 {
1836   return (register_operand (op, mode)
1837           && (GET_CODE (op) != REG
1838               || REGNO (op) > FIRST_PSEUDO_REGISTER
1839               || ALTIVEC_REGNO_P (REGNO (op))));
1840 }
1841
1842 int
1843 xer_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1844 {
1845   if (GET_CODE (op) != REG)
1846     return 0;
1847
1848   if (XER_REGNO_P (REGNO (op)))
1849     return 1;
1850
1851   return 0;
1852 }
1853
1854 /* Return 1 if OP is a signed 8-bit constant.  Int multiplication
1855    by such constants completes more quickly.  */
1856
1857 int
1858 s8bit_cint_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1859 {
1860   return (GET_CODE (op) == CONST_INT
1861           && (INTVAL (op) >= -128 && INTVAL (op) <= 127));
1862 }
1863
1864 /* Return 1 if OP is a constant that can fit in a D field.  */
1865
1866 int
1867 short_cint_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1868 {
1869   return (GET_CODE (op) == CONST_INT
1870           && CONST_OK_FOR_LETTER_P (INTVAL (op), 'I'));
1871 }
1872
1873 /* Similar for an unsigned D field.  */
1874
1875 int
1876 u_short_cint_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1877 {
1878   return (GET_CODE (op) == CONST_INT
1879           && CONST_OK_FOR_LETTER_P (INTVAL (op) & GET_MODE_MASK (mode), 'K'));
1880 }
1881
1882 /* Return 1 if OP is a CONST_INT that cannot fit in a signed D field.  */
1883
1884 int
1885 non_short_cint_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1886 {
1887   return (GET_CODE (op) == CONST_INT
1888           && (unsigned HOST_WIDE_INT) (INTVAL (op) + 0x8000) >= 0x10000);
1889 }
1890
1891 /* Returns 1 if OP is a CONST_INT that is a positive value
1892    and an exact power of 2.  */
1893
1894 int
1895 exact_log2_cint_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1896 {
1897   return (GET_CODE (op) == CONST_INT
1898           && INTVAL (op) > 0
1899           && exact_log2 (INTVAL (op)) >= 0);
1900 }
1901
1902 /* Returns 1 if OP is a register that is not special (i.e., not MQ,
1903    ctr, or lr).  */
1904
1905 int
1906 gpc_reg_operand (rtx op, enum machine_mode mode)
1907 {
1908   return (register_operand (op, mode)
1909           && (GET_CODE (op) != REG
1910               || (REGNO (op) >= ARG_POINTER_REGNUM
1911                   && !XER_REGNO_P (REGNO (op)))
1912               || REGNO (op) < MQ_REGNO));
1913 }
1914
1915 /* Returns 1 if OP is either a pseudo-register or a register denoting a
1916    CR field.  */
1917
1918 int
1919 cc_reg_operand (rtx op, enum machine_mode mode)
1920 {
1921   return (register_operand (op, mode)
1922           && (GET_CODE (op) != REG
1923               || REGNO (op) >= FIRST_PSEUDO_REGISTER
1924               || CR_REGNO_P (REGNO (op))));
1925 }
1926
1927 /* Returns 1 if OP is either a pseudo-register or a register denoting a
1928    CR field that isn't CR0.  */
1929
1930 int
1931 cc_reg_not_cr0_operand (rtx op, enum machine_mode mode)
1932 {
1933   return (register_operand (op, mode)
1934           && (GET_CODE (op) != REG
1935               || REGNO (op) >= FIRST_PSEUDO_REGISTER
1936               || CR_REGNO_NOT_CR0_P (REGNO (op))));
1937 }
1938
1939 /* Returns 1 if OP is either a constant integer valid for a D-field or
1940    a non-special register.  If a register, it must be in the proper
1941    mode unless MODE is VOIDmode.  */
1942
1943 int
1944 reg_or_short_operand (rtx op, enum machine_mode mode)
1945 {
1946   return short_cint_operand (op, mode) || gpc_reg_operand (op, mode);
1947 }
1948
1949 /* Similar, except check if the negation of the constant would be
1950    valid for a D-field.  Don't allow a constant zero, since all the
1951    patterns that call this predicate use "addic r1,r2,-constant" on
1952    a constant value to set a carry when r2 is greater or equal to
1953    "constant".  That doesn't work for zero.  */
1954
1955 int
1956 reg_or_neg_short_operand (rtx op, enum machine_mode mode)
1957 {
1958   if (GET_CODE (op) == CONST_INT)
1959     return CONST_OK_FOR_LETTER_P (INTVAL (op), 'P') && INTVAL (op) != 0;
1960
1961   return gpc_reg_operand (op, mode);
1962 }
1963
1964 /* Returns 1 if OP is either a constant integer valid for a DS-field or
1965    a non-special register.  If a register, it must be in the proper
1966    mode unless MODE is VOIDmode.  */
1967
1968 int
1969 reg_or_aligned_short_operand (rtx op, enum machine_mode mode)
1970 {
1971   if (gpc_reg_operand (op, mode))
1972     return 1;
1973   else if (short_cint_operand (op, mode) && !(INTVAL (op) & 3))
1974     return 1;
1975
1976   return 0;
1977 }
1978
1979
1980 /* Return 1 if the operand is either a register or an integer whose
1981    high-order 16 bits are zero.  */
1982
1983 int
1984 reg_or_u_short_operand (rtx op, enum machine_mode mode)
1985 {
1986   return u_short_cint_operand (op, mode) || gpc_reg_operand (op, mode);
1987 }
1988
1989 /* Return 1 is the operand is either a non-special register or ANY
1990    constant integer.  */
1991
1992 int
1993 reg_or_cint_operand (rtx op, enum machine_mode mode)
1994 {
1995   return (GET_CODE (op) == CONST_INT || gpc_reg_operand (op, mode));
1996 }
1997
1998 /* Return 1 is the operand is either a non-special register or ANY
1999    32-bit signed constant integer.  */
2000
2001 int
2002 reg_or_arith_cint_operand (rtx op, enum machine_mode mode)
2003 {
2004   return (gpc_reg_operand (op, mode)
2005           || (GET_CODE (op) == CONST_INT
2006 #if HOST_BITS_PER_WIDE_INT != 32
2007               && ((unsigned HOST_WIDE_INT) (INTVAL (op) + 0x80000000)
2008                   < (unsigned HOST_WIDE_INT) 0x100000000ll)
2009 #endif
2010               ));
2011 }
2012
2013 /* Return 1 is the operand is either a non-special register or a 32-bit
2014    signed constant integer valid for 64-bit addition.  */
2015
2016 int
2017 reg_or_add_cint64_operand (rtx op, enum machine_mode mode)
2018 {
2019   return (gpc_reg_operand (op, mode)
2020           || (GET_CODE (op) == CONST_INT
2021 #if HOST_BITS_PER_WIDE_INT == 32
2022               && INTVAL (op) < 0x7fff8000
2023 #else
2024               && ((unsigned HOST_WIDE_INT) (INTVAL (op) + 0x80008000)
2025                   < 0x100000000ll)
2026 #endif
2027               ));
2028 }
2029
2030 /* Return 1 is the operand is either a non-special register or a 32-bit
2031    signed constant integer valid for 64-bit subtraction.  */
2032
2033 int
2034 reg_or_sub_cint64_operand (rtx op, enum machine_mode mode)
2035 {
2036   return (gpc_reg_operand (op, mode)
2037           || (GET_CODE (op) == CONST_INT
2038 #if HOST_BITS_PER_WIDE_INT == 32
2039               && (- INTVAL (op)) < 0x7fff8000
2040 #else
2041               && ((unsigned HOST_WIDE_INT) ((- INTVAL (op)) + 0x80008000)
2042                   < 0x100000000ll)
2043 #endif
2044               ));
2045 }
2046
2047 /* Return 1 is the operand is either a non-special register or ANY
2048    32-bit unsigned constant integer.  */
2049
2050 int
2051 reg_or_logical_cint_operand (rtx op, enum machine_mode mode)
2052 {
2053   if (GET_CODE (op) == CONST_INT)
2054     {
2055       if (GET_MODE_BITSIZE (mode) > HOST_BITS_PER_WIDE_INT)
2056         {
2057           if (GET_MODE_BITSIZE (mode) <= 32)
2058             abort ();
2059
2060           if (INTVAL (op) < 0)
2061             return 0;
2062         }
2063
2064       return ((INTVAL (op) & GET_MODE_MASK (mode)
2065                & (~ (unsigned HOST_WIDE_INT) 0xffffffff)) == 0);
2066     }
2067   else if (GET_CODE (op) == CONST_DOUBLE)
2068     {
2069       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
2070           || mode != DImode)
2071         abort ();
2072
2073       return CONST_DOUBLE_HIGH (op) == 0;
2074     }
2075   else
2076     return gpc_reg_operand (op, mode);
2077 }
2078
2079 /* Return 1 if the operand is an operand that can be loaded via the GOT.  */
2080
2081 int
2082 got_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2083 {
2084   return (GET_CODE (op) == SYMBOL_REF
2085           || GET_CODE (op) == CONST
2086           || GET_CODE (op) == LABEL_REF);
2087 }
2088
2089 /* Return 1 if the operand is a simple references that can be loaded via
2090    the GOT (labels involving addition aren't allowed).  */
2091
2092 int
2093 got_no_const_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2094 {
2095   return (GET_CODE (op) == SYMBOL_REF || GET_CODE (op) == LABEL_REF);
2096 }
2097
2098 /* Return the number of instructions it takes to form a constant in an
2099    integer register.  */
2100
2101 static int
2102 num_insns_constant_wide (HOST_WIDE_INT value)
2103 {
2104   /* signed constant loadable with {cal|addi} */
2105   if (CONST_OK_FOR_LETTER_P (value, 'I'))
2106     return 1;
2107
2108   /* constant loadable with {cau|addis} */
2109   else if (CONST_OK_FOR_LETTER_P (value, 'L'))
2110     return 1;
2111
2112 #if HOST_BITS_PER_WIDE_INT == 64
2113   else if (TARGET_POWERPC64)
2114     {
2115       HOST_WIDE_INT low  = ((value & 0xffffffff) ^ 0x80000000) - 0x80000000;
2116       HOST_WIDE_INT high = value >> 31;
2117
2118       if (high == 0 || high == -1)
2119         return 2;
2120
2121       high >>= 1;
2122
2123       if (low == 0)
2124         return num_insns_constant_wide (high) + 1;
2125       else
2126         return (num_insns_constant_wide (high)
2127                 + num_insns_constant_wide (low) + 1);
2128     }
2129 #endif
2130
2131   else
2132     return 2;
2133 }
2134
2135 int
2136 num_insns_constant (rtx op, enum machine_mode mode)
2137 {
2138   if (GET_CODE (op) == CONST_INT)
2139     {
2140 #if HOST_BITS_PER_WIDE_INT == 64
2141       if ((INTVAL (op) >> 31) != 0 && (INTVAL (op) >> 31) != -1
2142           && mask64_operand (op, mode))
2143         return 2;
2144       else
2145 #endif
2146         return num_insns_constant_wide (INTVAL (op));
2147     }
2148
2149   else if (GET_CODE (op) == CONST_DOUBLE && mode == SFmode)
2150     {
2151       long l;
2152       REAL_VALUE_TYPE rv;
2153
2154       REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
2155       REAL_VALUE_TO_TARGET_SINGLE (rv, l);
2156       return num_insns_constant_wide ((HOST_WIDE_INT) l);
2157     }
2158
2159   else if (GET_CODE (op) == CONST_DOUBLE)
2160     {
2161       HOST_WIDE_INT low;
2162       HOST_WIDE_INT high;
2163       long l[2];
2164       REAL_VALUE_TYPE rv;
2165       int endian = (WORDS_BIG_ENDIAN == 0);
2166
2167       if (mode == VOIDmode || mode == DImode)
2168         {
2169           high = CONST_DOUBLE_HIGH (op);
2170           low  = CONST_DOUBLE_LOW (op);
2171         }
2172       else
2173         {
2174           REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
2175           REAL_VALUE_TO_TARGET_DOUBLE (rv, l);
2176           high = l[endian];
2177           low  = l[1 - endian];
2178         }
2179
2180       if (TARGET_32BIT)
2181         return (num_insns_constant_wide (low)
2182                 + num_insns_constant_wide (high));
2183
2184       else
2185         {
2186           if (high == 0 && low >= 0)
2187             return num_insns_constant_wide (low);
2188
2189           else if (high == -1 && low < 0)
2190             return num_insns_constant_wide (low);
2191
2192           else if (mask64_operand (op, mode))
2193             return 2;
2194
2195           else if (low == 0)
2196             return num_insns_constant_wide (high) + 1;
2197
2198           else
2199             return (num_insns_constant_wide (high)
2200                     + num_insns_constant_wide (low) + 1);
2201         }
2202     }
2203
2204   else
2205     abort ();
2206 }
2207
2208 /* Return 1 if the operand is a CONST_DOUBLE and it can be put into a
2209    register with one instruction per word.  We only do this if we can
2210    safely read CONST_DOUBLE_{LOW,HIGH}.  */
2211
2212 int
2213 easy_fp_constant (rtx op, enum machine_mode mode)
2214 {
2215   if (GET_CODE (op) != CONST_DOUBLE
2216       || GET_MODE (op) != mode
2217       || (GET_MODE_CLASS (mode) != MODE_FLOAT && mode != DImode))
2218     return 0;
2219
2220   /* Consider all constants with -msoft-float to be easy.  */
2221   if ((TARGET_SOFT_FLOAT || TARGET_E500_SINGLE)
2222       && mode != DImode)
2223     return 1;
2224
2225   /* If we are using V.4 style PIC, consider all constants to be hard.  */
2226   if (flag_pic && DEFAULT_ABI == ABI_V4)
2227     return 0;
2228
2229 #ifdef TARGET_RELOCATABLE
2230   /* Similarly if we are using -mrelocatable, consider all constants
2231      to be hard.  */
2232   if (TARGET_RELOCATABLE)
2233     return 0;
2234 #endif
2235
2236   if (mode == TFmode)
2237     {
2238       long k[4];
2239       REAL_VALUE_TYPE rv;
2240
2241       REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
2242       REAL_VALUE_TO_TARGET_LONG_DOUBLE (rv, k);
2243
2244       return (num_insns_constant_wide ((HOST_WIDE_INT) k[0]) == 1
2245               && num_insns_constant_wide ((HOST_WIDE_INT) k[1]) == 1
2246               && num_insns_constant_wide ((HOST_WIDE_INT) k[2]) == 1
2247               && num_insns_constant_wide ((HOST_WIDE_INT) k[3]) == 1);
2248     }
2249
2250   else if (mode == DFmode)
2251     {
2252       long k[2];
2253       REAL_VALUE_TYPE rv;
2254
2255       if (TARGET_E500_DOUBLE)
2256         return 0;
2257
2258       REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
2259       REAL_VALUE_TO_TARGET_DOUBLE (rv, k);
2260
2261       return (num_insns_constant_wide ((HOST_WIDE_INT) k[0]) == 1
2262               && num_insns_constant_wide ((HOST_WIDE_INT) k[1]) == 1);
2263     }
2264
2265   else if (mode == SFmode)
2266     {
2267       long l;
2268       REAL_VALUE_TYPE rv;
2269
2270       REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
2271       REAL_VALUE_TO_TARGET_SINGLE (rv, l);
2272
2273       return num_insns_constant_wide (l) == 1;
2274     }
2275
2276   else if (mode == DImode)
2277     return ((TARGET_POWERPC64
2278              && GET_CODE (op) == CONST_DOUBLE && CONST_DOUBLE_LOW (op) == 0)
2279             || (num_insns_constant (op, DImode) <= 2));
2280
2281   else if (mode == SImode)
2282     return 1;
2283   else
2284     abort ();
2285 }
2286
2287 /* Returns the constant for the splat instruction, if exists.  */
2288
2289 static int
2290 easy_vector_splat_const (int cst, enum machine_mode mode)
2291 {
2292   switch (mode)
2293     {
2294     case V4SImode:
2295       if (EASY_VECTOR_15 (cst)
2296           || EASY_VECTOR_15_ADD_SELF (cst))
2297         return cst;
2298       if ((cst & 0xffff) != ((cst >> 16) & 0xffff))
2299         break;
2300       cst = cst >> 16;
2301       /* Fall thru */
2302
2303     case V8HImode:
2304       if (EASY_VECTOR_15 (cst)
2305           || EASY_VECTOR_15_ADD_SELF (cst))
2306         return cst;
2307       if ((cst & 0xff) != ((cst >> 8) & 0xff))
2308         break;
2309       cst = cst >> 8;
2310       /* Fall thru */
2311
2312     case V16QImode:
2313       if (EASY_VECTOR_15 (cst)
2314           || EASY_VECTOR_15_ADD_SELF (cst))
2315         return cst;
2316     default:
2317       break;
2318     }
2319   return 0;
2320 }
2321
2322
2323 /* Return nonzero if all elements of a vector have the same value.  */
2324
2325 static int
2326 easy_vector_same (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2327 {
2328   int units, i, cst;
2329
2330   units = CONST_VECTOR_NUNITS (op);
2331
2332   cst = INTVAL (CONST_VECTOR_ELT (op, 0));
2333   for (i = 1; i < units; ++i)
2334     if (INTVAL (CONST_VECTOR_ELT (op, i)) != cst)
2335       break;
2336   if (i == units && easy_vector_splat_const (cst, mode))
2337     return 1;
2338   return 0;
2339 }
2340
2341 /* Return 1 if the operand is a CONST_INT and can be put into a
2342    register without using memory.  */
2343
2344 int
2345 easy_vector_constant (rtx op, enum machine_mode mode)
2346 {
2347   int cst, cst2;
2348
2349   if (GET_CODE (op) != CONST_VECTOR
2350       || (!TARGET_ALTIVEC
2351           && !TARGET_SPE))
2352     return 0;
2353
2354   if (zero_constant (op, mode)
2355       && ((TARGET_ALTIVEC && ALTIVEC_VECTOR_MODE (mode))
2356           || (TARGET_SPE && SPE_VECTOR_MODE (mode))))
2357     return 1;
2358
2359   if (GET_MODE_CLASS (mode) != MODE_VECTOR_INT)
2360     return 0;
2361
2362   if (TARGET_SPE && mode == V1DImode)
2363     return 0;
2364
2365   cst  = INTVAL (CONST_VECTOR_ELT (op, 0));
2366   cst2 = INTVAL (CONST_VECTOR_ELT (op, 1));
2367
2368   /* Limit SPE vectors to 15 bits signed.  These we can generate with:
2369        li r0, CONSTANT1
2370        evmergelo r0, r0, r0
2371        li r0, CONSTANT2
2372
2373      I don't know how efficient it would be to allow bigger constants,
2374      considering we'll have an extra 'ori' for every 'li'.  I doubt 5
2375      instructions is better than a 64-bit memory load, but I don't
2376      have the e500 timing specs.  */
2377   if (TARGET_SPE && mode == V2SImode
2378       && cst  >= -0x7fff && cst <= 0x7fff
2379       && cst2 >= -0x7fff && cst2 <= 0x7fff)
2380     return 1;
2381
2382   if (TARGET_ALTIVEC
2383       && easy_vector_same (op, mode))
2384     {
2385       cst = easy_vector_splat_const (cst, mode);
2386       if (EASY_VECTOR_15_ADD_SELF (cst)
2387           || EASY_VECTOR_15 (cst))
2388         return 1;
2389     }
2390   return 0;
2391 }
2392
2393 /* Same as easy_vector_constant but only for EASY_VECTOR_15_ADD_SELF.  */
2394
2395 int
2396 easy_vector_constant_add_self (rtx op, enum machine_mode mode)
2397 {
2398   int cst;
2399   if (TARGET_ALTIVEC
2400       && GET_CODE (op) == CONST_VECTOR
2401       && easy_vector_same (op, mode))
2402     {
2403       cst = easy_vector_splat_const (INTVAL (CONST_VECTOR_ELT (op, 0)), mode);
2404       if (EASY_VECTOR_15_ADD_SELF (cst))
2405         return 1;
2406     }
2407   return 0;
2408 }
2409
2410 /* Generate easy_vector_constant out of a easy_vector_constant_add_self.  */
2411
2412 rtx
2413 gen_easy_vector_constant_add_self (rtx op)
2414 {
2415   int i, units;
2416   rtvec v;
2417   units = GET_MODE_NUNITS (GET_MODE (op));
2418   v = rtvec_alloc (units);
2419
2420   for (i = 0; i < units; i++)
2421     RTVEC_ELT (v, i) =
2422       GEN_INT (INTVAL (CONST_VECTOR_ELT (op, i)) >> 1);
2423   return gen_rtx_raw_CONST_VECTOR (GET_MODE (op), v);
2424 }
2425
2426 const char *
2427 output_vec_const_move (rtx *operands)
2428 {
2429   int cst, cst2;
2430   enum machine_mode mode;
2431   rtx dest, vec;
2432
2433   dest = operands[0];
2434   vec = operands[1];
2435
2436   cst = INTVAL (CONST_VECTOR_ELT (vec, 0));
2437   cst2 = INTVAL (CONST_VECTOR_ELT (vec, 1));
2438   mode = GET_MODE (dest);
2439
2440   if (TARGET_ALTIVEC)
2441     {
2442       if (zero_constant (vec, mode))
2443         return "vxor %0,%0,%0";
2444       else if (easy_vector_constant (vec, mode))
2445         {
2446           operands[1] = GEN_INT (cst);
2447           switch (mode)
2448             {
2449             case V4SImode:
2450               if (EASY_VECTOR_15 (cst))
2451                 {
2452                   operands[1] = GEN_INT (cst);
2453                   return "vspltisw %0,%1";
2454                 }
2455               else if (EASY_VECTOR_15_ADD_SELF (cst))
2456                 return "#";
2457               cst = cst >> 16;
2458               /* Fall thru */
2459
2460             case V8HImode:
2461               if (EASY_VECTOR_15 (cst))
2462                 {
2463                   operands[1] = GEN_INT (cst);
2464                   return "vspltish %0,%1";
2465                 }
2466               else if (EASY_VECTOR_15_ADD_SELF (cst))
2467                 return "#";
2468               cst = cst >> 8;
2469               /* Fall thru */
2470
2471             case V16QImode:
2472               if (EASY_VECTOR_15 (cst))
2473                 {
2474                   operands[1] = GEN_INT (cst);
2475                   return "vspltisb %0,%1";
2476                 }
2477               else if (EASY_VECTOR_15_ADD_SELF (cst))
2478                 return "#";
2479
2480             default:
2481               abort ();
2482             }
2483         }
2484       else
2485         abort ();
2486     }
2487
2488   if (TARGET_SPE)
2489     {
2490       /* Vector constant 0 is handled as a splitter of V2SI, and in the
2491          pattern of V1DI, V4HI, and V2SF.
2492
2493          FIXME: We should probably return # and add post reload
2494          splitters for these, but this way is so easy ;-).  */
2495       operands[1] = GEN_INT (cst);
2496       operands[2] = GEN_INT (cst2);
2497       if (cst == cst2)
2498         return "li %0,%1\n\tevmergelo %0,%0,%0";
2499       else
2500         return "li %0,%1\n\tevmergelo %0,%0,%0\n\tli %0,%2";
2501     }
2502
2503   abort ();
2504 }
2505
2506 /* Return 1 if the operand is the constant 0.  This works for scalars
2507    as well as vectors.  */
2508 int
2509 zero_constant (rtx op, enum machine_mode mode)
2510 {
2511   return op == CONST0_RTX (mode);
2512 }
2513
2514 /* Return 1 if the operand is 0.0.  */
2515 int
2516 zero_fp_constant (rtx op, enum machine_mode mode)
2517 {
2518   return GET_MODE_CLASS (mode) == MODE_FLOAT && op == CONST0_RTX (mode);
2519 }
2520
2521 /* Return 1 if the operand is in volatile memory.  Note that during
2522    the RTL generation phase, memory_operand does not return TRUE for
2523    volatile memory references.  So this function allows us to
2524    recognize volatile references where its safe.  */
2525
2526 int
2527 volatile_mem_operand (rtx op, enum machine_mode mode)
2528 {
2529   if (GET_CODE (op) != MEM)
2530     return 0;
2531
2532   if (!MEM_VOLATILE_P (op))
2533     return 0;
2534
2535   if (mode != GET_MODE (op))
2536     return 0;
2537
2538   if (reload_completed)
2539     return memory_operand (op, mode);
2540
2541   if (reload_in_progress)
2542     return strict_memory_address_p (mode, XEXP (op, 0));
2543
2544   return memory_address_p (mode, XEXP (op, 0));
2545 }
2546
2547 /* Return 1 if the operand is an offsettable memory operand.  */
2548
2549 int
2550 offsettable_mem_operand (rtx op, enum machine_mode mode)
2551 {
2552   return ((GET_CODE (op) == MEM)
2553           && offsettable_address_p (reload_completed || reload_in_progress,
2554                                     mode, XEXP (op, 0)));
2555 }
2556
2557 /* Return 1 if the operand is either an easy FP constant (see above) or
2558    memory.  */
2559
2560 int
2561 mem_or_easy_const_operand (rtx op, enum machine_mode mode)
2562 {
2563   return memory_operand (op, mode) || easy_fp_constant (op, mode);
2564 }
2565
2566 /* Return 1 if the operand is either a non-special register or an item
2567    that can be used as the operand of a `mode' add insn.  */
2568
2569 int
2570 add_operand (rtx op, enum machine_mode mode)
2571 {
2572   if (GET_CODE (op) == CONST_INT)
2573     return (CONST_OK_FOR_LETTER_P (INTVAL (op), 'I')
2574             || CONST_OK_FOR_LETTER_P (INTVAL (op), 'L'));
2575
2576   return gpc_reg_operand (op, mode);
2577 }
2578
2579 /* Return 1 if OP is a constant but not a valid add_operand.  */
2580
2581 int
2582 non_add_cint_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2583 {
2584   return (GET_CODE (op) == CONST_INT
2585           && !CONST_OK_FOR_LETTER_P (INTVAL (op), 'I')
2586           && !CONST_OK_FOR_LETTER_P (INTVAL (op), 'L'));
2587 }
2588
2589 /* Return 1 if the operand is a non-special register or a constant that
2590    can be used as the operand of an OR or XOR insn on the RS/6000.  */
2591
2592 int
2593 logical_operand (rtx op, enum machine_mode mode)
2594 {
2595   HOST_WIDE_INT opl, oph;
2596
2597   if (gpc_reg_operand (op, mode))
2598     return 1;
2599
2600   if (GET_CODE (op) == CONST_INT)
2601     {
2602       opl = INTVAL (op) & GET_MODE_MASK (mode);
2603
2604 #if HOST_BITS_PER_WIDE_INT <= 32
2605       if (GET_MODE_BITSIZE (mode) > HOST_BITS_PER_WIDE_INT && opl < 0)
2606         return 0;
2607 #endif
2608     }
2609   else if (GET_CODE (op) == CONST_DOUBLE)
2610     {
2611       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
2612         abort ();
2613
2614       opl = CONST_DOUBLE_LOW (op);
2615       oph = CONST_DOUBLE_HIGH (op);
2616       if (oph != 0)
2617         return 0;
2618     }
2619   else
2620     return 0;
2621
2622   return ((opl & ~ (unsigned HOST_WIDE_INT) 0xffff) == 0
2623           || (opl & ~ (unsigned HOST_WIDE_INT) 0xffff0000) == 0);
2624 }
2625
2626 /* Return 1 if C is a constant that is not a logical operand (as
2627    above), but could be split into one.  */
2628
2629 int
2630 non_logical_cint_operand (rtx op, enum machine_mode mode)
2631 {
2632   return ((GET_CODE (op) == CONST_INT || GET_CODE (op) == CONST_DOUBLE)
2633           && ! logical_operand (op, mode)
2634           && reg_or_logical_cint_operand (op, mode));
2635 }
2636
2637 /* Return 1 if C is a constant that can be encoded in a 32-bit mask on the
2638    RS/6000.  It is if there are no more than two 1->0 or 0->1 transitions.
2639    Reject all ones and all zeros, since these should have been optimized
2640    away and confuse the making of MB and ME.  */
2641
2642 int
2643 mask_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2644 {
2645   HOST_WIDE_INT c, lsb;
2646
2647   if (GET_CODE (op) != CONST_INT)
2648     return 0;
2649
2650   c = INTVAL (op);
2651
2652   /* Fail in 64-bit mode if the mask wraps around because the upper
2653      32-bits of the mask will all be 1s, contrary to GCC's internal view.  */
2654   if (TARGET_POWERPC64 && (c & 0x80000001) == 0x80000001)
2655     return 0;
2656
2657   /* We don't change the number of transitions by inverting,
2658      so make sure we start with the LS bit zero.  */
2659   if (c & 1)
2660     c = ~c;
2661
2662   /* Reject all zeros or all ones.  */
2663   if (c == 0)
2664     return 0;
2665
2666   /* Find the first transition.  */
2667   lsb = c & -c;
2668
2669   /* Invert to look for a second transition.  */
2670   c = ~c;
2671
2672   /* Erase first transition.  */
2673   c &= -lsb;
2674
2675   /* Find the second transition (if any).  */
2676   lsb = c & -c;
2677
2678   /* Match if all the bits above are 1's (or c is zero).  */
2679   return c == -lsb;
2680 }
2681
2682 /* Return 1 for the PowerPC64 rlwinm corner case.  */
2683
2684 int
2685 mask_operand_wrap (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2686 {
2687   HOST_WIDE_INT c, lsb;
2688
2689   if (GET_CODE (op) != CONST_INT)
2690     return 0;
2691
2692   c = INTVAL (op);
2693
2694   if ((c & 0x80000001) != 0x80000001)
2695     return 0;
2696
2697   c = ~c;
2698   if (c == 0)
2699     return 0;
2700
2701   lsb = c & -c;
2702   c = ~c;
2703   c &= -lsb;
2704   lsb = c & -c;
2705   return c == -lsb;
2706 }
2707
2708 /* Return 1 if the operand is a constant that is a PowerPC64 mask.
2709    It is if there are no more than one 1->0 or 0->1 transitions.
2710    Reject all zeros, since zero should have been optimized away and
2711    confuses the making of MB and ME.  */
2712
2713 int
2714 mask64_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2715 {
2716   if (GET_CODE (op) == CONST_INT)
2717     {
2718       HOST_WIDE_INT c, lsb;
2719
2720       c = INTVAL (op);
2721
2722       /* Reject all zeros.  */
2723       if (c == 0)
2724         return 0;
2725
2726       /* We don't change the number of transitions by inverting,
2727          so make sure we start with the LS bit zero.  */
2728       if (c & 1)
2729         c = ~c;
2730
2731       /* Find the transition, and check that all bits above are 1's.  */
2732       lsb = c & -c;
2733
2734       /* Match if all the bits above are 1's (or c is zero).  */
2735       return c == -lsb;
2736     }
2737   return 0;
2738 }
2739
2740 static int
2741 mask64_1or2_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED,
2742                        bool allow_one)
2743 {
2744   if (GET_CODE (op) == CONST_INT)
2745     {
2746       HOST_WIDE_INT c, lsb;
2747       bool one_ok;
2748       
2749       c = INTVAL (op);
2750
2751       /* Disallow all zeros.  */
2752       if (c == 0)
2753         return 0;
2754
2755       /* We can use a single rlwinm insn if no upper bits of C are set
2756          AND there are zero, one or two transitions in the _whole_ of
2757          C.  */
2758       one_ok = !(c & ~(HOST_WIDE_INT)0xffffffff);
2759       
2760       /* We don't change the number of transitions by inverting,
2761          so make sure we start with the LS bit zero.  */
2762       if (c & 1)
2763         c = ~c;
2764
2765       /* Find the first transition.  */
2766       lsb = c & -c;
2767
2768       /* Invert to look for a second transition.  */
2769       c = ~c;
2770
2771       /* Erase first transition.  */
2772       c &= -lsb;
2773
2774       /* Find the second transition.  */
2775       lsb = c & -c;
2776
2777       /* Invert to look for a third transition.  */
2778       c = ~c;
2779
2780       /* Erase second transition.  */
2781       c &= -lsb;
2782
2783       if (one_ok && !(allow_one || c))
2784         return 0;
2785
2786       /* Find the third transition (if any).  */
2787       lsb = c & -c;
2788
2789       /* Match if all the bits above are 1's (or c is zero).  */
2790       return c == -lsb;
2791     }
2792   return 0;
2793 }
2794
2795 /* Like mask64_operand, but allow up to three transitions.  This
2796    predicate is used by insn patterns that generate two rldicl or
2797    rldicr machine insns.   */
2798 int mask64_2_operand (rtx op, enum machine_mode mode)
2799 {
2800   return mask64_1or2_operand (op, mode, false);
2801 }
2802
2803 /* Generates shifts and masks for a pair of rldicl or rldicr insns to
2804    implement ANDing by the mask IN.  */
2805 void
2806 build_mask64_2_operands (rtx in, rtx *out)
2807 {
2808 #if HOST_BITS_PER_WIDE_INT >= 64
2809   unsigned HOST_WIDE_INT c, lsb, m1, m2;
2810   int shift;
2811
2812   if (GET_CODE (in) != CONST_INT)
2813     abort ();
2814
2815   c = INTVAL (in);
2816   if (c & 1)
2817     {
2818       /* Assume c initially something like 0x00fff000000fffff.  The idea
2819          is to rotate the word so that the middle ^^^^^^ group of zeros
2820          is at the MS end and can be cleared with an rldicl mask.  We then
2821          rotate back and clear off the MS    ^^ group of zeros with a
2822          second rldicl.  */
2823       c = ~c;                   /*   c == 0xff000ffffff00000 */
2824       lsb = c & -c;             /* lsb == 0x0000000000100000 */
2825       m1 = -lsb;                /*  m1 == 0xfffffffffff00000 */
2826       c = ~c;                   /*   c == 0x00fff000000fffff */
2827       c &= -lsb;                /*   c == 0x00fff00000000000 */
2828       lsb = c & -c;             /* lsb == 0x0000100000000000 */
2829       c = ~c;                   /*   c == 0xff000fffffffffff */
2830       c &= -lsb;                /*   c == 0xff00000000000000 */
2831       shift = 0;
2832       while ((lsb >>= 1) != 0)
2833         shift++;                /* shift == 44 on exit from loop */
2834       m1 <<= 64 - shift;        /*  m1 == 0xffffff0000000000 */
2835       m1 = ~m1;                 /*  m1 == 0x000000ffffffffff */
2836       m2 = ~c;                  /*  m2 == 0x00ffffffffffffff */
2837     }
2838   else
2839     {
2840       /* Assume c initially something like 0xff000f0000000000.  The idea
2841          is to rotate the word so that the     ^^^  middle group of zeros
2842          is at the LS end and can be cleared with an rldicr mask.  We then
2843          rotate back and clear off the LS group of ^^^^^^^^^^ zeros with
2844          a second rldicr.  */
2845       lsb = c & -c;             /* lsb == 0x0000010000000000 */
2846       m2 = -lsb;                /*  m2 == 0xffffff0000000000 */
2847       c = ~c;                   /*   c == 0x00fff0ffffffffff */
2848       c &= -lsb;                /*   c == 0x00fff00000000000 */
2849       lsb = c & -c;             /* lsb == 0x0000100000000000 */
2850       c = ~c;                   /*   c == 0xff000fffffffffff */
2851       c &= -lsb;                /*   c == 0xff00000000000000 */
2852       shift = 0;
2853       while ((lsb >>= 1) != 0)
2854         shift++;                /* shift == 44 on exit from loop */
2855       m1 = ~c;                  /*  m1 == 0x00ffffffffffffff */
2856       m1 >>= shift;             /*  m1 == 0x0000000000000fff */
2857       m1 = ~m1;                 /*  m1 == 0xfffffffffffff000 */
2858     }
2859
2860   /* Note that when we only have two 0->1 and 1->0 transitions, one of the
2861      masks will be all 1's.  We are guaranteed more than one transition.  */
2862   out[0] = GEN_INT (64 - shift);
2863   out[1] = GEN_INT (m1);
2864   out[2] = GEN_INT (shift);
2865   out[3] = GEN_INT (m2);
2866 #else
2867   (void)in;
2868   (void)out;
2869   abort ();
2870 #endif
2871 }
2872
2873 /* Return 1 if the operand is either a non-special register or a constant
2874    that can be used as the operand of a PowerPC64 logical AND insn.  */
2875
2876 int
2877 and64_operand (rtx op, enum machine_mode mode)
2878 {
2879   if (fixed_regs[CR0_REGNO])    /* CR0 not available, don't do andi./andis.  */
2880     return (gpc_reg_operand (op, mode) || mask64_operand (op, mode));
2881
2882   return (logical_operand (op, mode) || mask64_operand (op, mode));
2883 }
2884
2885 /* Like the above, but also match constants that can be implemented
2886    with two rldicl or rldicr insns.  */
2887
2888 int
2889 and64_2_operand (rtx op, enum machine_mode mode)
2890 {
2891   if (fixed_regs[CR0_REGNO])    /* CR0 not available, don't do andi./andis.  */
2892     return gpc_reg_operand (op, mode) || mask64_1or2_operand (op, mode, true);
2893
2894   return logical_operand (op, mode) || mask64_1or2_operand (op, mode, true);
2895 }
2896
2897 /* Return 1 if the operand is either a non-special register or a
2898    constant that can be used as the operand of an RS/6000 logical AND insn.  */
2899
2900 int
2901 and_operand (rtx op, enum machine_mode mode)
2902 {
2903   if (fixed_regs[CR0_REGNO])    /* CR0 not available, don't do andi./andis.  */
2904     return (gpc_reg_operand (op, mode) || mask_operand (op, mode));
2905
2906   return (logical_operand (op, mode) || mask_operand (op, mode));
2907 }
2908
2909 /* Return 1 if the operand is a general register or memory operand.  */
2910
2911 int
2912 reg_or_mem_operand (rtx op, enum machine_mode mode)
2913 {
2914   return (gpc_reg_operand (op, mode)
2915           || memory_operand (op, mode)
2916           || macho_lo_sum_memory_operand (op, mode)
2917           || volatile_mem_operand (op, mode));
2918 }
2919
2920 /* Return 1 if the operand is a general register or memory operand without
2921    pre_inc or pre_dec which produces invalid form of PowerPC lwa
2922    instruction.  */
2923
2924 int
2925 lwa_operand (rtx op, enum machine_mode mode)
2926 {
2927   rtx inner = op;
2928
2929   if (reload_completed && GET_CODE (inner) == SUBREG)
2930     inner = SUBREG_REG (inner);
2931
2932   return gpc_reg_operand (inner, mode)
2933     || (memory_operand (inner, mode)
2934         && GET_CODE (XEXP (inner, 0)) != PRE_INC
2935         && GET_CODE (XEXP (inner, 0)) != PRE_DEC
2936         && (GET_CODE (XEXP (inner, 0)) != PLUS
2937             || GET_CODE (XEXP (XEXP (inner, 0), 1)) != CONST_INT
2938             || INTVAL (XEXP (XEXP (inner, 0), 1)) % 4 == 0));
2939 }
2940
2941 /* Return 1 if the operand, used inside a MEM, is a SYMBOL_REF.  */
2942
2943 int
2944 symbol_ref_operand (rtx op, enum machine_mode mode)
2945 {
2946   if (mode != VOIDmode && GET_MODE (op) != mode)
2947     return 0;
2948
2949   return (GET_CODE (op) == SYMBOL_REF
2950           && (DEFAULT_ABI != ABI_AIX || SYMBOL_REF_FUNCTION_P (op)));
2951 }
2952
2953 /* Return 1 if the operand, used inside a MEM, is a valid first argument
2954    to CALL.  This is a SYMBOL_REF, a pseudo-register, LR or CTR.  */
2955
2956 int
2957 call_operand (rtx op, enum machine_mode mode)
2958 {
2959   if (mode != VOIDmode && GET_MODE (op) != mode)
2960     return 0;
2961
2962   return (GET_CODE (op) == SYMBOL_REF
2963           || (GET_CODE (op) == REG
2964               && (REGNO (op) == LINK_REGISTER_REGNUM
2965                   || REGNO (op) == COUNT_REGISTER_REGNUM
2966                   || REGNO (op) >= FIRST_PSEUDO_REGISTER)));
2967 }
2968
2969 /* Return 1 if the operand is a SYMBOL_REF for a function known to be in
2970    this file.  */
2971
2972 int
2973 current_file_function_operand (rtx op,
2974                                enum machine_mode mode ATTRIBUTE_UNUSED)
2975 {
2976   return (GET_CODE (op) == SYMBOL_REF
2977           && (DEFAULT_ABI != ABI_AIX || SYMBOL_REF_FUNCTION_P (op))
2978           && (SYMBOL_REF_LOCAL_P (op)
2979               || (DECL_RTL_SET_P (current_function_decl)
2980                   && op == XEXP (DECL_RTL (current_function_decl), 0))));
2981 }
2982
2983 /* Return 1 if this operand is a valid input for a move insn.  */
2984
2985 int
2986 input_operand (rtx op, enum machine_mode mode)
2987 {
2988   /* Memory is always valid.  */
2989   if (memory_operand (op, mode))
2990     return 1;
2991
2992   /* For floating-point, easy constants are valid.  */
2993   if (GET_MODE_CLASS (mode) == MODE_FLOAT
2994       && CONSTANT_P (op)
2995       && easy_fp_constant (op, mode))
2996     return 1;
2997
2998   /* Allow any integer constant.  */
2999   if (GET_MODE_CLASS (mode) == MODE_INT
3000       && (GET_CODE (op) == CONST_INT
3001           || GET_CODE (op) == CONST_DOUBLE))
3002     return 1;
3003
3004   /* Allow easy vector constants.  */
3005   if (GET_CODE (op) == CONST_VECTOR
3006       && easy_vector_constant (op, mode))
3007     return 1;
3008
3009   /* For floating-point or multi-word mode, the only remaining valid type
3010      is a register.  */
3011   if (GET_MODE_CLASS (mode) == MODE_FLOAT
3012       || GET_MODE_SIZE (mode) > UNITS_PER_WORD)
3013     return register_operand (op, mode);
3014
3015   /* The only cases left are integral modes one word or smaller (we
3016      do not get called for MODE_CC values).  These can be in any
3017      register.  */
3018   if (register_operand (op, mode))
3019     return 1;
3020
3021   /* A SYMBOL_REF referring to the TOC is valid.  */
3022   if (legitimate_constant_pool_address_p (op))
3023     return 1;
3024
3025   /* A constant pool expression (relative to the TOC) is valid */
3026   if (toc_relative_expr_p (op))
3027     return 1;
3028
3029   /* V.4 allows SYMBOL_REFs and CONSTs that are in the small data region
3030      to be valid.  */
3031   if (DEFAULT_ABI == ABI_V4
3032       && (GET_CODE (op) == SYMBOL_REF || GET_CODE (op) == CONST)
3033       && small_data_operand (op, Pmode))
3034     return 1;
3035
3036   return 0;
3037 }
3038
3039 /* Return TRUE if OP is an invalid SUBREG operation on the e500.  */
3040 static bool
3041 invalid_e500_subreg (rtx op, enum machine_mode mode)
3042 {
3043   /* Reject (subreg:SI (reg:DF)).  */
3044   if (GET_CODE (op) == SUBREG
3045       && mode == SImode
3046       && REG_P (SUBREG_REG (op))
3047       && GET_MODE (SUBREG_REG (op)) == DFmode)
3048     return true;
3049
3050   /* Reject (subreg:DF (reg:DI)).  */
3051   if (GET_CODE (op) == SUBREG
3052       && mode == DFmode
3053       && REG_P (SUBREG_REG (op))
3054       && GET_MODE (SUBREG_REG (op)) == DImode)
3055     return true;
3056
3057   return false;
3058 }
3059
3060 /* Just like nonimmediate_operand, but return 0 for invalid SUBREG's
3061    on the e500.  */
3062 int
3063 rs6k_nonimmediate_operand (rtx op, enum machine_mode mode)
3064 {
3065   if (TARGET_E500_DOUBLE
3066       && GET_CODE (op) == SUBREG
3067       && invalid_e500_subreg (op, mode))
3068     return 0;
3069
3070   return nonimmediate_operand (op, mode);
3071 }
3072
3073 /* Darwin, AIX increases natural record alignment to doubleword if the first
3074    field is an FP double while the FP fields remain word aligned.  */
3075
3076 unsigned int
3077 rs6000_special_round_type_align (tree type, int computed, int specified)
3078 {
3079   tree field = TYPE_FIELDS (type);
3080
3081   /* Skip all non field decls */ 
3082   while (field != NULL && TREE_CODE (field) != FIELD_DECL)
3083     field = TREE_CHAIN (field);
3084
3085   if (field == NULL || field == type || DECL_MODE (field) != DFmode)
3086     return MAX (computed, specified);
3087
3088   return MAX (MAX (computed, specified), 64);
3089 }
3090
3091 /* Return 1 for an operand in small memory on V.4/eabi.  */
3092
3093 int
3094 small_data_operand (rtx op ATTRIBUTE_UNUSED,
3095                     enum machine_mode mode ATTRIBUTE_UNUSED)
3096 {
3097 #if TARGET_ELF
3098   rtx sym_ref;
3099
3100   if (rs6000_sdata == SDATA_NONE || rs6000_sdata == SDATA_DATA)
3101     return 0;
3102
3103   if (DEFAULT_ABI != ABI_V4)
3104     return 0;
3105
3106   if (GET_CODE (op) == SYMBOL_REF)
3107     sym_ref = op;
3108
3109   else if (GET_CODE (op) != CONST
3110            || GET_CODE (XEXP (op, 0)) != PLUS
3111            || GET_CODE (XEXP (XEXP (op, 0), 0)) != SYMBOL_REF
3112            || GET_CODE (XEXP (XEXP (op, 0), 1)) != CONST_INT)
3113     return 0;
3114
3115   else
3116     {
3117       rtx sum = XEXP (op, 0);
3118       HOST_WIDE_INT summand;
3119
3120       /* We have to be careful here, because it is the referenced address
3121          that must be 32k from _SDA_BASE_, not just the symbol.  */
3122       summand = INTVAL (XEXP (sum, 1));
3123       if (summand < 0 || (unsigned HOST_WIDE_INT) summand > g_switch_value)
3124        return 0;
3125
3126       sym_ref = XEXP (sum, 0);
3127     }
3128
3129   return SYMBOL_REF_SMALL_P (sym_ref);
3130 #else
3131   return 0;
3132 #endif
3133 }
3134
3135 /* Return true, if operand is a memory operand and has a
3136    displacement divisible by 4.  */
3137
3138 int
3139 word_offset_memref_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
3140 {
3141   rtx addr;
3142   int off = 0;
3143
3144   if (!memory_operand (op, mode))
3145     return 0;
3146
3147   addr = XEXP (op, 0);
3148   if (GET_CODE (addr) == PLUS
3149       && GET_CODE (XEXP (addr, 0)) == REG
3150       && GET_CODE (XEXP (addr, 1)) == CONST_INT)
3151     off = INTVAL (XEXP (addr, 1));
3152
3153   return (off % 4) == 0;
3154 }
3155
3156 /* Return true if either operand is a general purpose register.  */
3157
3158 bool
3159 gpr_or_gpr_p (rtx op0, rtx op1)
3160 {
3161   return ((REG_P (op0) && INT_REGNO_P (REGNO (op0)))
3162           || (REG_P (op1) && INT_REGNO_P (REGNO (op1))));
3163 }
3164
3165 \f
3166 /* Subroutines of rs6000_legitimize_address and rs6000_legitimate_address.  */
3167
3168 static int
3169 constant_pool_expr_1 (rtx op, int *have_sym, int *have_toc)
3170 {
3171   switch (GET_CODE(op))
3172     {
3173     case SYMBOL_REF:
3174       if (RS6000_SYMBOL_REF_TLS_P (op))
3175         return 0;
3176       else if (CONSTANT_POOL_ADDRESS_P (op))
3177         {
3178           if (ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (get_pool_constant (op), Pmode))
3179             {
3180               *have_sym = 1;
3181               return 1;
3182             }
3183           else
3184             return 0;
3185         }
3186       else if (! strcmp (XSTR (op, 0), toc_label_name))
3187         {
3188           *have_toc = 1;
3189           return 1;
3190         }
3191       else
3192         return 0;
3193     case PLUS:
3194     case MINUS:
3195       return (constant_pool_expr_1 (XEXP (op, 0), have_sym, have_toc)
3196               && constant_pool_expr_1 (XEXP (op, 1), have_sym, have_toc));
3197     case CONST:
3198       return constant_pool_expr_1 (XEXP (op, 0), have_sym, have_toc);
3199     case CONST_INT:
3200       return 1;
3201     default:
3202       return 0;
3203     }
3204 }
3205
3206 static bool
3207 constant_pool_expr_p (rtx op)
3208 {
3209   int have_sym = 0;
3210   int have_toc = 0;
3211   return constant_pool_expr_1 (op, &have_sym, &have_toc) && have_sym;
3212 }
3213
3214 static bool
3215 toc_relative_expr_p (rtx op)
3216 {
3217   int have_sym = 0;
3218   int have_toc = 0;
3219   return constant_pool_expr_1 (op, &have_sym, &have_toc) && have_toc;
3220 }
3221
3222 bool
3223 legitimate_constant_pool_address_p (rtx x)
3224 {
3225   return (TARGET_TOC
3226           && GET_CODE (x) == PLUS
3227           && GET_CODE (XEXP (x, 0)) == REG
3228           && (TARGET_MINIMAL_TOC || REGNO (XEXP (x, 0)) == TOC_REGISTER)
3229           && constant_pool_expr_p (XEXP (x, 1)));
3230 }
3231
3232 static bool
3233 legitimate_small_data_p (enum machine_mode mode, rtx x)
3234 {
3235   return (DEFAULT_ABI == ABI_V4
3236           && !flag_pic && !TARGET_TOC
3237           && (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == CONST)
3238           && small_data_operand (x, mode));
3239 }
3240
3241 /* SPE offset addressing is limited to 5-bits worth of double words.  */
3242 #define SPE_CONST_OFFSET_OK(x) (((x) & ~0xf8) == 0)
3243
3244 bool
3245 rs6000_legitimate_offset_address_p (enum machine_mode mode, rtx x, int strict)
3246 {
3247   unsigned HOST_WIDE_INT offset, extra;
3248
3249   if (GET_CODE (x) != PLUS)
3250     return false;
3251   if (GET_CODE (XEXP (x, 0)) != REG)
3252     return false;
3253   if (!INT_REG_OK_FOR_BASE_P (XEXP (x, 0), strict))
3254     return false;
3255   if (legitimate_constant_pool_address_p (x))
3256     return true;
3257   if (GET_CODE (XEXP (x, 1)) != CONST_INT)
3258     return false;
3259
3260   offset = INTVAL (XEXP (x, 1));
3261   extra = 0;
3262   switch (mode)
3263     {
3264     case V16QImode:
3265     case V8HImode:
3266     case V4SFmode:
3267     case V4SImode:
3268       /* AltiVec vector modes.  Only reg+reg addressing is valid here,
3269          which leaves the only valid constant offset of zero, which by
3270          canonicalization rules is also invalid.  */
3271       return false;
3272
3273     case V4HImode:
3274     case V2SImode:
3275     case V1DImode:
3276     case V2SFmode:
3277       /* SPE vector modes.  */
3278       return SPE_CONST_OFFSET_OK (offset);
3279
3280     case DFmode:
3281       if (TARGET_E500_DOUBLE)
3282         return SPE_CONST_OFFSET_OK (offset);
3283
3284     case DImode:
3285       /* On e500v2, we may have:
3286
3287            (subreg:DF (mem:DI (plus (reg) (const_int))) 0).
3288
3289          Which gets addressed with evldd instructions.  */
3290       if (TARGET_E500_DOUBLE)
3291         return SPE_CONST_OFFSET_OK (offset);
3292
3293       if (mode == DFmode || !TARGET_POWERPC64)
3294         extra = 4;
3295       else if (offset & 3)
3296         return false;
3297       break;
3298
3299     case TFmode:
3300     case TImode:
3301       if (mode == TFmode || !TARGET_POWERPC64)
3302         extra = 12;
3303       else if (offset & 3)
3304         return false;
3305       else
3306         extra = 8;
3307       break;
3308
3309     default:
3310       break;
3311     }
3312
3313   offset += 0x8000;
3314   return (offset < 0x10000) && (offset + extra < 0x10000);
3315 }
3316
3317 static bool
3318 legitimate_indexed_address_p (rtx x, int strict)
3319 {
3320   rtx op0, op1;
3321
3322   if (GET_CODE (x) != PLUS)
3323     return false;
3324
3325   op0 = XEXP (x, 0);
3326   op1 = XEXP (x, 1);
3327
3328   if (!REG_P (op0) || !REG_P (op1))
3329     return false;
3330
3331   return ((INT_REG_OK_FOR_BASE_P (op0, strict)
3332            && INT_REG_OK_FOR_INDEX_P (op1, strict))
3333           || (INT_REG_OK_FOR_BASE_P (op1, strict)
3334               && INT_REG_OK_FOR_INDEX_P (op0, strict)));
3335 }
3336
3337 static inline bool
3338 legitimate_indirect_address_p (rtx x, int strict)
3339 {
3340   return GET_CODE (x) == REG && INT_REG_OK_FOR_BASE_P (x, strict);
3341 }
3342
3343 static bool
3344 macho_lo_sum_memory_operand (rtx x, enum machine_mode mode)
3345 {
3346   if (!TARGET_MACHO || !flag_pic
3347       || mode != SImode || GET_CODE(x) != MEM)
3348     return false;
3349   x = XEXP (x, 0);
3350
3351   if (GET_CODE (x) != LO_SUM)
3352     return false;
3353   if (GET_CODE (XEXP (x, 0)) != REG)
3354     return false;
3355   if (!INT_REG_OK_FOR_BASE_P (XEXP (x, 0), 0))
3356     return false;
3357   x = XEXP (x, 1);
3358
3359   return CONSTANT_P (x);
3360 }
3361
3362 static bool
3363 legitimate_lo_sum_address_p (enum machine_mode mode, rtx x, int strict)
3364 {
3365   if (GET_CODE (x) != LO_SUM)
3366     return false;
3367   if (GET_CODE (XEXP (x, 0)) != REG)
3368     return false;
3369   if (!INT_REG_OK_FOR_BASE_P (XEXP (x, 0), strict))
3370     return false;
3371   /* Restrict addressing for DI because of our SUBREG hackery.  */
3372   if (TARGET_E500_DOUBLE && (mode == DFmode || mode == DImode))
3373     return false;
3374   x = XEXP (x, 1);
3375
3376   if (TARGET_ELF || TARGET_MACHO)
3377     {
3378       if (DEFAULT_ABI != ABI_AIX && DEFAULT_ABI != ABI_DARWIN && flag_pic)
3379         return false;
3380       if (TARGET_TOC)
3381         return false;
3382       if (GET_MODE_NUNITS (mode) != 1)
3383         return false;
3384       if (GET_MODE_BITSIZE (mode) > 64
3385           || (GET_MODE_BITSIZE (mode) > 32 && !TARGET_POWERPC64
3386               && !(TARGET_HARD_FLOAT && TARGET_FPRS && mode == DFmode)))
3387         return false;
3388
3389       return CONSTANT_P (x);
3390     }
3391
3392   return false;
3393 }
3394
3395
3396 /* Try machine-dependent ways of modifying an illegitimate address
3397    to be legitimate.  If we find one, return the new, valid address.
3398    This is used from only one place: `memory_address' in explow.c.
3399
3400    OLDX is the address as it was before break_out_memory_refs was
3401    called.  In some cases it is useful to look at this to decide what
3402    needs to be done.
3403
3404    MODE is passed so that this function can use GO_IF_LEGITIMATE_ADDRESS.
3405
3406    It is always safe for this function to do nothing.  It exists to
3407    recognize opportunities to optimize the output.
3408
3409    On RS/6000, first check for the sum of a register with a constant
3410    integer that is out of range.  If so, generate code to add the
3411    constant with the low-order 16 bits masked to the register and force
3412    this result into another register (this can be done with `cau').
3413    Then generate an address of REG+(CONST&0xffff), allowing for the
3414    possibility of bit 16 being a one.
3415
3416    Then check for the sum of a register and something not constant, try to
3417    load the other things into a register and return the sum.  */
3418
3419 rtx
3420 rs6000_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
3421                            enum machine_mode mode)
3422 {
3423   if (GET_CODE (x) == SYMBOL_REF)
3424     {
3425       enum tls_model model = SYMBOL_REF_TLS_MODEL (x);
3426       if (model != 0)
3427         return rs6000_legitimize_tls_address (x, model);
3428     }
3429
3430   if (GET_CODE (x) == PLUS
3431       && GET_CODE (XEXP (x, 0)) == REG
3432       && GET_CODE (XEXP (x, 1)) == CONST_INT
3433       && (unsigned HOST_WIDE_INT) (INTVAL (XEXP (x, 1)) + 0x8000) >= 0x10000)
3434     {
3435       HOST_WIDE_INT high_int, low_int;
3436       rtx sum;
3437       low_int = ((INTVAL (XEXP (x, 1)) & 0xffff) ^ 0x8000) - 0x8000;
3438       high_int = INTVAL (XEXP (x, 1)) - low_int;
3439       sum = force_operand (gen_rtx_PLUS (Pmode, XEXP (x, 0),
3440                                          GEN_INT (high_int)), 0);
3441       return gen_rtx_PLUS (Pmode, sum, GEN_INT (low_int));
3442     }
3443   else if (GET_CODE (x) == PLUS
3444            && GET_CODE (XEXP (x, 0)) == REG
3445            && GET_CODE (XEXP (x, 1)) != CONST_INT
3446            && GET_MODE_NUNITS (mode) == 1
3447            && ((TARGET_HARD_FLOAT && TARGET_FPRS)
3448                || TARGET_POWERPC64
3449                || (((mode != DImode && mode != DFmode) || TARGET_E500_DOUBLE)
3450                    && mode != TFmode))
3451            && (TARGET_POWERPC64 || mode != DImode)
3452            && mode != TImode)
3453     {
3454       return gen_rtx_PLUS (Pmode, XEXP (x, 0),
3455                            force_reg (Pmode, force_operand (XEXP (x, 1), 0)));
3456     }
3457   else if (ALTIVEC_VECTOR_MODE (mode))
3458     {
3459       rtx reg;
3460
3461       /* Make sure both operands are registers.  */
3462       if (GET_CODE (x) == PLUS)
3463         return gen_rtx_PLUS (Pmode, force_reg (Pmode, XEXP (x, 0)),
3464                              force_reg (Pmode, XEXP (x, 1)));
3465
3466       reg = force_reg (Pmode, x);
3467       return reg;
3468     }
3469   else if (SPE_VECTOR_MODE (mode)
3470            || (TARGET_E500_DOUBLE && (mode == DFmode
3471                                       || mode == DImode)))
3472     {
3473       if (mode == DImode)
3474         return NULL_RTX;
3475       /* We accept [reg + reg] and [reg + OFFSET].  */
3476
3477       if (GET_CODE (x) == PLUS)
3478         {
3479           rtx op1 = XEXP (x, 0);
3480           rtx op2 = XEXP (x, 1);
3481
3482           op1 = force_reg (Pmode, op1);
3483
3484           if (GET_CODE (op2) != REG
3485               && (GET_CODE (op2) != CONST_INT
3486                   || !SPE_CONST_OFFSET_OK (INTVAL (op2))))
3487             op2 = force_reg (Pmode, op2);
3488
3489           return gen_rtx_PLUS (Pmode, op1, op2);
3490         }
3491
3492       return force_reg (Pmode, x);
3493     }
3494   else if (TARGET_ELF
3495            && TARGET_32BIT
3496            && TARGET_NO_TOC
3497            && ! flag_pic
3498            && GET_CODE (x) != CONST_INT
3499            && GET_CODE (x) != CONST_DOUBLE
3500            && CONSTANT_P (x)
3501            && GET_MODE_NUNITS (mode) == 1
3502            && (GET_MODE_BITSIZE (mode) <= 32
3503                || ((TARGET_HARD_FLOAT && TARGET_FPRS) && mode == DFmode)))
3504     {
3505       rtx reg = gen_reg_rtx (Pmode);
3506       emit_insn (gen_elf_high (reg, x));
3507       return gen_rtx_LO_SUM (Pmode, reg, x);
3508     }
3509   else if (TARGET_MACHO && TARGET_32BIT && TARGET_NO_TOC