OSDN Git Service

8ca07a242115a0a92c7e46cabe3f7790ee85a9e7
[pf3gnuchains/gcc-fork.git] / gcc / config / rs6000 / rs6000.c
1 /* Subroutines used for code generation on IBM RS/6000.
2    Copyright (C) 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3    2000, 2001, 2002, 2003, 2004, 2005 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 #include "intl.h"
57 #if TARGET_XCOFF
58 #include "xcoffout.h"  /* get declarations of xcoff_*_section_name */
59 #endif
60 #if TARGET_MACHO
61 #include "gstab.h"  /* for N_SLINE */
62 #endif
63
64 #ifndef TARGET_NO_PROTOTYPE
65 #define TARGET_NO_PROTOTYPE 0
66 #endif
67
68 #define min(A,B)        ((A) < (B) ? (A) : (B))
69 #define max(A,B)        ((A) > (B) ? (A) : (B))
70
71 /* Structure used to define the rs6000 stack */
72 typedef struct rs6000_stack {
73   int first_gp_reg_save;        /* first callee saved GP register used */
74   int first_fp_reg_save;        /* first callee saved FP register used */
75   int first_altivec_reg_save;   /* first callee saved AltiVec register used */
76   int lr_save_p;                /* true if the link reg needs to be saved */
77   int cr_save_p;                /* true if the CR reg needs to be saved */
78   unsigned int vrsave_mask;     /* mask of vec registers to save */
79   int toc_save_p;               /* true if the TOC needs to be saved */
80   int push_p;                   /* true if we need to allocate stack space */
81   int calls_p;                  /* true if the function makes any calls */
82   int world_save_p;             /* true if we're saving *everything*:
83                                    r13-r31, cr, f14-f31, vrsave, v20-v31  */
84   enum rs6000_abi abi;          /* which ABI to use */
85   int gp_save_offset;           /* offset to save GP regs from initial SP */
86   int fp_save_offset;           /* offset to save FP regs from initial SP */
87   int altivec_save_offset;      /* offset to save AltiVec regs from initial SP */
88   int lr_save_offset;           /* offset to save LR from initial SP */
89   int cr_save_offset;           /* offset to save CR from initial SP */
90   int vrsave_save_offset;       /* offset to save VRSAVE from initial SP */
91   int spe_gp_save_offset;       /* offset to save spe 64-bit gprs  */
92   int toc_save_offset;          /* offset to save the TOC pointer */
93   int varargs_save_offset;      /* offset to save the varargs registers */
94   int ehrd_offset;              /* offset to EH return data */
95   int reg_size;                 /* register size (4 or 8) */
96   int varargs_size;             /* size to hold V.4 args passed in regs */
97   HOST_WIDE_INT vars_size;      /* variable save area size */
98   int parm_size;                /* outgoing parameter size */
99   int save_size;                /* save area size */
100   int fixed_size;               /* fixed size of stack frame */
101   int gp_size;                  /* size of saved GP registers */
102   int fp_size;                  /* size of saved FP registers */
103   int altivec_size;             /* size of saved AltiVec registers */
104   int cr_size;                  /* size to hold CR if not in save_size */
105   int lr_size;                  /* size to hold LR if not in save_size */
106   int vrsave_size;              /* size to hold VRSAVE if not in save_size */
107   int altivec_padding_size;     /* size of altivec alignment padding if
108                                    not in save_size */
109   int spe_gp_size;              /* size of 64-bit GPR save size for SPE */
110   int spe_padding_size;
111   int toc_size;                 /* size to hold TOC if not in save_size */
112   HOST_WIDE_INT total_size;     /* total bytes allocated for stack */
113   int spe_64bit_regs_used;
114 } rs6000_stack_t;
115
116 /* Target cpu type */
117
118 enum processor_type rs6000_cpu;
119 struct rs6000_cpu_select rs6000_select[3] =
120 {
121   /* switch             name,                   tune    arch */
122   { (const char *)0,    "--with-cpu=",          1,      1 },
123   { (const char *)0,    "-mcpu=",               1,      1 },
124   { (const char *)0,    "-mtune=",              1,      0 },
125 };
126
127 /* Always emit branch hint bits.  */
128 static GTY(()) bool rs6000_always_hint;
129
130 /* Schedule instructions for group formation.  */
131 static GTY(()) bool rs6000_sched_groups;
132
133 /* Support adjust_priority scheduler hook
134    and -mprioritize-restricted-insns= option.  */
135 const char *rs6000_sched_restricted_insns_priority_str;
136 int rs6000_sched_restricted_insns_priority;
137
138 /* Support for -msched-costly-dep option.  */
139 const char *rs6000_sched_costly_dep_str;
140 enum rs6000_dependence_cost rs6000_sched_costly_dep;
141
142 /* Support for -minsert-sched-nops option.  */
143 const char *rs6000_sched_insert_nops_str;
144 enum rs6000_nop_insertion rs6000_sched_insert_nops;
145
146 /* Support targetm.vectorize.builtin_mask_for_load.  */
147 static GTY(()) tree altivec_builtin_mask_for_load;
148
149 /* Size of long double */
150 const char *rs6000_long_double_size_string;
151 int rs6000_long_double_type_size;
152
153 /* Whether -mabi=altivec has appeared */
154 int rs6000_altivec_abi;
155
156 /* Whether VRSAVE instructions should be generated.  */
157 int rs6000_altivec_vrsave;
158
159 /* String from -mvrsave= option.  */
160 const char *rs6000_altivec_vrsave_string;
161
162 /* Nonzero if we want SPE ABI extensions.  */
163 int rs6000_spe_abi;
164
165 /* Whether isel instructions should be generated.  */
166 int rs6000_isel;
167
168 /* Whether SPE simd instructions should be generated.  */
169 int rs6000_spe;
170
171 /* Nonzero if floating point operations are done in the GPRs.  */
172 int rs6000_float_gprs = 0;
173
174 /* Nonzero if we want Darwin's struct-by-value-in-regs ABI.  */
175 int rs6000_darwin64_abi;
176
177 /* String from -mfloat-gprs=.  */
178 const char *rs6000_float_gprs_string;
179
180 /* String from -misel=.  */
181 const char *rs6000_isel_string;
182
183 /* String from -mspe=.  */
184 const char *rs6000_spe_string;
185
186 /* Set to nonzero once AIX common-mode calls have been defined.  */
187 static GTY(()) int common_mode_defined;
188
189 /* Save information from a "cmpxx" operation until the branch or scc is
190    emitted.  */
191 rtx rs6000_compare_op0, rs6000_compare_op1;
192 int rs6000_compare_fp_p;
193
194 /* Label number of label created for -mrelocatable, to call to so we can
195    get the address of the GOT section */
196 int rs6000_pic_labelno;
197
198 #ifdef USING_ELFOS_H
199 /* Which abi to adhere to */
200 const char *rs6000_abi_name;
201
202 /* Semantics of the small data area */
203 enum rs6000_sdata_type rs6000_sdata = SDATA_DATA;
204
205 /* Which small data model to use */
206 const char *rs6000_sdata_name = (char *)0;
207
208 /* Counter for labels which are to be placed in .fixup.  */
209 int fixuplabelno = 0;
210 #endif
211
212 /* Bit size of immediate TLS offsets and string from which it is decoded.  */
213 int rs6000_tls_size = 32;
214 const char *rs6000_tls_size_string;
215
216 /* ABI enumeration available for subtarget to use.  */
217 enum rs6000_abi rs6000_current_abi;
218
219 /* ABI string from -mabi= option.  */
220 const char *rs6000_abi_string;
221
222 /* Whether to use variant of AIX ABI for PowerPC64 Linux.  */
223 int dot_symbols;
224
225 /* Debug flags */
226 const char *rs6000_debug_name;
227 int rs6000_debug_stack;         /* debug stack applications */
228 int rs6000_debug_arg;           /* debug argument handling */
229
230 /* Value is TRUE if register/mode pair is acceptable.  */
231 bool rs6000_hard_regno_mode_ok_p[NUM_MACHINE_MODES][FIRST_PSEUDO_REGISTER];
232
233 /* Opaque types.  */
234 static GTY(()) tree opaque_V2SI_type_node;
235 static GTY(()) tree opaque_V2SF_type_node;
236 static GTY(()) tree opaque_p_V2SI_type_node;
237 static GTY(()) tree V16QI_type_node;
238 static GTY(()) tree V2SI_type_node;
239 static GTY(()) tree V2SF_type_node;
240 static GTY(()) tree V4HI_type_node;
241 static GTY(()) tree V4SI_type_node;
242 static GTY(()) tree V4SF_type_node;
243 static GTY(()) tree V8HI_type_node;
244 static GTY(()) tree unsigned_V16QI_type_node;
245 static GTY(()) tree unsigned_V8HI_type_node;
246 static GTY(()) tree unsigned_V4SI_type_node;
247 static GTY(()) tree bool_char_type_node;        /* __bool char */
248 static GTY(()) tree bool_short_type_node;       /* __bool short */
249 static GTY(()) tree bool_int_type_node;         /* __bool int */
250 static GTY(()) tree pixel_type_node;            /* __pixel */
251 static GTY(()) tree bool_V16QI_type_node;       /* __vector __bool char */
252 static GTY(()) tree bool_V8HI_type_node;        /* __vector __bool short */
253 static GTY(()) tree bool_V4SI_type_node;        /* __vector __bool int */
254 static GTY(()) tree pixel_V8HI_type_node;       /* __vector __pixel */
255
256 int rs6000_warn_altivec_long = 1;               /* On by default. */
257 const char *rs6000_warn_altivec_long_switch;
258
259 const char *rs6000_traceback_name;
260 static enum {
261   traceback_default = 0,
262   traceback_none,
263   traceback_part,
264   traceback_full
265 } rs6000_traceback;
266
267 /* Flag to say the TOC is initialized */
268 int toc_initialized;
269 char toc_label_name[10];
270
271 /* Alias set for saves and restores from the rs6000 stack.  */
272 static GTY(()) int rs6000_sr_alias_set;
273
274 /* Call distance, overridden by -mlongcall and #pragma longcall(1).
275    The only place that looks at this is rs6000_set_default_type_attributes;
276    everywhere else should rely on the presence or absence of a longcall
277    attribute on the function declaration.  Exception: init_cumulative_args
278    looks at it too, for libcalls.  */
279 int rs6000_default_long_calls;
280 const char *rs6000_longcall_switch;
281
282 /* Control alignment for fields within structures.  */
283 /* String from -malign-XXXXX.  */
284 const char *rs6000_alignment_string;
285 int rs6000_alignment_flags;
286
287 struct builtin_description
288 {
289   /* mask is not const because we're going to alter it below.  This
290      nonsense will go away when we rewrite the -march infrastructure
291      to give us more target flag bits.  */
292   unsigned int mask;
293   const enum insn_code icode;
294   const char *const name;
295   const enum rs6000_builtins code;
296 };
297 \f
298 /* Target cpu costs.  */
299
300 struct processor_costs {
301   const int mulsi;        /* cost of SImode multiplication.  */
302   const int mulsi_const;  /* cost of SImode multiplication by constant.  */
303   const int mulsi_const9; /* cost of SImode mult by short constant.  */
304   const int muldi;        /* cost of DImode multiplication.  */
305   const int divsi;        /* cost of SImode division.  */
306   const int divdi;        /* cost of DImode division.  */
307   const int fp;           /* cost of simple SFmode and DFmode insns.  */
308   const int dmul;         /* cost of DFmode multiplication (and fmadd).  */
309   const int sdiv;         /* cost of SFmode division (fdivs).  */
310   const int ddiv;         /* cost of DFmode division (fdiv).  */
311 };
312
313 const struct processor_costs *rs6000_cost;
314
315 /* Processor costs (relative to an add) */
316
317 /* Instruction size costs on 32bit processors.  */
318 static const
319 struct processor_costs size32_cost = {
320   COSTS_N_INSNS (1),    /* mulsi */
321   COSTS_N_INSNS (1),    /* mulsi_const */
322   COSTS_N_INSNS (1),    /* mulsi_const9 */
323   COSTS_N_INSNS (1),    /* muldi */
324   COSTS_N_INSNS (1),    /* divsi */
325   COSTS_N_INSNS (1),    /* divdi */
326   COSTS_N_INSNS (1),    /* fp */
327   COSTS_N_INSNS (1),    /* dmul */
328   COSTS_N_INSNS (1),    /* sdiv */
329   COSTS_N_INSNS (1),    /* ddiv */
330 };
331
332 /* Instruction size costs on 64bit processors.  */
333 static const
334 struct processor_costs size64_cost = {
335   COSTS_N_INSNS (1),    /* mulsi */
336   COSTS_N_INSNS (1),    /* mulsi_const */
337   COSTS_N_INSNS (1),    /* mulsi_const9 */
338   COSTS_N_INSNS (1),    /* muldi */
339   COSTS_N_INSNS (1),    /* divsi */
340   COSTS_N_INSNS (1),    /* divdi */
341   COSTS_N_INSNS (1),    /* fp */
342   COSTS_N_INSNS (1),    /* dmul */
343   COSTS_N_INSNS (1),    /* sdiv */
344   COSTS_N_INSNS (1),    /* ddiv */
345 };
346
347 /* Instruction costs on RIOS1 processors.  */
348 static const
349 struct processor_costs rios1_cost = {
350   COSTS_N_INSNS (5),    /* mulsi */
351   COSTS_N_INSNS (4),    /* mulsi_const */
352   COSTS_N_INSNS (3),    /* mulsi_const9 */
353   COSTS_N_INSNS (5),    /* muldi */
354   COSTS_N_INSNS (19),   /* divsi */
355   COSTS_N_INSNS (19),   /* divdi */
356   COSTS_N_INSNS (2),    /* fp */
357   COSTS_N_INSNS (2),    /* dmul */
358   COSTS_N_INSNS (19),   /* sdiv */
359   COSTS_N_INSNS (19),   /* ddiv */
360 };
361
362 /* Instruction costs on RIOS2 processors.  */
363 static const
364 struct processor_costs rios2_cost = {
365   COSTS_N_INSNS (2),    /* mulsi */
366   COSTS_N_INSNS (2),    /* mulsi_const */
367   COSTS_N_INSNS (2),    /* mulsi_const9 */
368   COSTS_N_INSNS (2),    /* muldi */
369   COSTS_N_INSNS (13),   /* divsi */
370   COSTS_N_INSNS (13),   /* divdi */
371   COSTS_N_INSNS (2),    /* fp */
372   COSTS_N_INSNS (2),    /* dmul */
373   COSTS_N_INSNS (17),   /* sdiv */
374   COSTS_N_INSNS (17),   /* ddiv */
375 };
376
377 /* Instruction costs on RS64A processors.  */
378 static const
379 struct processor_costs rs64a_cost = {
380   COSTS_N_INSNS (20),   /* mulsi */
381   COSTS_N_INSNS (12),   /* mulsi_const */
382   COSTS_N_INSNS (8),    /* mulsi_const9 */
383   COSTS_N_INSNS (34),   /* muldi */
384   COSTS_N_INSNS (65),   /* divsi */
385   COSTS_N_INSNS (67),   /* divdi */
386   COSTS_N_INSNS (4),    /* fp */
387   COSTS_N_INSNS (4),    /* dmul */
388   COSTS_N_INSNS (31),   /* sdiv */
389   COSTS_N_INSNS (31),   /* ddiv */
390 };
391
392 /* Instruction costs on MPCCORE processors.  */
393 static const
394 struct processor_costs mpccore_cost = {
395   COSTS_N_INSNS (2),    /* mulsi */
396   COSTS_N_INSNS (2),    /* mulsi_const */
397   COSTS_N_INSNS (2),    /* mulsi_const9 */
398   COSTS_N_INSNS (2),    /* muldi */
399   COSTS_N_INSNS (6),    /* divsi */
400   COSTS_N_INSNS (6),    /* divdi */
401   COSTS_N_INSNS (4),    /* fp */
402   COSTS_N_INSNS (5),    /* dmul */
403   COSTS_N_INSNS (10),   /* sdiv */
404   COSTS_N_INSNS (17),   /* ddiv */
405 };
406
407 /* Instruction costs on PPC403 processors.  */
408 static const
409 struct processor_costs ppc403_cost = {
410   COSTS_N_INSNS (4),    /* mulsi */
411   COSTS_N_INSNS (4),    /* mulsi_const */
412   COSTS_N_INSNS (4),    /* mulsi_const9 */
413   COSTS_N_INSNS (4),    /* muldi */
414   COSTS_N_INSNS (33),   /* divsi */
415   COSTS_N_INSNS (33),   /* divdi */
416   COSTS_N_INSNS (11),   /* fp */
417   COSTS_N_INSNS (11),   /* dmul */
418   COSTS_N_INSNS (11),   /* sdiv */
419   COSTS_N_INSNS (11),   /* ddiv */
420 };
421
422 /* Instruction costs on PPC405 processors.  */
423 static const
424 struct processor_costs ppc405_cost = {
425   COSTS_N_INSNS (5),    /* mulsi */
426   COSTS_N_INSNS (4),    /* mulsi_const */
427   COSTS_N_INSNS (3),    /* mulsi_const9 */
428   COSTS_N_INSNS (5),    /* muldi */
429   COSTS_N_INSNS (35),   /* divsi */
430   COSTS_N_INSNS (35),   /* divdi */
431   COSTS_N_INSNS (11),   /* fp */
432   COSTS_N_INSNS (11),   /* dmul */
433   COSTS_N_INSNS (11),   /* sdiv */
434   COSTS_N_INSNS (11),   /* ddiv */
435 };
436
437 /* Instruction costs on PPC440 processors.  */
438 static const
439 struct processor_costs ppc440_cost = {
440   COSTS_N_INSNS (3),    /* mulsi */
441   COSTS_N_INSNS (2),    /* mulsi_const */
442   COSTS_N_INSNS (2),    /* mulsi_const9 */
443   COSTS_N_INSNS (3),    /* muldi */
444   COSTS_N_INSNS (34),   /* divsi */
445   COSTS_N_INSNS (34),   /* divdi */
446   COSTS_N_INSNS (5),    /* fp */
447   COSTS_N_INSNS (5),    /* dmul */
448   COSTS_N_INSNS (19),   /* sdiv */
449   COSTS_N_INSNS (33),   /* ddiv */
450 };
451
452 /* Instruction costs on PPC601 processors.  */
453 static const
454 struct processor_costs ppc601_cost = {
455   COSTS_N_INSNS (5),    /* mulsi */
456   COSTS_N_INSNS (5),    /* mulsi_const */
457   COSTS_N_INSNS (5),    /* mulsi_const9 */
458   COSTS_N_INSNS (5),    /* muldi */
459   COSTS_N_INSNS (36),   /* divsi */
460   COSTS_N_INSNS (36),   /* divdi */
461   COSTS_N_INSNS (4),    /* fp */
462   COSTS_N_INSNS (5),    /* dmul */
463   COSTS_N_INSNS (17),   /* sdiv */
464   COSTS_N_INSNS (31),   /* ddiv */
465 };
466
467 /* Instruction costs on PPC603 processors.  */
468 static const
469 struct processor_costs ppc603_cost = {
470   COSTS_N_INSNS (5),    /* mulsi */
471   COSTS_N_INSNS (3),    /* mulsi_const */
472   COSTS_N_INSNS (2),    /* mulsi_const9 */
473   COSTS_N_INSNS (5),    /* muldi */
474   COSTS_N_INSNS (37),   /* divsi */
475   COSTS_N_INSNS (37),   /* divdi */
476   COSTS_N_INSNS (3),    /* fp */
477   COSTS_N_INSNS (4),    /* dmul */
478   COSTS_N_INSNS (18),   /* sdiv */
479   COSTS_N_INSNS (33),   /* ddiv */
480 };
481
482 /* Instruction costs on PPC604 processors.  */
483 static const
484 struct processor_costs ppc604_cost = {
485   COSTS_N_INSNS (4),    /* mulsi */
486   COSTS_N_INSNS (4),    /* mulsi_const */
487   COSTS_N_INSNS (4),    /* mulsi_const9 */
488   COSTS_N_INSNS (4),    /* muldi */
489   COSTS_N_INSNS (20),   /* divsi */
490   COSTS_N_INSNS (20),   /* divdi */
491   COSTS_N_INSNS (3),    /* fp */
492   COSTS_N_INSNS (3),    /* dmul */
493   COSTS_N_INSNS (18),   /* sdiv */
494   COSTS_N_INSNS (32),   /* ddiv */
495 };
496
497 /* Instruction costs on PPC604e processors.  */
498 static const
499 struct processor_costs ppc604e_cost = {
500   COSTS_N_INSNS (2),    /* mulsi */
501   COSTS_N_INSNS (2),    /* mulsi_const */
502   COSTS_N_INSNS (2),    /* mulsi_const9 */
503   COSTS_N_INSNS (2),    /* muldi */
504   COSTS_N_INSNS (20),   /* divsi */
505   COSTS_N_INSNS (20),   /* divdi */
506   COSTS_N_INSNS (3),    /* fp */
507   COSTS_N_INSNS (3),    /* dmul */
508   COSTS_N_INSNS (18),   /* sdiv */
509   COSTS_N_INSNS (32),   /* ddiv */
510 };
511
512 /* Instruction costs on PPC620 processors.  */
513 static const
514 struct processor_costs ppc620_cost = {
515   COSTS_N_INSNS (5),    /* mulsi */
516   COSTS_N_INSNS (4),    /* mulsi_const */
517   COSTS_N_INSNS (3),    /* mulsi_const9 */
518   COSTS_N_INSNS (7),    /* muldi */
519   COSTS_N_INSNS (21),   /* divsi */
520   COSTS_N_INSNS (37),   /* divdi */
521   COSTS_N_INSNS (3),    /* fp */
522   COSTS_N_INSNS (3),    /* dmul */
523   COSTS_N_INSNS (18),   /* sdiv */
524   COSTS_N_INSNS (32),   /* ddiv */
525 };
526
527 /* Instruction costs on PPC630 processors.  */
528 static const
529 struct processor_costs ppc630_cost = {
530   COSTS_N_INSNS (5),    /* mulsi */
531   COSTS_N_INSNS (4),    /* mulsi_const */
532   COSTS_N_INSNS (3),    /* mulsi_const9 */
533   COSTS_N_INSNS (7),    /* muldi */
534   COSTS_N_INSNS (21),   /* divsi */
535   COSTS_N_INSNS (37),   /* divdi */
536   COSTS_N_INSNS (3),    /* fp */
537   COSTS_N_INSNS (3),    /* dmul */
538   COSTS_N_INSNS (17),   /* sdiv */
539   COSTS_N_INSNS (21),   /* ddiv */
540 };
541
542 /* Instruction costs on PPC750 and PPC7400 processors.  */
543 static const
544 struct processor_costs ppc750_cost = {
545   COSTS_N_INSNS (5),    /* mulsi */
546   COSTS_N_INSNS (3),    /* mulsi_const */
547   COSTS_N_INSNS (2),    /* mulsi_const9 */
548   COSTS_N_INSNS (5),    /* muldi */
549   COSTS_N_INSNS (17),   /* divsi */
550   COSTS_N_INSNS (17),   /* divdi */
551   COSTS_N_INSNS (3),    /* fp */
552   COSTS_N_INSNS (3),    /* dmul */
553   COSTS_N_INSNS (17),   /* sdiv */
554   COSTS_N_INSNS (31),   /* ddiv */
555 };
556
557 /* Instruction costs on PPC7450 processors.  */
558 static const
559 struct processor_costs ppc7450_cost = {
560   COSTS_N_INSNS (4),    /* mulsi */
561   COSTS_N_INSNS (3),    /* mulsi_const */
562   COSTS_N_INSNS (3),    /* mulsi_const9 */
563   COSTS_N_INSNS (4),    /* muldi */
564   COSTS_N_INSNS (23),   /* divsi */
565   COSTS_N_INSNS (23),   /* divdi */
566   COSTS_N_INSNS (5),    /* fp */
567   COSTS_N_INSNS (5),    /* dmul */
568   COSTS_N_INSNS (21),   /* sdiv */
569   COSTS_N_INSNS (35),   /* ddiv */
570 };
571
572 /* Instruction costs on PPC8540 processors.  */
573 static const
574 struct processor_costs ppc8540_cost = {
575   COSTS_N_INSNS (4),    /* mulsi */
576   COSTS_N_INSNS (4),    /* mulsi_const */
577   COSTS_N_INSNS (4),    /* mulsi_const9 */
578   COSTS_N_INSNS (4),    /* muldi */
579   COSTS_N_INSNS (19),   /* divsi */
580   COSTS_N_INSNS (19),   /* divdi */
581   COSTS_N_INSNS (4),    /* fp */
582   COSTS_N_INSNS (4),    /* dmul */
583   COSTS_N_INSNS (29),   /* sdiv */
584   COSTS_N_INSNS (29),   /* ddiv */
585 };
586
587 /* Instruction costs on POWER4 and POWER5 processors.  */
588 static const
589 struct processor_costs power4_cost = {
590   COSTS_N_INSNS (3),    /* mulsi */
591   COSTS_N_INSNS (2),    /* mulsi_const */
592   COSTS_N_INSNS (2),    /* mulsi_const9 */
593   COSTS_N_INSNS (4),    /* muldi */
594   COSTS_N_INSNS (18),   /* divsi */
595   COSTS_N_INSNS (34),   /* divdi */
596   COSTS_N_INSNS (3),    /* fp */
597   COSTS_N_INSNS (3),    /* dmul */
598   COSTS_N_INSNS (17),   /* sdiv */
599   COSTS_N_INSNS (17),   /* ddiv */
600 };
601
602 \f
603 static bool rs6000_function_ok_for_sibcall (tree, tree);
604 static rtx rs6000_generate_compare (enum rtx_code);
605 static void rs6000_maybe_dead (rtx);
606 static void rs6000_emit_stack_tie (void);
607 static void rs6000_frame_related (rtx, rtx, HOST_WIDE_INT, rtx, rtx);
608 static rtx spe_synthesize_frame_save (rtx);
609 static bool spe_func_has_64bit_regs_p (void);
610 static void emit_frame_save (rtx, rtx, enum machine_mode, unsigned int,
611                              int, HOST_WIDE_INT);
612 static rtx gen_frame_mem_offset (enum machine_mode, rtx, int);
613 static void rs6000_emit_allocate_stack (HOST_WIDE_INT, int);
614 static unsigned rs6000_hash_constant (rtx);
615 static unsigned toc_hash_function (const void *);
616 static int toc_hash_eq (const void *, const void *);
617 static int constant_pool_expr_1 (rtx, int *, int *);
618 static bool constant_pool_expr_p (rtx);
619 static bool legitimate_small_data_p (enum machine_mode, rtx);
620 static bool legitimate_indexed_address_p (rtx, int);
621 static bool legitimate_lo_sum_address_p (enum machine_mode, rtx, int);
622 static struct machine_function * rs6000_init_machine_status (void);
623 static bool rs6000_assemble_integer (rtx, unsigned int, int);
624 #ifdef HAVE_GAS_HIDDEN
625 static void rs6000_assemble_visibility (tree, int);
626 #endif
627 static int rs6000_ra_ever_killed (void);
628 static tree rs6000_handle_longcall_attribute (tree *, tree, tree, int, bool *);
629 static tree rs6000_handle_altivec_attribute (tree *, tree, tree, int, bool *);
630 static void rs6000_eliminate_indexed_memrefs (rtx operands[2]);
631 static const char *rs6000_mangle_fundamental_type (tree);
632 extern const struct attribute_spec rs6000_attribute_table[];
633 static void rs6000_set_default_type_attributes (tree);
634 static void rs6000_output_function_prologue (FILE *, HOST_WIDE_INT);
635 static void rs6000_output_function_epilogue (FILE *, HOST_WIDE_INT);
636 static void rs6000_output_mi_thunk (FILE *, tree, HOST_WIDE_INT, HOST_WIDE_INT,
637                                     tree);
638 static rtx rs6000_emit_set_long_const (rtx, HOST_WIDE_INT, HOST_WIDE_INT);
639 static bool rs6000_return_in_memory (tree, tree);
640 static void rs6000_file_start (void);
641 #if TARGET_ELF
642 static unsigned int rs6000_elf_section_type_flags (tree, const char *, int);
643 static void rs6000_elf_asm_out_constructor (rtx, int);
644 static void rs6000_elf_asm_out_destructor (rtx, int);
645 static void rs6000_elf_select_section (tree, int, unsigned HOST_WIDE_INT);
646 static void rs6000_elf_unique_section (tree, int);
647 static void rs6000_elf_select_rtx_section (enum machine_mode, rtx,
648                                            unsigned HOST_WIDE_INT);
649 static void rs6000_elf_encode_section_info (tree, rtx, int)
650      ATTRIBUTE_UNUSED;
651 static bool rs6000_elf_in_small_data_p (tree);
652 #endif
653 #if TARGET_XCOFF
654 static void rs6000_xcoff_asm_globalize_label (FILE *, const char *);
655 static void rs6000_xcoff_asm_named_section (const char *, unsigned int, tree);
656 static void rs6000_xcoff_select_section (tree, int, unsigned HOST_WIDE_INT);
657 static void rs6000_xcoff_unique_section (tree, int);
658 static void rs6000_xcoff_select_rtx_section (enum machine_mode, rtx,
659                                              unsigned HOST_WIDE_INT);
660 static const char * rs6000_xcoff_strip_name_encoding (const char *);
661 static unsigned int rs6000_xcoff_section_type_flags (tree, const char *, int);
662 static void rs6000_xcoff_file_start (void);
663 static void rs6000_xcoff_file_end (void);
664 #endif
665 #if TARGET_MACHO
666 static bool rs6000_binds_local_p (tree);
667 #endif
668 static int rs6000_variable_issue (FILE *, int, rtx, int);
669 static bool rs6000_rtx_costs (rtx, int, int, int *);
670 static int rs6000_adjust_cost (rtx, rtx, rtx, int);
671 static bool is_microcoded_insn (rtx);
672 static int is_dispatch_slot_restricted (rtx);
673 static bool is_cracked_insn (rtx);
674 static bool is_branch_slot_insn (rtx);
675 static int rs6000_adjust_priority (rtx, int);
676 static int rs6000_issue_rate (void);
677 static bool rs6000_is_costly_dependence (rtx, rtx, rtx, int, int);
678 static rtx get_next_active_insn (rtx, rtx);
679 static bool insn_terminates_group_p (rtx , enum group_termination);
680 static bool is_costly_group (rtx *, rtx);
681 static int force_new_group (int, FILE *, rtx *, rtx, bool *, int, int *);
682 static int redefine_groups (FILE *, int, rtx, rtx);
683 static int pad_groups (FILE *, int, rtx, rtx);
684 static void rs6000_sched_finish (FILE *, int);
685 static int rs6000_use_sched_lookahead (void);
686 static tree rs6000_builtin_mask_for_load (void);
687
688 static void rs6000_init_builtins (void);
689 static rtx rs6000_expand_unop_builtin (enum insn_code, tree, rtx);
690 static rtx rs6000_expand_binop_builtin (enum insn_code, tree, rtx);
691 static rtx rs6000_expand_ternop_builtin (enum insn_code, tree, rtx);
692 static rtx rs6000_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
693 static void altivec_init_builtins (void);
694 static void rs6000_common_init_builtins (void);
695 static void rs6000_init_libfuncs (void);
696
697 static void enable_mask_for_builtins (struct builtin_description *, int,
698                                       enum rs6000_builtins,
699                                       enum rs6000_builtins);
700 static tree build_opaque_vector_type (tree, int);
701 static void spe_init_builtins (void);
702 static rtx spe_expand_builtin (tree, rtx, bool *);
703 static rtx spe_expand_stv_builtin (enum insn_code, tree);
704 static rtx spe_expand_predicate_builtin (enum insn_code, tree, rtx);
705 static rtx spe_expand_evsel_builtin (enum insn_code, tree, rtx);
706 static int rs6000_emit_int_cmove (rtx, rtx, rtx, rtx);
707 static rs6000_stack_t *rs6000_stack_info (void);
708 static void debug_stack_info (rs6000_stack_t *);
709
710 static rtx altivec_expand_builtin (tree, rtx, bool *);
711 static rtx altivec_expand_ld_builtin (tree, rtx, bool *);
712 static rtx altivec_expand_st_builtin (tree, rtx, bool *);
713 static rtx altivec_expand_dst_builtin (tree, rtx, bool *);
714 static rtx altivec_expand_abs_builtin (enum insn_code, tree, rtx);
715 static rtx altivec_expand_predicate_builtin (enum insn_code,
716                                              const char *, tree, rtx);
717 static rtx altivec_expand_lv_builtin (enum insn_code, tree, rtx);
718 static rtx altivec_expand_stv_builtin (enum insn_code, tree);
719 static void rs6000_parse_abi_options (void);
720 static void rs6000_parse_alignment_option (void);
721 static void rs6000_parse_tls_size_option (void);
722 static void rs6000_parse_yes_no_option (const char *, const char *, int *);
723 static void rs6000_parse_float_gprs_option (void);
724 static int first_altivec_reg_to_save (void);
725 static unsigned int compute_vrsave_mask (void);
726 static void compute_save_world_info (rs6000_stack_t *info_ptr);
727 static void is_altivec_return_reg (rtx, void *);
728 static rtx generate_set_vrsave (rtx, rs6000_stack_t *, int);
729 int easy_vector_constant (rtx, enum machine_mode);
730 static bool is_ev64_opaque_type (tree);
731 static rtx rs6000_dwarf_register_span (rtx);
732 static rtx rs6000_legitimize_tls_address (rtx, enum tls_model);
733 static rtx rs6000_tls_get_addr (void);
734 static rtx rs6000_got_sym (void);
735 static int rs6000_tls_symbol_ref_1 (rtx *, void *);
736 static const char *rs6000_get_some_local_dynamic_name (void);
737 static int rs6000_get_some_local_dynamic_name_1 (rtx *, void *);
738 static rtx rs6000_complex_function_value (enum machine_mode);
739 static rtx rs6000_spe_function_arg (CUMULATIVE_ARGS *,
740                                     enum machine_mode, tree);
741 static void rs6000_darwin64_record_arg_advance_flush (CUMULATIVE_ARGS *,
742                                                       HOST_WIDE_INT);
743 static void rs6000_darwin64_record_arg_advance_recurse (CUMULATIVE_ARGS *,
744                                                         tree, HOST_WIDE_INT);
745 static void rs6000_darwin64_record_arg_flush (CUMULATIVE_ARGS *,
746                                               HOST_WIDE_INT,
747                                               rtx[], int *);
748 static void rs6000_darwin64_record_arg_recurse (CUMULATIVE_ARGS *,
749                                                tree, HOST_WIDE_INT,
750                                                rtx[], int *);
751 static rtx rs6000_darwin64_record_arg (CUMULATIVE_ARGS *, tree, int, bool);
752 static rtx rs6000_mixed_function_arg (enum machine_mode, tree, int);
753 static void rs6000_move_block_from_reg (int regno, rtx x, int nregs);
754 static void setup_incoming_varargs (CUMULATIVE_ARGS *,
755                                     enum machine_mode, tree,
756                                     int *, int);
757 static bool rs6000_pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode,
758                                       tree, bool);
759 static int rs6000_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode,
760                                      tree, bool);
761 static const char *invalid_arg_for_unprototyped_fn (tree, tree, tree);
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 \f
857 /* Initialize the GCC target structure.  */
858 #undef TARGET_ATTRIBUTE_TABLE
859 #define TARGET_ATTRIBUTE_TABLE rs6000_attribute_table
860 #undef TARGET_SET_DEFAULT_TYPE_ATTRIBUTES
861 #define TARGET_SET_DEFAULT_TYPE_ATTRIBUTES rs6000_set_default_type_attributes
862
863 #undef TARGET_ASM_ALIGNED_DI_OP
864 #define TARGET_ASM_ALIGNED_DI_OP DOUBLE_INT_ASM_OP
865
866 /* Default unaligned ops are only provided for ELF.  Find the ops needed
867    for non-ELF systems.  */
868 #ifndef OBJECT_FORMAT_ELF
869 #if TARGET_XCOFF
870 /* For XCOFF.  rs6000_assemble_integer will handle unaligned DIs on
871    64-bit targets.  */
872 #undef TARGET_ASM_UNALIGNED_HI_OP
873 #define TARGET_ASM_UNALIGNED_HI_OP "\t.vbyte\t2,"
874 #undef TARGET_ASM_UNALIGNED_SI_OP
875 #define TARGET_ASM_UNALIGNED_SI_OP "\t.vbyte\t4,"
876 #undef TARGET_ASM_UNALIGNED_DI_OP
877 #define TARGET_ASM_UNALIGNED_DI_OP "\t.vbyte\t8,"
878 #else
879 /* For Darwin.  */
880 #undef TARGET_ASM_UNALIGNED_HI_OP
881 #define TARGET_ASM_UNALIGNED_HI_OP "\t.short\t"
882 #undef TARGET_ASM_UNALIGNED_SI_OP
883 #define TARGET_ASM_UNALIGNED_SI_OP "\t.long\t"
884 #undef TARGET_ASM_UNALIGNED_DI_OP
885 #define TARGET_ASM_UNALIGNED_DI_OP "\t.quad\t"
886 #undef TARGET_ASM_ALIGNED_DI_OP
887 #define TARGET_ASM_ALIGNED_DI_OP "\t.quad\t"
888 #endif
889 #endif
890
891 /* This hook deals with fixups for relocatable code and DI-mode objects
892    in 64-bit code.  */
893 #undef TARGET_ASM_INTEGER
894 #define TARGET_ASM_INTEGER rs6000_assemble_integer
895
896 #ifdef HAVE_GAS_HIDDEN
897 #undef TARGET_ASM_ASSEMBLE_VISIBILITY
898 #define TARGET_ASM_ASSEMBLE_VISIBILITY rs6000_assemble_visibility
899 #endif
900
901 #undef TARGET_HAVE_TLS
902 #define TARGET_HAVE_TLS HAVE_AS_TLS
903
904 #undef TARGET_CANNOT_FORCE_CONST_MEM
905 #define TARGET_CANNOT_FORCE_CONST_MEM rs6000_tls_referenced_p
906
907 #undef TARGET_ASM_FUNCTION_PROLOGUE
908 #define TARGET_ASM_FUNCTION_PROLOGUE rs6000_output_function_prologue
909 #undef TARGET_ASM_FUNCTION_EPILOGUE
910 #define TARGET_ASM_FUNCTION_EPILOGUE rs6000_output_function_epilogue
911
912 #undef  TARGET_SCHED_VARIABLE_ISSUE
913 #define TARGET_SCHED_VARIABLE_ISSUE rs6000_variable_issue
914
915 #undef TARGET_SCHED_ISSUE_RATE
916 #define TARGET_SCHED_ISSUE_RATE rs6000_issue_rate
917 #undef TARGET_SCHED_ADJUST_COST
918 #define TARGET_SCHED_ADJUST_COST rs6000_adjust_cost
919 #undef TARGET_SCHED_ADJUST_PRIORITY
920 #define TARGET_SCHED_ADJUST_PRIORITY rs6000_adjust_priority
921 #undef TARGET_SCHED_IS_COSTLY_DEPENDENCE
922 #define TARGET_SCHED_IS_COSTLY_DEPENDENCE rs6000_is_costly_dependence
923 #undef TARGET_SCHED_FINISH
924 #define TARGET_SCHED_FINISH rs6000_sched_finish
925
926 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
927 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD rs6000_use_sched_lookahead
928
929 #undef TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD
930 #define TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD rs6000_builtin_mask_for_load
931
932 #undef TARGET_INIT_BUILTINS
933 #define TARGET_INIT_BUILTINS rs6000_init_builtins
934
935 #undef TARGET_EXPAND_BUILTIN
936 #define TARGET_EXPAND_BUILTIN rs6000_expand_builtin
937
938 #undef TARGET_MANGLE_FUNDAMENTAL_TYPE
939 #define TARGET_MANGLE_FUNDAMENTAL_TYPE rs6000_mangle_fundamental_type
940
941 #undef TARGET_INIT_LIBFUNCS
942 #define TARGET_INIT_LIBFUNCS rs6000_init_libfuncs
943
944 #if TARGET_MACHO
945 #undef TARGET_BINDS_LOCAL_P
946 #define TARGET_BINDS_LOCAL_P rs6000_binds_local_p
947 #endif
948
949 #undef TARGET_ASM_OUTPUT_MI_THUNK
950 #define TARGET_ASM_OUTPUT_MI_THUNK rs6000_output_mi_thunk
951
952 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
953 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK hook_bool_tree_hwi_hwi_tree_true
954
955 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
956 #define TARGET_FUNCTION_OK_FOR_SIBCALL rs6000_function_ok_for_sibcall
957
958 #undef TARGET_RTX_COSTS
959 #define TARGET_RTX_COSTS rs6000_rtx_costs
960 #undef TARGET_ADDRESS_COST
961 #define TARGET_ADDRESS_COST hook_int_rtx_0
962
963 #undef TARGET_VECTOR_OPAQUE_P
964 #define TARGET_VECTOR_OPAQUE_P is_ev64_opaque_type
965
966 #undef TARGET_DWARF_REGISTER_SPAN
967 #define TARGET_DWARF_REGISTER_SPAN rs6000_dwarf_register_span
968
969 /* On rs6000, function arguments are promoted, as are function return
970    values.  */
971 #undef TARGET_PROMOTE_FUNCTION_ARGS
972 #define TARGET_PROMOTE_FUNCTION_ARGS hook_bool_tree_true
973 #undef TARGET_PROMOTE_FUNCTION_RETURN
974 #define TARGET_PROMOTE_FUNCTION_RETURN hook_bool_tree_true
975
976 #undef TARGET_RETURN_IN_MEMORY
977 #define TARGET_RETURN_IN_MEMORY rs6000_return_in_memory
978
979 #undef TARGET_SETUP_INCOMING_VARARGS
980 #define TARGET_SETUP_INCOMING_VARARGS setup_incoming_varargs
981
982 /* Always strict argument naming on rs6000.  */
983 #undef TARGET_STRICT_ARGUMENT_NAMING
984 #define TARGET_STRICT_ARGUMENT_NAMING hook_bool_CUMULATIVE_ARGS_true
985 #undef TARGET_PRETEND_OUTGOING_VARARGS_NAMED
986 #define TARGET_PRETEND_OUTGOING_VARARGS_NAMED hook_bool_CUMULATIVE_ARGS_true
987 #undef TARGET_SPLIT_COMPLEX_ARG
988 #define TARGET_SPLIT_COMPLEX_ARG hook_bool_tree_true
989 #undef TARGET_MUST_PASS_IN_STACK
990 #define TARGET_MUST_PASS_IN_STACK rs6000_must_pass_in_stack
991 #undef TARGET_PASS_BY_REFERENCE
992 #define TARGET_PASS_BY_REFERENCE rs6000_pass_by_reference
993 #undef TARGET_ARG_PARTIAL_BYTES
994 #define TARGET_ARG_PARTIAL_BYTES rs6000_arg_partial_bytes
995
996 #undef TARGET_BUILD_BUILTIN_VA_LIST
997 #define TARGET_BUILD_BUILTIN_VA_LIST rs6000_build_builtin_va_list
998
999 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
1000 #define TARGET_GIMPLIFY_VA_ARG_EXPR rs6000_gimplify_va_arg
1001
1002 #undef TARGET_EH_RETURN_FILTER_MODE
1003 #define TARGET_EH_RETURN_FILTER_MODE rs6000_eh_return_filter_mode
1004
1005 #undef TARGET_VECTOR_MODE_SUPPORTED_P
1006 #define TARGET_VECTOR_MODE_SUPPORTED_P rs6000_vector_mode_supported_p
1007
1008 #undef TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN
1009 #define TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN invalid_arg_for_unprototyped_fn
1010
1011 /* MPC604EUM 3.5.2 Weak Consistency between Multiple Processors
1012    The PowerPC architecture requires only weak consistency among
1013    processors--that is, memory accesses between processors need not be
1014    sequentially consistent and memory accesses among processors can occur
1015    in any order. The ability to order memory accesses weakly provides
1016    opportunities for more efficient use of the system bus. Unless a
1017    dependency exists, the 604e allows read operations to precede store
1018    operations.  */
1019 #undef TARGET_RELAXED_ORDERING
1020 #define TARGET_RELAXED_ORDERING true
1021
1022 struct gcc_target targetm = TARGET_INITIALIZER;
1023 \f
1024
1025 /* Value is 1 if hard register REGNO can hold a value of machine-mode
1026    MODE.  */
1027 static int
1028 rs6000_hard_regno_mode_ok (int regno, enum machine_mode mode)
1029 {
1030   /* The GPRs can hold any mode, but values bigger than one register
1031      cannot go past R31.  */
1032   if (INT_REGNO_P (regno))
1033     return INT_REGNO_P (regno + HARD_REGNO_NREGS (regno, mode) - 1);
1034
1035   /* The float registers can only hold floating modes and DImode.  */
1036   if (FP_REGNO_P (regno))
1037     return
1038       (GET_MODE_CLASS (mode) == MODE_FLOAT
1039        && FP_REGNO_P (regno + HARD_REGNO_NREGS (regno, mode) - 1))
1040       || (GET_MODE_CLASS (mode) == MODE_INT
1041           && GET_MODE_SIZE (mode) == UNITS_PER_FP_WORD);
1042
1043   /* The CR register can only hold CC modes.  */
1044   if (CR_REGNO_P (regno))
1045     return GET_MODE_CLASS (mode) == MODE_CC;
1046
1047   if (XER_REGNO_P (regno))
1048     return mode == PSImode;
1049
1050   /* AltiVec only in AldyVec registers.  */
1051   if (ALTIVEC_REGNO_P (regno))
1052     return ALTIVEC_VECTOR_MODE (mode);
1053
1054   /* ...but GPRs can hold SIMD data on the SPE in one register.  */
1055   if (SPE_SIMD_REGNO_P (regno) && TARGET_SPE && SPE_VECTOR_MODE (mode))
1056     return 1;
1057
1058   /* We cannot put TImode anywhere except general register and it must be
1059      able to fit within the register set.  */
1060
1061   return GET_MODE_SIZE (mode) <= UNITS_PER_WORD;
1062 }
1063
1064 /* Initialize rs6000_hard_regno_mode_ok_p table.  */
1065 static void
1066 rs6000_init_hard_regno_mode_ok (void)
1067 {
1068   int r, m;
1069
1070   for (r = 0; r < FIRST_PSEUDO_REGISTER; ++r)
1071     for (m = 0; m < NUM_MACHINE_MODES; ++m)
1072       if (rs6000_hard_regno_mode_ok (r, m))
1073         rs6000_hard_regno_mode_ok_p[m][r] = true;
1074 }
1075
1076 /* If not otherwise specified by a target, make 'long double' equivalent to
1077    'double'.  */
1078
1079 #ifndef RS6000_DEFAULT_LONG_DOUBLE_SIZE
1080 #define RS6000_DEFAULT_LONG_DOUBLE_SIZE 64
1081 #endif
1082
1083 /* Override command line options.  Mostly we process the processor
1084    type and sometimes adjust other TARGET_ options.  */
1085
1086 void
1087 rs6000_override_options (const char *default_cpu)
1088 {
1089   size_t i, j;
1090   struct rs6000_cpu_select *ptr;
1091   int set_masks;
1092
1093   /* Simplifications for entries below.  */
1094
1095   enum {
1096     POWERPC_BASE_MASK = MASK_POWERPC | MASK_NEW_MNEMONICS,
1097     POWERPC_7400_MASK = POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_ALTIVEC
1098   };
1099
1100   /* This table occasionally claims that a processor does not support
1101      a particular feature even though it does, but the feature is slower
1102      than the alternative.  Thus, it shouldn't be relied on as a
1103      complete description of the processor's support.
1104
1105      Please keep this list in order, and don't forget to update the
1106      documentation in invoke.texi when adding a new processor or
1107      flag.  */
1108   static struct ptt
1109     {
1110       const char *const name;           /* Canonical processor name.  */
1111       const enum processor_type processor; /* Processor type enum value.  */
1112       const int target_enable;  /* Target flags to enable.  */
1113     } const processor_target_table[]
1114       = {{"401", PROCESSOR_PPC403, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1115          {"403", PROCESSOR_PPC403,
1116           POWERPC_BASE_MASK | MASK_SOFT_FLOAT | MASK_STRICT_ALIGN},
1117          {"405", PROCESSOR_PPC405, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1118          {"405fp", PROCESSOR_PPC405, POWERPC_BASE_MASK},
1119          {"440", PROCESSOR_PPC440, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1120          {"440fp", PROCESSOR_PPC440, POWERPC_BASE_MASK},
1121          {"505", PROCESSOR_MPCCORE, POWERPC_BASE_MASK},
1122          {"601", PROCESSOR_PPC601,
1123           MASK_POWER | POWERPC_BASE_MASK | MASK_MULTIPLE | MASK_STRING},
1124          {"602", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1125          {"603", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1126          {"603e", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1127          {"604", PROCESSOR_PPC604, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1128          {"604e", PROCESSOR_PPC604e, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1129          {"620", PROCESSOR_PPC620,
1130           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
1131          {"630", PROCESSOR_PPC630,
1132           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
1133          {"740", PROCESSOR_PPC750, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1134          {"7400", PROCESSOR_PPC7400, POWERPC_7400_MASK},
1135          {"7450", PROCESSOR_PPC7450, POWERPC_7400_MASK},
1136          {"750", PROCESSOR_PPC750, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1137          {"801", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1138          {"821", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1139          {"823", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1140          {"8540", PROCESSOR_PPC8540, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1141          /* 8548 has a dummy entry for now.  */
1142          {"8548", PROCESSOR_PPC8540, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1143          {"860", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1144          {"970", PROCESSOR_POWER4,
1145           POWERPC_7400_MASK | MASK_PPC_GPOPT | MASK_MFCRF | MASK_POWERPC64},
1146          {"common", PROCESSOR_COMMON, MASK_NEW_MNEMONICS},
1147          {"ec603e", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
1148          {"G3", PROCESSOR_PPC750, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
1149          {"G4",  PROCESSOR_PPC7450, POWERPC_7400_MASK},
1150          {"G5", PROCESSOR_POWER4,
1151           POWERPC_7400_MASK | MASK_PPC_GPOPT | MASK_MFCRF | MASK_POWERPC64},
1152          {"power", PROCESSOR_POWER, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
1153          {"power2", PROCESSOR_POWER,
1154           MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING},
1155          {"power3", PROCESSOR_PPC630,
1156           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
1157          {"power4", PROCESSOR_POWER4,
1158           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_MFCRF | MASK_POWERPC64},
1159          {"power5", PROCESSOR_POWER5,
1160           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_MFCRF | MASK_POWERPC64},
1161          {"powerpc", PROCESSOR_POWERPC, POWERPC_BASE_MASK},
1162          {"powerpc64", PROCESSOR_POWERPC64,
1163           POWERPC_BASE_MASK | MASK_POWERPC64},
1164          {"rios", PROCESSOR_RIOS1, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
1165          {"rios1", PROCESSOR_RIOS1, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
1166          {"rios2", PROCESSOR_RIOS2,
1167           MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING},
1168          {"rsc", PROCESSOR_PPC601, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
1169          {"rsc1", PROCESSOR_PPC601, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
1170          {"rs64a", PROCESSOR_RS64A, POWERPC_BASE_MASK | MASK_POWERPC64},
1171       };
1172
1173   const size_t ptt_size = ARRAY_SIZE (processor_target_table);
1174
1175   /* Some OSs don't support saving the high part of 64-bit registers on
1176      context switch.  Other OSs don't support saving Altivec registers.
1177      On those OSs, we don't touch the MASK_POWERPC64 or MASK_ALTIVEC
1178      settings; if the user wants either, the user must explicitly specify
1179      them and we won't interfere with the user's specification.  */
1180
1181   enum {
1182     POWER_MASKS = MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING,
1183     POWERPC_MASKS = (POWERPC_BASE_MASK | MASK_PPC_GPOPT
1184                      | MASK_PPC_GFXOPT | MASK_POWERPC64 | MASK_ALTIVEC
1185                      | MASK_MFCRF)
1186   };
1187
1188   rs6000_init_hard_regno_mode_ok ();
1189
1190   set_masks = POWER_MASKS | POWERPC_MASKS | MASK_SOFT_FLOAT;
1191 #ifdef OS_MISSING_POWERPC64
1192   if (OS_MISSING_POWERPC64)
1193     set_masks &= ~MASK_POWERPC64;
1194 #endif
1195 #ifdef OS_MISSING_ALTIVEC
1196   if (OS_MISSING_ALTIVEC)
1197     set_masks &= ~MASK_ALTIVEC;
1198 #endif
1199
1200   /* Don't override by the processor default if given explicitly.  */
1201   set_masks &= ~target_flags_explicit;
1202
1203   /* Identify the processor type.  */
1204   rs6000_select[0].string = default_cpu;
1205   rs6000_cpu = TARGET_POWERPC64 ? PROCESSOR_DEFAULT64 : PROCESSOR_DEFAULT;
1206
1207   for (i = 0; i < ARRAY_SIZE (rs6000_select); i++)
1208     {
1209       ptr = &rs6000_select[i];
1210       if (ptr->string != (char *)0 && ptr->string[0] != '\0')
1211         {
1212           for (j = 0; j < ptt_size; j++)
1213             if (! strcmp (ptr->string, processor_target_table[j].name))
1214               {
1215                 if (ptr->set_tune_p)
1216                   rs6000_cpu = processor_target_table[j].processor;
1217
1218                 if (ptr->set_arch_p)
1219                   {
1220                     target_flags &= ~set_masks;
1221                     target_flags |= (processor_target_table[j].target_enable
1222                                      & set_masks);
1223                   }
1224                 break;
1225               }
1226
1227           if (j == ptt_size)
1228             error ("bad value (%s) for %s switch", ptr->string, ptr->name);
1229         }
1230     }
1231
1232   if (TARGET_E500)
1233     rs6000_isel = 1;
1234
1235   /* If we are optimizing big endian systems for space, use the load/store
1236      multiple and string instructions.  */
1237   if (BYTES_BIG_ENDIAN && optimize_size)
1238     target_flags |= ~target_flags_explicit & (MASK_MULTIPLE | MASK_STRING);
1239
1240   /* Don't allow -mmultiple or -mstring on little endian systems
1241      unless the cpu is a 750, because the hardware doesn't support the
1242      instructions used in little endian mode, and causes an alignment
1243      trap.  The 750 does not cause an alignment trap (except when the
1244      target is unaligned).  */
1245
1246   if (!BYTES_BIG_ENDIAN && rs6000_cpu != PROCESSOR_PPC750)
1247     {
1248       if (TARGET_MULTIPLE)
1249         {
1250           target_flags &= ~MASK_MULTIPLE;
1251           if ((target_flags_explicit & MASK_MULTIPLE) != 0)
1252             warning ("-mmultiple is not supported on little endian systems");
1253         }
1254
1255       if (TARGET_STRING)
1256         {
1257           target_flags &= ~MASK_STRING;
1258           if ((target_flags_explicit & MASK_STRING) != 0)
1259             warning ("-mstring is not supported on little endian systems");
1260         }
1261     }
1262
1263   /* Set debug flags */
1264   if (rs6000_debug_name)
1265     {
1266       if (! strcmp (rs6000_debug_name, "all"))
1267         rs6000_debug_stack = rs6000_debug_arg = 1;
1268       else if (! strcmp (rs6000_debug_name, "stack"))
1269         rs6000_debug_stack = 1;
1270       else if (! strcmp (rs6000_debug_name, "arg"))
1271         rs6000_debug_arg = 1;
1272       else
1273         error ("unknown -mdebug-%s switch", rs6000_debug_name);
1274     }
1275
1276   if (rs6000_traceback_name)
1277     {
1278       if (! strncmp (rs6000_traceback_name, "full", 4))
1279         rs6000_traceback = traceback_full;
1280       else if (! strncmp (rs6000_traceback_name, "part", 4))
1281         rs6000_traceback = traceback_part;
1282       else if (! strncmp (rs6000_traceback_name, "no", 2))
1283         rs6000_traceback = traceback_none;
1284       else
1285         error ("unknown -mtraceback arg %qs; expecting %<full%>, %<partial%> or %<none%>",
1286                rs6000_traceback_name);
1287     }
1288
1289   /* Set size of long double */
1290   rs6000_long_double_type_size = RS6000_DEFAULT_LONG_DOUBLE_SIZE;
1291   if (rs6000_long_double_size_string)
1292     {
1293       char *tail;
1294       int size = strtol (rs6000_long_double_size_string, &tail, 10);
1295       if (*tail != '\0' || (size != 64 && size != 128))
1296         error ("Unknown switch -mlong-double-%s",
1297                rs6000_long_double_size_string);
1298       else
1299         rs6000_long_double_type_size = size;
1300     }
1301
1302   /* Set Altivec ABI as default for powerpc64 linux.  */
1303   if (TARGET_ELF && TARGET_64BIT)
1304     {
1305       rs6000_altivec_abi = 1;
1306       rs6000_altivec_vrsave = 1;
1307     }
1308
1309   /* Set the Darwin64 ABI as default for 64-bit Darwin.  */
1310   if (DEFAULT_ABI == ABI_DARWIN && TARGET_64BIT)
1311     {
1312       rs6000_darwin64_abi = 1;
1313       /* Setting to empty string is same as "-mone-byte-bool".  */
1314 #if TARGET_MACHO
1315       darwin_one_byte_bool = "";
1316 #endif
1317       /* Default to natural alignment, for better performance.  */
1318       rs6000_alignment_flags = MASK_ALIGN_NATURAL;
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     {
1688       /* On 64-bit Darwin, power alignment is ABI-incompatible with
1689          some C library functions, so warn about it. The flag may be
1690          useful for performance studies from time to time though, so
1691          don't disable it entirely.  */
1692       if (DEFAULT_ABI == ABI_DARWIN && TARGET_64BIT)
1693         warning ("-malign-power is not supported for 64-bit Darwin;"
1694                  " it is incompatible with the installed C and C++ libraries");
1695       rs6000_alignment_flags = MASK_ALIGN_POWER;
1696     }
1697   else if (! strcmp (rs6000_alignment_string, "natural"))
1698     rs6000_alignment_flags = MASK_ALIGN_NATURAL;
1699   else
1700     error ("unknown -malign-XXXXX option specified: '%s'",
1701            rs6000_alignment_string);
1702 }
1703
1704 /* Validate and record the size specified with the -mtls-size option.  */
1705
1706 static void
1707 rs6000_parse_tls_size_option (void)
1708 {
1709   if (rs6000_tls_size_string == 0)
1710     return;
1711   else if (strcmp (rs6000_tls_size_string, "16") == 0)
1712     rs6000_tls_size = 16;
1713   else if (strcmp (rs6000_tls_size_string, "32") == 0)
1714     rs6000_tls_size = 32;
1715   else if (strcmp (rs6000_tls_size_string, "64") == 0)
1716     rs6000_tls_size = 64;
1717   else
1718     error ("bad value %qs for -mtls-size switch", rs6000_tls_size_string);
1719 }
1720
1721 void
1722 optimization_options (int level ATTRIBUTE_UNUSED, int size ATTRIBUTE_UNUSED)
1723 {
1724 }
1725 \f
1726 /* Do anything needed at the start of the asm file.  */
1727
1728 static void
1729 rs6000_file_start (void)
1730 {
1731   size_t i;
1732   char buffer[80];
1733   const char *start = buffer;
1734   struct rs6000_cpu_select *ptr;
1735   const char *default_cpu = TARGET_CPU_DEFAULT;
1736   FILE *file = asm_out_file;
1737
1738   default_file_start ();
1739
1740 #ifdef TARGET_BI_ARCH
1741   if ((TARGET_DEFAULT ^ target_flags) & MASK_64BIT)
1742     default_cpu = 0;
1743 #endif
1744
1745   if (flag_verbose_asm)
1746     {
1747       sprintf (buffer, "\n%s rs6000/powerpc options:", ASM_COMMENT_START);
1748       rs6000_select[0].string = default_cpu;
1749
1750       for (i = 0; i < ARRAY_SIZE (rs6000_select); i++)
1751         {
1752           ptr = &rs6000_select[i];
1753           if (ptr->string != (char *)0 && ptr->string[0] != '\0')
1754             {
1755               fprintf (file, "%s %s%s", start, ptr->name, ptr->string);
1756               start = "";
1757             }
1758         }
1759
1760 #ifdef USING_ELFOS_H
1761       switch (rs6000_sdata)
1762         {
1763         case SDATA_NONE: fprintf (file, "%s -msdata=none", start); start = ""; break;
1764         case SDATA_DATA: fprintf (file, "%s -msdata=data", start); start = ""; break;
1765         case SDATA_SYSV: fprintf (file, "%s -msdata=sysv", start); start = ""; break;
1766         case SDATA_EABI: fprintf (file, "%s -msdata=eabi", start); start = ""; break;
1767         }
1768
1769       if (rs6000_sdata && g_switch_value)
1770         {
1771           fprintf (file, "%s -G " HOST_WIDE_INT_PRINT_UNSIGNED, start,
1772                    g_switch_value);
1773           start = "";
1774         }
1775 #endif
1776
1777       if (*start == '\0')
1778         putc ('\n', file);
1779     }
1780
1781   if (DEFAULT_ABI == ABI_AIX || (TARGET_ELF && flag_pic == 2))
1782     {
1783       toc_section ();
1784       text_section ();
1785     }
1786 }
1787
1788 \f
1789 /* Return nonzero if this function is known to have a null epilogue.  */
1790
1791 int
1792 direct_return (void)
1793 {
1794   if (reload_completed)
1795     {
1796       rs6000_stack_t *info = rs6000_stack_info ();
1797
1798       if (info->first_gp_reg_save == 32
1799           && info->first_fp_reg_save == 64
1800           && info->first_altivec_reg_save == LAST_ALTIVEC_REGNO + 1
1801           && ! info->lr_save_p
1802           && ! info->cr_save_p
1803           && info->vrsave_mask == 0
1804           && ! info->push_p)
1805         return 1;
1806     }
1807
1808   return 0;
1809 }
1810
1811 /* Return the number of instructions it takes to form a constant in an
1812    integer register.  */
1813
1814 int
1815 num_insns_constant_wide (HOST_WIDE_INT value)
1816 {
1817   /* signed constant loadable with {cal|addi} */
1818   if (CONST_OK_FOR_LETTER_P (value, 'I'))
1819     return 1;
1820
1821   /* constant loadable with {cau|addis} */
1822   else if (CONST_OK_FOR_LETTER_P (value, 'L'))
1823     return 1;
1824
1825 #if HOST_BITS_PER_WIDE_INT == 64
1826   else if (TARGET_POWERPC64)
1827     {
1828       HOST_WIDE_INT low  = ((value & 0xffffffff) ^ 0x80000000) - 0x80000000;
1829       HOST_WIDE_INT high = value >> 31;
1830
1831       if (high == 0 || high == -1)
1832         return 2;
1833
1834       high >>= 1;
1835
1836       if (low == 0)
1837         return num_insns_constant_wide (high) + 1;
1838       else
1839         return (num_insns_constant_wide (high)
1840                 + num_insns_constant_wide (low) + 1);
1841     }
1842 #endif
1843
1844   else
1845     return 2;
1846 }
1847
1848 int
1849 num_insns_constant (rtx op, enum machine_mode mode)
1850 {
1851   if (GET_CODE (op) == CONST_INT)
1852     {
1853 #if HOST_BITS_PER_WIDE_INT == 64
1854       if ((INTVAL (op) >> 31) != 0 && (INTVAL (op) >> 31) != -1
1855           && mask64_operand (op, mode))
1856         return 2;
1857       else
1858 #endif
1859         return num_insns_constant_wide (INTVAL (op));
1860     }
1861
1862   else if (GET_CODE (op) == CONST_DOUBLE && mode == SFmode)
1863     {
1864       long l;
1865       REAL_VALUE_TYPE rv;
1866
1867       REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
1868       REAL_VALUE_TO_TARGET_SINGLE (rv, l);
1869       return num_insns_constant_wide ((HOST_WIDE_INT) l);
1870     }
1871
1872   else if (GET_CODE (op) == CONST_DOUBLE)
1873     {
1874       HOST_WIDE_INT low;
1875       HOST_WIDE_INT high;
1876       long l[2];
1877       REAL_VALUE_TYPE rv;
1878       int endian = (WORDS_BIG_ENDIAN == 0);
1879
1880       if (mode == VOIDmode || mode == DImode)
1881         {
1882           high = CONST_DOUBLE_HIGH (op);
1883           low  = CONST_DOUBLE_LOW (op);
1884         }
1885       else
1886         {
1887           REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
1888           REAL_VALUE_TO_TARGET_DOUBLE (rv, l);
1889           high = l[endian];
1890           low  = l[1 - endian];
1891         }
1892
1893       if (TARGET_32BIT)
1894         return (num_insns_constant_wide (low)
1895                 + num_insns_constant_wide (high));
1896
1897       else
1898         {
1899           if (high == 0 && low >= 0)
1900             return num_insns_constant_wide (low);
1901
1902           else if (high == -1 && low < 0)
1903             return num_insns_constant_wide (low);
1904
1905           else if (mask64_operand (op, mode))
1906             return 2;
1907
1908           else if (low == 0)
1909             return num_insns_constant_wide (high) + 1;
1910
1911           else
1912             return (num_insns_constant_wide (high)
1913                     + num_insns_constant_wide (low) + 1);
1914         }
1915     }
1916
1917   else
1918     abort ();
1919 }
1920
1921 /* Returns the constant for the splat instruction, if exists.  */
1922
1923 int
1924 easy_vector_splat_const (int cst, enum machine_mode mode)
1925 {
1926   switch (mode)
1927     {
1928     case V4SImode:
1929       if (EASY_VECTOR_15 (cst)
1930           || EASY_VECTOR_15_ADD_SELF (cst))
1931         return cst;
1932       if ((cst & 0xffff) != ((cst >> 16) & 0xffff))
1933         break;
1934       cst = cst >> 16;
1935       /* Fall thru */
1936
1937     case V8HImode:
1938       if (EASY_VECTOR_15 (cst)
1939           || EASY_VECTOR_15_ADD_SELF (cst))
1940         return cst;
1941       if ((cst & 0xff) != ((cst >> 8) & 0xff))
1942         break;
1943       cst = cst >> 8;
1944       /* Fall thru */
1945
1946     case V16QImode:
1947       if (EASY_VECTOR_15 (cst)
1948           || EASY_VECTOR_15_ADD_SELF (cst))
1949         return cst;
1950     default:
1951       break;
1952     }
1953   return 0;
1954 }
1955
1956 /* Return nonzero if all elements of a vector have the same value.  */
1957
1958 int
1959 easy_vector_same (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1960 {
1961   int units, i, cst;
1962
1963   units = CONST_VECTOR_NUNITS (op);
1964
1965   cst = INTVAL (CONST_VECTOR_ELT (op, 0));
1966   for (i = 1; i < units; ++i)
1967     if (INTVAL (CONST_VECTOR_ELT (op, i)) != cst)
1968       break;
1969   if (i == units && easy_vector_splat_const (cst, mode))
1970     return 1;
1971   return 0;
1972 }
1973
1974 /* Generate easy_vector_constant out of a easy_vector_constant_add_self.  */
1975
1976 rtx
1977 gen_easy_vector_constant_add_self (rtx op)
1978 {
1979   int i, units;
1980   rtvec v;
1981   units = GET_MODE_NUNITS (GET_MODE (op));
1982   v = rtvec_alloc (units);
1983
1984   for (i = 0; i < units; i++)
1985     RTVEC_ELT (v, i) =
1986       GEN_INT (INTVAL (CONST_VECTOR_ELT (op, i)) >> 1);
1987   return gen_rtx_raw_CONST_VECTOR (GET_MODE (op), v);
1988 }
1989
1990 const char *
1991 output_vec_const_move (rtx *operands)
1992 {
1993   int cst, cst2;
1994   enum machine_mode mode;
1995   rtx dest, vec;
1996
1997   dest = operands[0];
1998   vec = operands[1];
1999
2000   cst = INTVAL (CONST_VECTOR_ELT (vec, 0));
2001   cst2 = INTVAL (CONST_VECTOR_ELT (vec, 1));
2002   mode = GET_MODE (dest);
2003
2004   if (TARGET_ALTIVEC)
2005     {
2006       if (zero_constant (vec, mode))
2007         return "vxor %0,%0,%0";
2008       else if (easy_vector_constant (vec, mode))
2009         {
2010           operands[1] = GEN_INT (cst);
2011           switch (mode)
2012             {
2013             case V4SImode:
2014               if (EASY_VECTOR_15 (cst))
2015                 {
2016                   operands[1] = GEN_INT (cst);
2017                   return "vspltisw %0,%1";
2018                 }
2019               else if (EASY_VECTOR_15_ADD_SELF (cst))
2020                 return "#";
2021               cst = cst >> 16;
2022               /* Fall thru */
2023
2024             case V8HImode:
2025               if (EASY_VECTOR_15 (cst))
2026                 {
2027                   operands[1] = GEN_INT (cst);
2028                   return "vspltish %0,%1";
2029                 }
2030               else if (EASY_VECTOR_15_ADD_SELF (cst))
2031                 return "#";
2032               cst = cst >> 8;
2033               /* Fall thru */
2034
2035             case V16QImode:
2036               if (EASY_VECTOR_15 (cst))
2037                 {
2038                   operands[1] = GEN_INT (cst);
2039                   return "vspltisb %0,%1";
2040                 }
2041               else if (EASY_VECTOR_15_ADD_SELF (cst))
2042                 return "#";
2043
2044             default:
2045               abort ();
2046             }
2047         }
2048       else
2049         abort ();
2050     }
2051
2052   if (TARGET_SPE)
2053     {
2054       /* Vector constant 0 is handled as a splitter of V2SI, and in the
2055          pattern of V1DI, V4HI, and V2SF.
2056
2057          FIXME: We should probably return # and add post reload
2058          splitters for these, but this way is so easy ;-).  */
2059       operands[1] = GEN_INT (cst);
2060       operands[2] = GEN_INT (cst2);
2061       if (cst == cst2)
2062         return "li %0,%1\n\tevmergelo %0,%0,%0";
2063       else
2064         return "li %0,%1\n\tevmergelo %0,%0,%0\n\tli %0,%2";
2065     }
2066
2067   abort ();
2068 }
2069
2070 int
2071 mask64_1or2_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED,
2072                        bool allow_one)
2073 {
2074   if (GET_CODE (op) == CONST_INT)
2075     {
2076       HOST_WIDE_INT c, lsb;
2077       bool one_ok;
2078       
2079       c = INTVAL (op);
2080
2081       /* Disallow all zeros.  */
2082       if (c == 0)
2083         return 0;
2084
2085       /* We can use a single rlwinm insn if no upper bits of C are set
2086          AND there are zero, one or two transitions in the _whole_ of
2087          C.  */
2088       one_ok = !(c & ~(HOST_WIDE_INT)0xffffffff);
2089       
2090       /* We don't change the number of transitions by inverting,
2091          so make sure we start with the LS bit zero.  */
2092       if (c & 1)
2093         c = ~c;
2094
2095       /* Find the first transition.  */
2096       lsb = c & -c;
2097
2098       /* Invert to look for a second transition.  */
2099       c = ~c;
2100
2101       /* Erase first transition.  */
2102       c &= -lsb;
2103
2104       /* Find the second transition.  */
2105       lsb = c & -c;
2106
2107       /* Invert to look for a third transition.  */
2108       c = ~c;
2109
2110       /* Erase second transition.  */
2111       c &= -lsb;
2112
2113       if (one_ok && !(allow_one || c))
2114         return 0;
2115
2116       /* Find the third transition (if any).  */
2117       lsb = c & -c;
2118
2119       /* Match if all the bits above are 1's (or c is zero).  */
2120       return c == -lsb;
2121     }
2122   return 0;
2123 }
2124
2125 /* Generates shifts and masks for a pair of rldicl or rldicr insns to
2126    implement ANDing by the mask IN.  */
2127 void
2128 build_mask64_2_operands (rtx in, rtx *out)
2129 {
2130 #if HOST_BITS_PER_WIDE_INT >= 64
2131   unsigned HOST_WIDE_INT c, lsb, m1, m2;
2132   int shift;
2133
2134   if (GET_CODE (in) != CONST_INT)
2135     abort ();
2136
2137   c = INTVAL (in);
2138   if (c & 1)
2139     {
2140       /* Assume c initially something like 0x00fff000000fffff.  The idea
2141          is to rotate the word so that the middle ^^^^^^ group of zeros
2142          is at the MS end and can be cleared with an rldicl mask.  We then
2143          rotate back and clear off the MS    ^^ group of zeros with a
2144          second rldicl.  */
2145       c = ~c;                   /*   c == 0xff000ffffff00000 */
2146       lsb = c & -c;             /* lsb == 0x0000000000100000 */
2147       m1 = -lsb;                /*  m1 == 0xfffffffffff00000 */
2148       c = ~c;                   /*   c == 0x00fff000000fffff */
2149       c &= -lsb;                /*   c == 0x00fff00000000000 */
2150       lsb = c & -c;             /* lsb == 0x0000100000000000 */
2151       c = ~c;                   /*   c == 0xff000fffffffffff */
2152       c &= -lsb;                /*   c == 0xff00000000000000 */
2153       shift = 0;
2154       while ((lsb >>= 1) != 0)
2155         shift++;                /* shift == 44 on exit from loop */
2156       m1 <<= 64 - shift;        /*  m1 == 0xffffff0000000000 */
2157       m1 = ~m1;                 /*  m1 == 0x000000ffffffffff */
2158       m2 = ~c;                  /*  m2 == 0x00ffffffffffffff */
2159     }
2160   else
2161     {
2162       /* Assume c initially something like 0xff000f0000000000.  The idea
2163          is to rotate the word so that the     ^^^  middle group of zeros
2164          is at the LS end and can be cleared with an rldicr mask.  We then
2165          rotate back and clear off the LS group of ^^^^^^^^^^ zeros with
2166          a second rldicr.  */
2167       lsb = c & -c;             /* lsb == 0x0000010000000000 */
2168       m2 = -lsb;                /*  m2 == 0xffffff0000000000 */
2169       c = ~c;                   /*   c == 0x00fff0ffffffffff */
2170       c &= -lsb;                /*   c == 0x00fff00000000000 */
2171       lsb = c & -c;             /* lsb == 0x0000100000000000 */
2172       c = ~c;                   /*   c == 0xff000fffffffffff */
2173       c &= -lsb;                /*   c == 0xff00000000000000 */
2174       shift = 0;
2175       while ((lsb >>= 1) != 0)
2176         shift++;                /* shift == 44 on exit from loop */
2177       m1 = ~c;                  /*  m1 == 0x00ffffffffffffff */
2178       m1 >>= shift;             /*  m1 == 0x0000000000000fff */
2179       m1 = ~m1;                 /*  m1 == 0xfffffffffffff000 */
2180     }
2181
2182   /* Note that when we only have two 0->1 and 1->0 transitions, one of the
2183      masks will be all 1's.  We are guaranteed more than one transition.  */
2184   out[0] = GEN_INT (64 - shift);
2185   out[1] = GEN_INT (m1);
2186   out[2] = GEN_INT (shift);
2187   out[3] = GEN_INT (m2);
2188 #else
2189   (void)in;
2190   (void)out;
2191   abort ();
2192 #endif
2193 }
2194
2195 /* Return TRUE if OP is an invalid SUBREG operation on the e500.  */
2196
2197 bool
2198 invalid_e500_subreg (rtx op, enum machine_mode mode)
2199 {
2200   /* Reject (subreg:SI (reg:DF)).  */
2201   if (GET_CODE (op) == SUBREG
2202       && mode == SImode
2203       && REG_P (SUBREG_REG (op))
2204       && GET_MODE (SUBREG_REG (op)) == DFmode)
2205     return true;
2206
2207   /* Reject (subreg:DF (reg:DI)).  */
2208   if (GET_CODE (op) == SUBREG
2209       && mode == DFmode
2210       && REG_P (SUBREG_REG (op))
2211       && GET_MODE (SUBREG_REG (op)) == DImode)
2212     return true;
2213
2214   return false;
2215 }
2216
2217 /* Darwin, AIX increases natural record alignment to doubleword if the first
2218    field is an FP double while the FP fields remain word aligned.  */
2219
2220 unsigned int
2221 rs6000_special_round_type_align (tree type, int computed, int specified)
2222 {
2223   tree field = TYPE_FIELDS (type);
2224
2225   /* Skip all non field decls */ 
2226   while (field != NULL && TREE_CODE (field) != FIELD_DECL)
2227     field = TREE_CHAIN (field);
2228
2229   if (field == NULL || field == type || DECL_MODE (field) != DFmode)
2230     return MAX (computed, specified);
2231
2232   return MAX (MAX (computed, specified), 64);
2233 }
2234
2235 /* Return 1 for an operand in small memory on V.4/eabi.  */
2236
2237 int
2238 small_data_operand (rtx op ATTRIBUTE_UNUSED,
2239                     enum machine_mode mode ATTRIBUTE_UNUSED)
2240 {
2241 #if TARGET_ELF
2242   rtx sym_ref;
2243
2244   if (rs6000_sdata == SDATA_NONE || rs6000_sdata == SDATA_DATA)
2245     return 0;
2246
2247   if (DEFAULT_ABI != ABI_V4)
2248     return 0;
2249
2250   if (GET_CODE (op) == SYMBOL_REF)
2251     sym_ref = op;
2252
2253   else if (GET_CODE (op) != CONST
2254            || GET_CODE (XEXP (op, 0)) != PLUS
2255            || GET_CODE (XEXP (XEXP (op, 0), 0)) != SYMBOL_REF
2256            || GET_CODE (XEXP (XEXP (op, 0), 1)) != CONST_INT)
2257     return 0;
2258
2259   else
2260     {
2261       rtx sum = XEXP (op, 0);
2262       HOST_WIDE_INT summand;
2263
2264       /* We have to be careful here, because it is the referenced address
2265          that must be 32k from _SDA_BASE_, not just the symbol.  */
2266       summand = INTVAL (XEXP (sum, 1));
2267       if (summand < 0 || (unsigned HOST_WIDE_INT) summand > g_switch_value)
2268         return 0;
2269
2270       sym_ref = XEXP (sum, 0);
2271     }
2272
2273   return SYMBOL_REF_SMALL_P (sym_ref);
2274 #else
2275   return 0;
2276 #endif
2277 }
2278
2279 /* Return true if either operand is a general purpose register.  */
2280
2281 bool
2282 gpr_or_gpr_p (rtx op0, rtx op1)
2283 {
2284   return ((REG_P (op0) && INT_REGNO_P (REGNO (op0)))
2285           || (REG_P (op1) && INT_REGNO_P (REGNO (op1))));
2286 }
2287
2288 \f
2289 /* Subroutines of rs6000_legitimize_address and rs6000_legitimate_address.  */
2290
2291 static int
2292 constant_pool_expr_1 (rtx op, int *have_sym, int *have_toc)
2293 {
2294   switch (GET_CODE (op))
2295     {
2296     case SYMBOL_REF:
2297       if (RS6000_SYMBOL_REF_TLS_P (op))
2298         return 0;
2299       else if (CONSTANT_POOL_ADDRESS_P (op))
2300         {
2301           if (ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (get_pool_constant (op), Pmode))
2302             {
2303               *have_sym = 1;
2304               return 1;
2305             }
2306           else
2307             return 0;
2308         }
2309       else if (! strcmp (XSTR (op, 0), toc_label_name))
2310         {
2311           *have_toc = 1;
2312           return 1;
2313         }
2314       else
2315         return 0;
2316     case PLUS:
2317     case MINUS:
2318       return (constant_pool_expr_1 (XEXP (op, 0), have_sym, have_toc)
2319               && constant_pool_expr_1 (XEXP (op, 1), have_sym, have_toc));
2320     case CONST:
2321       return constant_pool_expr_1 (XEXP (op, 0), have_sym, have_toc);
2322     case CONST_INT:
2323       return 1;
2324     default:
2325       return 0;
2326     }
2327 }
2328
2329 static bool
2330 constant_pool_expr_p (rtx op)
2331 {
2332   int have_sym = 0;
2333   int have_toc = 0;
2334   return constant_pool_expr_1 (op, &have_sym, &have_toc) && have_sym;
2335 }
2336
2337 bool
2338 toc_relative_expr_p (rtx op)
2339 {
2340   int have_sym = 0;
2341   int have_toc = 0;
2342   return constant_pool_expr_1 (op, &have_sym, &have_toc) && have_toc;
2343 }
2344
2345 bool
2346 legitimate_constant_pool_address_p (rtx x)
2347 {
2348   return (TARGET_TOC
2349           && GET_CODE (x) == PLUS
2350           && GET_CODE (XEXP (x, 0)) == REG
2351           && (TARGET_MINIMAL_TOC || REGNO (XEXP (x, 0)) == TOC_REGISTER)
2352           && constant_pool_expr_p (XEXP (x, 1)));
2353 }
2354
2355 static bool
2356 legitimate_small_data_p (enum machine_mode mode, rtx x)
2357 {
2358   return (DEFAULT_ABI == ABI_V4
2359           && !flag_pic && !TARGET_TOC
2360           && (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == CONST)
2361           && small_data_operand (x, mode));
2362 }
2363
2364 /* SPE offset addressing is limited to 5-bits worth of double words.  */
2365 #define SPE_CONST_OFFSET_OK(x) (((x) & ~0xf8) == 0)
2366
2367 bool
2368 rs6000_legitimate_offset_address_p (enum machine_mode mode, rtx x, int strict)
2369 {
2370   unsigned HOST_WIDE_INT offset, extra;
2371
2372   if (GET_CODE (x) != PLUS)
2373     return false;
2374   if (GET_CODE (XEXP (x, 0)) != REG)
2375     return false;
2376   if (!INT_REG_OK_FOR_BASE_P (XEXP (x, 0), strict))
2377     return false;
2378   if (legitimate_constant_pool_address_p (x))
2379     return true;
2380   if (GET_CODE (XEXP (x, 1)) != CONST_INT)
2381     return false;
2382
2383   offset = INTVAL (XEXP (x, 1));
2384   extra = 0;
2385   switch (mode)
2386     {
2387     case V16QImode:
2388     case V8HImode:
2389     case V4SFmode:
2390     case V4SImode:
2391       /* AltiVec vector modes.  Only reg+reg addressing is valid here,
2392          which leaves the only valid constant offset of zero, which by
2393          canonicalization rules is also invalid.  */
2394       return false;
2395
2396     case V4HImode:
2397     case V2SImode:
2398     case V1DImode:
2399     case V2SFmode:
2400       /* SPE vector modes.  */
2401       return SPE_CONST_OFFSET_OK (offset);
2402
2403     case DFmode:
2404       if (TARGET_E500_DOUBLE)
2405         return SPE_CONST_OFFSET_OK (offset);
2406
2407     case DImode:
2408       /* On e500v2, we may have:
2409
2410            (subreg:DF (mem:DI (plus (reg) (const_int))) 0).
2411
2412          Which gets addressed with evldd instructions.  */
2413       if (TARGET_E500_DOUBLE)
2414         return SPE_CONST_OFFSET_OK (offset);
2415
2416       if (mode == DFmode || !TARGET_POWERPC64)
2417         extra = 4;
2418       else if (offset & 3)
2419         return false;
2420       break;
2421
2422     case TFmode:
2423     case TImode:
2424       if (mode == TFmode || !TARGET_POWERPC64)
2425         extra = 12;
2426       else if (offset & 3)
2427         return false;
2428       else
2429         extra = 8;
2430       break;
2431
2432     default:
2433       break;
2434     }
2435
2436   offset += 0x8000;
2437   return (offset < 0x10000) && (offset + extra < 0x10000);
2438 }
2439
2440 static bool
2441 legitimate_indexed_address_p (rtx x, int strict)
2442 {
2443   rtx op0, op1;
2444
2445   if (GET_CODE (x) != PLUS)
2446     return false;
2447
2448   op0 = XEXP (x, 0);
2449   op1 = XEXP (x, 1);
2450
2451   if (!REG_P (op0) || !REG_P (op1))
2452     return false;
2453
2454   return ((INT_REG_OK_FOR_BASE_P (op0, strict)
2455            && INT_REG_OK_FOR_INDEX_P (op1, strict))
2456           || (INT_REG_OK_FOR_BASE_P (op1, strict)
2457               && INT_REG_OK_FOR_INDEX_P (op0, strict)));
2458 }
2459
2460 inline bool
2461 legitimate_indirect_address_p (rtx x, int strict)
2462 {
2463   return GET_CODE (x) == REG && INT_REG_OK_FOR_BASE_P (x, strict);
2464 }
2465
2466 bool
2467 macho_lo_sum_memory_operand (rtx x, enum machine_mode mode)
2468 {
2469   if (!TARGET_MACHO || !flag_pic
2470       || mode != SImode || GET_CODE (x) != MEM)
2471     return false;
2472   x = XEXP (x, 0);
2473
2474   if (GET_CODE (x) != LO_SUM)
2475     return false;
2476   if (GET_CODE (XEXP (x, 0)) != REG)
2477     return false;
2478   if (!INT_REG_OK_FOR_BASE_P (XEXP (x, 0), 0))
2479     return false;
2480   x = XEXP (x, 1);
2481
2482   return CONSTANT_P (x);
2483 }
2484
2485 static bool
2486 legitimate_lo_sum_address_p (enum machine_mode mode, rtx x, int strict)
2487 {
2488   if (GET_CODE (x) != LO_SUM)
2489     return false;
2490   if (GET_CODE (XEXP (x, 0)) != REG)
2491     return false;
2492   if (!INT_REG_OK_FOR_BASE_P (XEXP (x, 0), strict))
2493     return false;
2494   /* Restrict addressing for DI because of our SUBREG hackery.  */
2495   if (TARGET_E500_DOUBLE && (mode == DFmode || mode == DImode))
2496     return false;
2497   x = XEXP (x, 1);
2498
2499   if (TARGET_ELF || TARGET_MACHO)
2500     {
2501       if (DEFAULT_ABI != ABI_AIX && DEFAULT_ABI != ABI_DARWIN && flag_pic)
2502         return false;
2503       if (TARGET_TOC)
2504         return false;
2505       if (GET_MODE_NUNITS (mode) != 1)
2506         return false;
2507       if (GET_MODE_BITSIZE (mode) > 64
2508           || (GET_MODE_BITSIZE (mode) > 32 && !TARGET_POWERPC64
2509               && !(TARGET_HARD_FLOAT && TARGET_FPRS && mode == DFmode)))
2510         return false;
2511
2512       return CONSTANT_P (x);
2513     }
2514
2515   return false;
2516 }
2517
2518
2519 /* Try machine-dependent ways of modifying an illegitimate address
2520    to be legitimate.  If we find one, return the new, valid address.
2521    This is used from only one place: `memory_address' in explow.c.
2522
2523    OLDX is the address as it was before break_out_memory_refs was
2524    called.  In some cases it is useful to look at this to decide what
2525    needs to be done.
2526
2527    MODE is passed so that this function can use GO_IF_LEGITIMATE_ADDRESS.
2528
2529    It is always safe for this function to do nothing.  It exists to
2530    recognize opportunities to optimize the output.
2531
2532    On RS/6000, first check for the sum of a register with a constant
2533    integer that is out of range.  If so, generate code to add the
2534    constant with the low-order 16 bits masked to the register and force
2535    this result into another register (this can be done with `cau').
2536    Then generate an address of REG+(CONST&0xffff), allowing for the
2537    possibility of bit 16 being a one.
2538
2539    Then check for the sum of a register and something not constant, try to
2540    load the other things into a register and return the sum.  */
2541
2542 rtx
2543 rs6000_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
2544                            enum machine_mode mode)
2545 {
2546   if (GET_CODE (x) == SYMBOL_REF)
2547     {
2548       enum tls_model model = SYMBOL_REF_TLS_MODEL (x);
2549       if (model != 0)
2550         return rs6000_legitimize_tls_address (x, model);
2551     }
2552
2553   if (GET_CODE (x) == PLUS
2554       && GET_CODE (XEXP (x, 0)) == REG
2555       && GET_CODE (XEXP (x, 1)) == CONST_INT
2556       && (unsigned HOST_WIDE_INT) (INTVAL (XEXP (x, 1)) + 0x8000) >= 0x10000)
2557     {
2558       HOST_WIDE_INT high_int, low_int;
2559       rtx sum;
2560       low_int = ((INTVAL (XEXP (x, 1)) & 0xffff) ^ 0x8000) - 0x8000;
2561       high_int = INTVAL (XEXP (x, 1)) - low_int;
2562       sum = force_operand (gen_rtx_PLUS (Pmode, XEXP (x, 0),
2563                                          GEN_INT (high_int)), 0);
2564       return gen_rtx_PLUS (Pmode, sum, GEN_INT (low_int));
2565     }
2566   else if (GET_CODE (x) == PLUS
2567            && GET_CODE (XEXP (x, 0)) == REG
2568            && GET_CODE (XEXP (x, 1)) != CONST_INT
2569            && GET_MODE_NUNITS (mode) == 1
2570            && ((TARGET_HARD_FLOAT && TARGET_FPRS)
2571                || TARGET_POWERPC64
2572                || (((mode != DImode && mode != DFmode) || TARGET_E500_DOUBLE)
2573                    && mode != TFmode))
2574            && (TARGET_POWERPC64 || mode != DImode)
2575            && mode != TImode)
2576     {
2577       return gen_rtx_PLUS (Pmode, XEXP (x, 0),
2578                            force_reg (Pmode, force_operand (XEXP (x, 1), 0)));
2579     }
2580   else if (ALTIVEC_VECTOR_MODE (mode))
2581     {
2582       rtx reg;
2583
2584       /* Make sure both operands are registers.  */
2585       if (GET_CODE (x) == PLUS)
2586         return gen_rtx_PLUS (Pmode, force_reg (Pmode, XEXP (x, 0)),
2587                              force_reg (Pmode, XEXP (x, 1)));
2588
2589       reg = force_reg (Pmode, x);
2590       return reg;
2591     }
2592   else if (SPE_VECTOR_MODE (mode)
2593            || (TARGET_E500_DOUBLE && (mode == DFmode
2594                                       || mode == DImode)))
2595     {
2596       if (mode == DImode)
2597         return NULL_RTX;
2598       /* We accept [reg + reg] and [reg + OFFSET].  */
2599
2600       if (GET_CODE (x) == PLUS)
2601         {
2602           rtx op1 = XEXP (x, 0);
2603           rtx op2 = XEXP (x, 1);
2604
2605           op1 = force_reg (Pmode, op1);
2606
2607           if (GET_CODE (op2) != REG
2608               && (GET_CODE (op2) != CONST_INT
2609                   || !SPE_CONST_OFFSET_OK (INTVAL (op2))))
2610             op2 = force_reg (Pmode, op2);
2611
2612           return gen_rtx_PLUS (Pmode, op1, op2);
2613         }
2614
2615       return force_reg (Pmode, x);
2616     }
2617   else if (TARGET_ELF
2618            && TARGET_32BIT
2619            && TARGET_NO_TOC
2620            && ! flag_pic
2621            && GET_CODE (x) != CONST_INT
2622            && GET_CODE (x) != CONST_DOUBLE
2623            && CONSTANT_P (x)
2624            && GET_MODE_NUNITS (mode) == 1
2625            && (GET_MODE_BITSIZE (mode) <= 32
2626                || ((TARGET_HARD_FLOAT && TARGET_FPRS) && mode == DFmode)))
2627     {
2628       rtx reg = gen_reg_rtx (Pmode);
2629       emit_insn (gen_elf_high (reg, x));
2630       return gen_rtx_LO_SUM (Pmode, reg, x);
2631     }
2632   else if (TARGET_MACHO && TARGET_32BIT && TARGET_NO_TOC
2633            && ! flag_pic
2634 #if TARGET_MACHO
2635            && ! MACHO_DYNAMIC_NO_PIC_P
2636 #endif
2637            && GET_CODE (x) != CONST_INT
2638            && GET_CODE (x) != CONST_DOUBLE
2639            && CONSTANT_P (x)
2640            && ((TARGET_HARD_FLOAT && TARGET_FPRS) || mode != DFmode)
2641            && mode != DImode
2642            && mode != TImode)
2643     {
2644       rtx reg = gen_reg_rtx (Pmode);
2645       emit_insn (gen_macho_high (reg, x));
2646       return gen_rtx_LO_SUM (Pmode, reg, x);
2647     }
2648   else if (TARGET_TOC
2649            && constant_pool_expr_p (x)
2650            && ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (get_pool_constant (x), Pmode))
2651     {
2652       return create_TOC_reference (x);
2653     }
2654   else
2655     return NULL_RTX;
2656 }
2657
2658 /* This is called from dwarf2out.c via ASM_OUTPUT_DWARF_DTPREL.
2659    We need to emit DTP-relative relocations.  */
2660
2661 void
2662 rs6000_output_dwarf_dtprel (FILE *file, int size, rtx x)
2663 {
2664   switch (size)
2665     {
2666     case 4:
2667       fputs ("\t.long\t", file);
2668       break;
2669     case 8:
2670       fputs (DOUBLE_INT_ASM_OP, file);
2671       break;
2672     default:
2673       abort ();
2674     }
2675   output_addr_const (file, x);
2676   fputs ("@dtprel+0x8000", file);
2677 }
2678
2679 /* Construct the SYMBOL_REF for the tls_get_addr function.  */
2680
2681 static GTY(()) rtx rs6000_tls_symbol;
2682 static rtx
2683 rs6000_tls_get_addr (void)
2684 {
2685   if (!rs6000_tls_symbol)
2686     rs6000_tls_symbol = init_one_libfunc ("__tls_get_addr");
2687
2688   return rs6000_tls_symbol;
2689 }
2690
2691 /* Construct the SYMBOL_REF for TLS GOT references.  */
2692
2693 static GTY(()) rtx rs6000_got_symbol;
2694 static rtx
2695 rs6000_got_sym (void)
2696 {
2697   if (!rs6000_got_symbol)
2698     {
2699       rs6000_got_symbol = gen_rtx_SYMBOL_REF (Pmode, "_GLOBAL_OFFSET_TABLE_");
2700       SYMBOL_REF_FLAGS (rs6000_got_symbol) |= SYMBOL_FLAG_LOCAL;
2701       SYMBOL_REF_FLAGS (rs6000_got_symbol) |= SYMBOL_FLAG_EXTERNAL;
2702     }
2703
2704   return rs6000_got_symbol;
2705 }
2706
2707 /* ADDR contains a thread-local SYMBOL_REF.  Generate code to compute
2708    this (thread-local) address.  */
2709
2710 static rtx
2711 rs6000_legitimize_tls_address (rtx addr, enum tls_model model)
2712 {
2713   rtx dest, insn;
2714
2715   dest = gen_reg_rtx (Pmode);
2716   if (model == TLS_MODEL_LOCAL_EXEC && rs6000_tls_size == 16)
2717     {
2718       rtx tlsreg;
2719
2720       if (TARGET_64BIT)
2721         {
2722           tlsreg = gen_rtx_REG (Pmode, 13);
2723           insn = gen_tls_tprel_64 (dest, tlsreg, addr);
2724         }
2725       else
2726         {
2727           tlsreg = gen_rtx_REG (Pmode, 2);
2728           insn = gen_tls_tprel_32 (dest, tlsreg, addr);
2729         }
2730       emit_insn (insn);
2731     }
2732   else if (model == TLS_MODEL_LOCAL_EXEC && rs6000_tls_size == 32)
2733     {
2734       rtx tlsreg, tmp;
2735
2736       tmp = gen_reg_rtx (Pmode);
2737       if (TARGET_64BIT)
2738         {
2739           tlsreg = gen_rtx_REG (Pmode, 13);
2740           insn = gen_tls_tprel_ha_64 (tmp, tlsreg, addr);
2741         }
2742       else
2743         {
2744           tlsreg = gen_rtx_REG (Pmode, 2);
2745           insn = gen_tls_tprel_ha_32 (tmp, tlsreg, addr);
2746         }
2747       emit_insn (insn);
2748       if (TARGET_64BIT)
2749         insn = gen_tls_tprel_lo_64 (dest, tmp, addr);
2750       else
2751         insn = gen_tls_tprel_lo_32 (dest, tmp, addr);
2752       emit_insn (insn);
2753     }
2754   else
2755     {
2756       rtx r3, got, tga, tmp1, tmp2, eqv;
2757
2758       if (TARGET_64BIT)
2759         got = gen_rtx_REG (Pmode, TOC_REGISTER);
2760       else
2761         {
2762           if (flag_pic == 1)
2763             got = gen_rtx_REG (Pmode, RS6000_PIC_OFFSET_TABLE_REGNUM);
2764           else
2765             {
2766               rtx gsym = rs6000_got_sym ();
2767               got = gen_reg_rtx (Pmode);
2768               if (flag_pic == 0)
2769                 rs6000_emit_move (got, gsym, Pmode);
2770               else
2771                 {
2772                   rtx tempLR, tmp3, mem;
2773                   rtx first, last;
2774
2775                   tempLR = gen_reg_rtx (Pmode);
2776                   tmp1 = gen_reg_rtx (Pmode);
2777                   tmp2 = gen_reg_rtx (Pmode);
2778                   tmp3 = gen_reg_rtx (Pmode);
2779                   mem = gen_const_mem (Pmode, tmp1);
2780
2781                   first = emit_insn (gen_load_toc_v4_PIC_1b (tempLR, gsym));
2782                   emit_move_insn (tmp1, tempLR);
2783                   emit_move_insn (tmp2, mem);
2784                   emit_insn (gen_addsi3 (tmp3, tmp1, tmp2));
2785                   last = emit_move_insn (got, tmp3);
2786                   REG_NOTES (last) = gen_rtx_EXPR_LIST (REG_EQUAL, gsym,
2787                                                         REG_NOTES (last));
2788                   REG_NOTES (first) = gen_rtx_INSN_LIST (REG_LIBCALL, last,
2789                                                          REG_NOTES (first));
2790                   REG_NOTES (last) = gen_rtx_INSN_LIST (REG_RETVAL, first,
2791                                                         REG_NOTES (last));
2792                 }
2793             }
2794         }
2795
2796       if (model == TLS_MODEL_GLOBAL_DYNAMIC)
2797         {
2798           r3 = gen_rtx_REG (Pmode, 3);
2799           if (TARGET_64BIT)
2800             insn = gen_tls_gd_64 (r3, got, addr);
2801           else
2802             insn = gen_tls_gd_32 (r3, got, addr);
2803           start_sequence ();
2804           emit_insn (insn);
2805           tga = gen_rtx_MEM (Pmode, rs6000_tls_get_addr ());
2806           insn = gen_call_value (r3, tga, const0_rtx, const0_rtx);
2807           insn = emit_call_insn (insn);
2808           CONST_OR_PURE_CALL_P (insn) = 1;
2809           use_reg (&CALL_INSN_FUNCTION_USAGE (insn), r3);
2810           insn = get_insns ();
2811           end_sequence ();
2812           emit_libcall_block (insn, dest, r3, addr);
2813         }
2814       else if (model == TLS_MODEL_LOCAL_DYNAMIC)
2815         {
2816           r3 = gen_rtx_REG (Pmode, 3);
2817           if (TARGET_64BIT)
2818             insn = gen_tls_ld_64 (r3, got);
2819           else
2820             insn = gen_tls_ld_32 (r3, got);
2821           start_sequence ();
2822           emit_insn (insn);
2823           tga = gen_rtx_MEM (Pmode, rs6000_tls_get_addr ());
2824           insn = gen_call_value (r3, tga, const0_rtx, const0_rtx);
2825           insn = emit_call_insn (insn);
2826           CONST_OR_PURE_CALL_P (insn) = 1;
2827           use_reg (&CALL_INSN_FUNCTION_USAGE (insn), r3);
2828           insn = get_insns ();
2829           end_sequence ();
2830           tmp1 = gen_reg_rtx (Pmode);
2831           eqv = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
2832                                 UNSPEC_TLSLD);
2833           emit_libcall_block (insn, tmp1, r3, eqv);
2834           if (rs6000_tls_size == 16)
2835             {
2836               if (TARGET_64BIT)
2837                 insn = gen_tls_dtprel_64 (dest, tmp1, addr);
2838               else
2839                 insn = gen_tls_dtprel_32 (dest, tmp1, addr);
2840             }
2841           else if (rs6000_tls_size == 32)
2842             {
2843               tmp2 = gen_reg_rtx (Pmode);
2844               if (TARGET_64BIT)
2845                 insn = gen_tls_dtprel_ha_64 (tmp2, tmp1, addr);
2846               else
2847                 insn = gen_tls_dtprel_ha_32 (tmp2, tmp1, addr);
2848               emit_insn (insn);
2849               if (TARGET_64BIT)
2850                 insn = gen_tls_dtprel_lo_64 (dest, tmp2, addr);
2851               else
2852                 insn = gen_tls_dtprel_lo_32 (dest, tmp2, addr);
2853             }
2854           else
2855             {
2856               tmp2 = gen_reg_rtx (Pmode);
2857               if (TARGET_64BIT)
2858                 insn = gen_tls_got_dtprel_64 (tmp2, got, addr);
2859               else
2860                 insn = gen_tls_got_dtprel_32 (tmp2, got, addr);
2861               emit_insn (insn);
2862               insn = gen_rtx_SET (Pmode, dest,
2863                                   gen_rtx_PLUS (Pmode, tmp2, tmp1));
2864             }
2865           emit_insn (insn);
2866         }
2867       else
2868         {
2869           /* IE, or 64 bit offset LE.  */
2870           tmp2 = gen_reg_rtx (Pmode);
2871           if (TARGET_64BIT)
2872             insn = gen_tls_got_tprel_64 (tmp2, got, addr);
2873           else
2874             insn = gen_tls_got_tprel_32 (tmp2, got, addr);
2875           emit_insn (insn);
2876           if (TARGET_64BIT)
2877             insn = gen_tls_tls_64 (dest, tmp2, addr);
2878           else
2879             insn = gen_tls_tls_32 (dest, tmp2, addr);
2880           emit_insn (insn);
2881         }
2882     }
2883
2884   return dest;
2885 }
2886
2887 /* Return 1 if X contains a thread-local symbol.  */
2888
2889 bool
2890 rs6000_tls_referenced_p (rtx x)
2891 {
2892   if (! TARGET_HAVE_TLS)
2893     return false;
2894
2895   return for_each_rtx (&x, &rs6000_tls_symbol_ref_1, 0);
2896 }
2897
2898 /* Return 1 if *X is a thread-local symbol.  This is the same as
2899    rs6000_tls_symbol_ref except for the type of the unused argument.  */
2900
2901 static int
2902 rs6000_tls_symbol_ref_1 (rtx *x, void *data ATTRIBUTE_UNUSED)
2903 {
2904   return RS6000_SYMBOL_REF_TLS_P (*x);
2905 }
2906
2907 /* The convention appears to be to define this wherever it is used.
2908    With legitimize_reload_address now defined here, REG_MODE_OK_FOR_BASE_P
2909    is now used here.  */
2910 #ifndef REG_MODE_OK_FOR_BASE_P
2911 #define REG_MODE_OK_FOR_BASE_P(REGNO, MODE) REG_OK_FOR_BASE_P (REGNO)
2912 #endif
2913
2914 /* Our implementation of LEGITIMIZE_RELOAD_ADDRESS.  Returns a value to
2915    replace the input X, or the original X if no replacement is called for.
2916    The output parameter *WIN is 1 if the calling macro should goto WIN,
2917    0 if it should not.
2918
2919    For RS/6000, we wish to handle large displacements off a base
2920    register by splitting the addend across an addiu/addis and the mem insn.
2921    This cuts number of extra insns needed from 3 to 1.
2922
2923    On Darwin, we use this to generate code for floating point constants.
2924    A movsf_low is generated so we wind up with 2 instructions rather than 3.
2925    The Darwin code is inside #if TARGET_MACHO because only then is
2926    machopic_function_base_name() defined.  */
2927 rtx
2928 rs6000_legitimize_reload_address (rtx x, enum machine_mode mode,
2929                                   int opnum, int type,
2930                                   int ind_levels ATTRIBUTE_UNUSED, int *win)
2931 {
2932   /* We must recognize output that we have already generated ourselves.  */
2933   if (GET_CODE (x) == PLUS
2934       && GET_CODE (XEXP (x, 0)) == PLUS
2935       && GET_CODE (XEXP (XEXP (x, 0), 0)) == REG
2936       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
2937       && GET_CODE (XEXP (x, 1)) == CONST_INT)
2938     {
2939       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
2940                    BASE_REG_CLASS, GET_MODE (x), VOIDmode, 0, 0,
2941                    opnum, (enum reload_type)type);
2942       *win = 1;
2943       return x;
2944     }
2945
2946 #if TARGET_MACHO
2947   if (DEFAULT_ABI == ABI_DARWIN && flag_pic
2948       && GET_CODE (x) == LO_SUM
2949       && GET_CODE (XEXP (x, 0)) == PLUS
2950       && XEXP (XEXP (x, 0), 0) == pic_offset_table_rtx
2951       && GET_CODE (XEXP (XEXP (x, 0), 1)) == HIGH
2952       && GET_CODE (XEXP (XEXP (XEXP (x, 0), 1), 0)) == CONST
2953       && XEXP (XEXP (XEXP (x, 0), 1), 0) == XEXP (x, 1)
2954       && GET_CODE (XEXP (XEXP (x, 1), 0)) == MINUS
2955       && GET_CODE (XEXP (XEXP (XEXP (x, 1), 0), 0)) == SYMBOL_REF
2956       && GET_CODE (XEXP (XEXP (XEXP (x, 1), 0), 1)) == SYMBOL_REF)
2957     {
2958       /* Result of previous invocation of this function on Darwin
2959          floating point constant.  */
2960       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
2961                    BASE_REG_CLASS, Pmode, VOIDmode, 0, 0,
2962                    opnum, (enum reload_type)type);
2963       *win = 1;
2964       return x;
2965     }
2966 #endif
2967
2968   /* Force ld/std non-word aligned offset into base register by wrapping
2969      in offset 0.  */
2970   if (GET_CODE (x) == PLUS
2971       && GET_CODE (XEXP (x, 0)) == REG
2972       && REGNO (XEXP (x, 0)) < 32
2973       && REG_MODE_OK_FOR_BASE_P (XEXP (x, 0), mode)
2974       && GET_CODE (XEXP (x, 1)) == CONST_INT
2975       && (INTVAL (XEXP (x, 1)) & 3) != 0
2976       && !ALTIVEC_VECTOR_MODE (mode)
2977       && GET_MODE_SIZE (mode) >= UNITS_PER_WORD
2978       && TARGET_POWERPC64)
2979     {
2980       x = gen_rtx_PLUS (GET_MODE (x), x, GEN_INT (0));
2981       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
2982                    BASE_REG_CLASS, GET_MODE (x), VOIDmode, 0, 0,
2983                    opnum, (enum reload_type) type);
2984       *win = 1;
2985       return x;
2986     }
2987
2988   if (GET_CODE (x) == PLUS
2989       && GET_CODE (XEXP (x, 0)) == REG
2990       && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER
2991       && REG_MODE_OK_FOR_BASE_P (XEXP (x, 0), mode)
2992       && GET_CODE (XEXP (x, 1)) == CONST_INT
2993       && !SPE_VECTOR_MODE (mode)
2994       && !(TARGET_E500_DOUBLE && (mode == DFmode
2995                                   || mode == DImode))
2996       && !ALTIVEC_VECTOR_MODE (mode))
2997     {
2998       HOST_WIDE_INT val = INTVAL (XEXP (x, 1));
2999       HOST_WIDE_INT low = ((val & 0xffff) ^ 0x8000) - 0x8000;
3000       HOST_WIDE_INT high
3001         = (((val - low) & 0xffffffff) ^ 0x80000000) - 0x80000000;
3002
3003       /* Check for 32-bit overflow.  */
3004       if (high + low != val)
3005         {
3006           *win = 0;
3007           return x;
3008         }
3009
3010       /* Reload the high part into a base reg; leave the low part
3011          in the mem directly.  */
3012
3013       x = gen_rtx_PLUS (GET_MODE (x),
3014                         gen_rtx_PLUS (GET_MODE (x), XEXP (x, 0),
3015                                       GEN_INT (high)),
3016                         GEN_INT (low));
3017
3018       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
3019                    BASE_REG_CLASS, GET_MODE (x), VOIDmode, 0, 0,
3020                    opnum, (enum reload_type)type);
3021       *win = 1;
3022       return x;
3023     }
3024
3025 #if TARGET_MACHO
3026   if (GET_CODE (x) == SYMBOL_REF
3027       && DEFAULT_ABI == ABI_DARWIN
3028       && !ALTIVEC_VECTOR_MODE (mode)
3029       && (flag_pic || MACHO_DYNAMIC_NO_PIC_P)
3030       /* Don't do this for TFmode, since the result isn't offsettable.
3031          The same goes for DImode without 64-bit gprs.  */
3032       && mode != TFmode
3033       && (mode != DImode || TARGET_POWERPC64))
3034     {
3035       if (flag_pic)
3036         {
3037           rtx offset = gen_rtx_CONST (Pmode,
3038                          gen_rtx_MINUS (Pmode, x,
3039                                         machopic_function_base_sym ()));
3040           x = gen_rtx_LO_SUM (GET_MODE (x),
3041                 gen_rtx_PLUS (Pmode, pic_offset_table_rtx,
3042                   gen_rtx_HIGH (Pmode, offset)), offset);
3043         }
3044       else
3045         x = gen_rtx_LO_SUM (GET_MODE (x),
3046               gen_rtx_HIGH (Pmode, x), x);
3047
3048       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
3049                    BASE_REG_CLASS, Pmode, VOIDmode, 0, 0,
3050                    opnum, (enum reload_type)type);
3051       *win = 1;
3052       return x;
3053     }
3054 #endif
3055
3056   if (TARGET_TOC
3057       && constant_pool_expr_p (x)
3058       && ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (get_pool_constant (x), mode))
3059     {
3060       (x) = create_TOC_reference (x);
3061       *win = 1;
3062       return x;
3063     }
3064   *win = 0;
3065   return x;
3066 }
3067
3068 /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression
3069    that is a valid memory address for an instruction.
3070    The MODE argument is the machine mode for the MEM expression
3071    that wants to use this address.
3072
3073    On the RS/6000, there are four valid address: a SYMBOL_REF that
3074    refers to a constant pool entry of an address (or the sum of it
3075    plus a constant), a short (16-bit signed) constant plus a register,
3076    the sum of two registers, or a register indirect, possibly with an
3077    auto-increment.  For DFmode and DImode with a constant plus register,
3078    we must ensure that both words are addressable or PowerPC64 with offset
3079    word aligned.
3080
3081    For modes spanning multiple registers (DFmode in 32-bit GPRs,
3082    32-bit DImode, TImode, TFmode), indexed addressing cannot be used because
3083    adjacent memory cells are accessed by adding word-sized offsets
3084    during assembly output.  */
3085 int
3086 rs6000_legitimate_address (enum machine_mode mode, rtx x, int reg_ok_strict)
3087 {
3088   /* If this is an unaligned stvx/ldvx type address, discard the outer AND.  */
3089   if (TARGET_ALTIVEC
3090       && ALTIVEC_VECTOR_MODE (mode)
3091       && GET_CODE (x) == AND
3092       && GET_CODE (XEXP (x, 1)) == CONST_INT
3093       && INTVAL (XEXP (x, 1)) == -16)
3094     x = XEXP (x, 0);
3095
3096   if (RS6000_SYMBOL_REF_TLS_P (x))
3097     return 0;
3098   if (legitimate_indirect_address_p (x, reg_ok_strict))
3099     return 1;
3100   if ((GET_CODE (x) == PRE_INC || GET_CODE (x) == PRE_DEC)
3101       && !ALTIVEC_VECTOR_MODE (mode)
3102       && !SPE_VECTOR_MODE (mode)
3103       /* Restrict addressing for DI because of our SUBREG hackery.  */
3104       && !(TARGET_E500_DOUBLE && (mode == DFmode || mode == DImode))
3105       && TARGET_UPDATE
3106       && legitimate_indirect_address_p (XEXP (x, 0), reg_ok_strict))
3107     return 1;
3108   if (legitimate_small_data_p (mode, x))
3109     return 1;
3110   if (legitimate_constant_pool_address_p (x))
3111     return 1;
3112   /* If not REG_OK_STRICT (before reload) let pass any stack offset.  */
3113   if (! reg_ok_strict
3114       && GET_CODE (x) == PLUS
3115       && GET_CODE (XEXP (x, 0)) == REG
3116       && (XEXP (x, 0) == virtual_stack_vars_rtx
3117           || XEXP (x, 0) == arg_pointer_rtx)
3118       && GET_CODE (XEXP (x, 1)) == CONST_INT)
3119     return 1;
3120   if (rs6000_legitimate_offset_address_p (mode, x, reg_ok_strict))
3121     return 1;
3122   if (mode != TImode
3123       && mode != TFmode
3124       && ((TARGET_HARD_FLOAT && TARGET_FPRS)
3125           || TARGET_POWERPC64
3126           || ((mode != DFmode || TARGET_E500_DOUBLE) && mode != TFmode))
3127       && (TARGET_POWERPC64 || mode != DImode)
3128       && legitimate_indexed_address_p (x, reg_ok_strict))
3129     return 1;
3130   if (legitimate_lo_sum_address_p (mode, x, reg_ok_strict))
3131     return 1;
3132   return 0;
3133 }
3134
3135 /* Go to LABEL if ADDR (a legitimate address expression)
3136    has an effect that depends on the machine mode it is used for.
3137
3138    On the RS/6000 this is true of all integral offsets (since AltiVec
3139    modes don't allow them) or is a pre-increment or decrement.
3140
3141    ??? Except that due to conceptual problems in offsettable_address_p
3142    we can't really report the problems of integral offsets.  So leave
3143    this assuming that the adjustable offset must be valid for the
3144    sub-words of a TFmode operand, which is what we had before.  */
3145
3146 bool
3147 rs6000_mode_dependent_address (rtx addr)
3148 {
3149   switch (GET_CODE (addr))
3150     {
3151     case PLUS:
3152       if (GET_CODE (XEXP (addr, 1)) == CONST_INT)
3153         {
3154           unsigned HOST_WIDE_INT val = INTVAL (XEXP (addr, 1));
3155           return val + 12 + 0x8000 >= 0x10000;
3156         }
3157       break;
3158
3159     case LO_SUM:
3160       return true;
3161
3162     case PRE_INC:
3163     case PRE_DEC:
3164       return TARGET_UPDATE;
3165
3166     default:
3167       break;
3168     }
3169
3170   return false;
3171 }
3172
3173 /* Return number of consecutive hard regs needed starting at reg REGNO
3174    to hold something of mode MODE.
3175    This is ordinarily the length in words of a value of mode MODE
3176    but can be less for certain modes in special long registers.
3177
3178    For the SPE, GPRs are 64 bits but only 32 bits are visible in
3179    scalar instructions.  The upper 32 bits are only available to the
3180    SIMD instructions.
3181
3182    POWER and PowerPC GPRs hold 32 bits worth;
3183    PowerPC64 GPRs and FPRs point register holds 64 bits worth.  */
3184
3185 int
3186 rs6000_hard_regno_nregs (int regno, enum machine_mode mode)
3187 {
3188   if (FP_REGNO_P (regno))
3189     return (GET_MODE_SIZE (mode) + UNITS_PER_FP_WORD - 1) / UNITS_PER_FP_WORD;
3190
3191   if (TARGET_E500_DOUBLE && mode == DFmode)
3192     return 1;
3193
3194   if (SPE_SIMD_REGNO_P (regno) && TARGET_SPE && SPE_VECTOR_MODE (mode))
3195     return (GET_MODE_SIZE (mode) + UNITS_PER_SPE_WORD - 1) / UNITS_PER_SPE_WORD;
3196
3197   if (ALTIVEC_REGNO_P (regno))
3198     return
3199       (GET_MODE_SIZE (mode) + UNITS_PER_ALTIVEC_WORD - 1) / UNITS_PER_ALTIVEC_WORD;
3200
3201   return (GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
3202 }
3203
3204 /* Change register usage conditional on target flags.  */
3205 void
3206 rs6000_conditional_register_usage (void)
3207 {
3208   int i;
3209
3210   /* Set MQ register fixed (already call_used) if not POWER
3211      architecture (RIOS1, RIOS2, RSC, and PPC601) so that it will not
3212      be allocated.  */
3213   if (! TARGET_POWER)
3214     fixed_regs[64] = 1;
3215
3216   /* 64-bit AIX reserves GPR13 for thread-private data.  */
3217   if (TARGET_64BIT)
3218     fixed_regs[13] = call_used_regs[13]
3219       = call_really_used_regs[13] = 1;
3220
3221   /* Conditionally disable FPRs.  */
3222   if (TARGET_SOFT_FLOAT || !TARGET_FPRS)
3223     for (i = 32; i < 64; i++)
3224       fixed_regs[i] = call_used_regs[i]
3225         = call_really_used_regs[i] = 1;
3226
3227   if (DEFAULT_ABI == ABI_V4
3228       && PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
3229       && flag_pic == 2)
3230     fixed_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] = 1;
3231
3232   if (DEFAULT_ABI == ABI_V4
3233       && PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
3234       && flag_pic == 1)
3235     fixed_regs[RS6000_PIC_OFFSET_TABLE_REGNUM]
3236       = call_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM]
3237       = call_really_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] = 1;
3238
3239   if (DEFAULT_ABI == ABI_DARWIN
3240       && PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM)
3241     global_regs[RS6000_PIC_OFFSET_TABLE_REGNUM]
3242       = fixed_regs[RS6000_PIC_OFFSET_TABLE_REGNUM]
3243       = call_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM]
3244       = call_really_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] = 1;
3245
3246   if (TARGET_TOC && TARGET_MINIMAL_TOC)
3247     fixed_regs[RS6000_PIC_OFFSET_TABLE_REGNUM]
3248       = call_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] = 1;
3249
3250   if (TARGET_ALTIVEC)
3251     global_regs[VSCR_REGNO] = 1;
3252
3253   if (TARGET_SPE)
3254     {
3255       global_regs[SPEFSCR_REGNO] = 1;
3256       fixed_regs[FIXED_SCRATCH]
3257         = call_used_regs[FIXED_SCRATCH]
3258         = call_really_used_regs[FIXED_SCRATCH] = 1;
3259     }
3260
3261   if (! TARGET_ALTIVEC)
3262     {
3263       for (i = FIRST_ALTIVEC_REGNO; i <= LAST_ALTIVEC_REGNO; ++i)
3264         fixed_regs[i] = call_used_regs[i] = call_really_used_regs[i] = 1;
3265       call_really_used_regs[VRSAVE_REGNO] = 1;
3266     }
3267
3268   if (TARGET_ALTIVEC_ABI)
3269     for (i = FIRST_ALTIVEC_REGNO; i < FIRST_ALTIVEC_REGNO + 20; ++i)
3270       call_used_regs[i] = call_really_used_regs[i] = 1;
3271 }
3272 \f
3273 /* Try to output insns to set TARGET equal to the constant C if it can
3274    be done in less than N insns.  Do all computations in MODE.
3275    Returns the place where the output has been placed if it can be
3276    done and the insns have been emitted.  If it would take more than N
3277    insns, zero is returned and no insns and emitted.  */
3278
3279 rtx
3280 rs6000_emit_set_const (rtx dest, enum machine_mode mode,
3281                        rtx source, int n ATTRIBUTE_UNUSED)
3282 {
3283   rtx result, insn, set;
3284   HOST_WIDE_INT c0, c1;
3285
3286   if (mode == QImode || mode == HImode)
3287     {
3288       if (dest == NULL)
3289         dest = gen_reg_rtx (mode);
3290       emit_insn (gen_rtx_SET (VOIDmode, dest, source));
3291       return dest;
3292     }
3293   else if (mode == SImode)
3294     {
3295       result = no_new_pseudos ? dest : gen_reg_rtx (SImode);
3296
3297       emit_insn (gen_rtx_SET (VOIDmode, result,
3298                               GEN_INT (INTVAL (source)
3299                                        & (~ (HOST_WIDE_INT) 0xffff))));
3300       emit_insn (gen_rtx_SET (VOIDmode, dest,
3301                               gen_rtx_IOR (SImode, result,
3302                                            GEN_INT (INTVAL (source) & 0xffff))));
3303       result = dest;
3304     }
3305   else if (mode == DImode)
3306     {
3307       if (GET_CODE (source) == CONST_INT)
3308         {
3309           c0 = INTVAL (source);
3310           c1 = -(c0 < 0);
3311         }
3312       else if (GET_CODE (source) == CONST_DOUBLE)
3313         {
3314 #if HOST_BITS_PER_WIDE_INT >= 64
3315           c0 = CONST_DOUBLE_LOW (source);
3316           c1 = -(c0 < 0);
3317 #else
3318           c0 = CONST_DOUBLE_LOW (source);
3319           c1 = CONST_DOUBLE_HIGH (source);
3320 #endif
3321         }
3322       else
3323         abort ();
3324
3325       result = rs6000_emit_set_long_const (dest, c0, c1);
3326     }
3327   else
3328     abort ();
3329
3330   insn = get_last_insn ();
3331   set = single_set (insn);
3332   if (! CONSTANT_P (SET_SRC (set)))
3333     set_unique_reg_note (insn, REG_EQUAL, source);
3334
3335   return result;
3336 }
3337
3338 /* Having failed to find a 3 insn sequence in rs6000_emit_set_const,
3339    fall back to a straight forward decomposition.  We do this to avoid
3340    exponential run times encountered when looking for longer sequences
3341    with rs6000_emit_set_const.  */
3342 static rtx
3343 rs6000_emit_set_long_const (rtx dest, HOST_WIDE_INT c1, HOST_WIDE_INT c2)
3344 {
3345   if (!TARGET_POWERPC64)
3346     {
3347       rtx operand1, operand2;
3348
3349       operand1 = operand_subword_force (dest, WORDS_BIG_ENDIAN == 0,
3350                                         DImode);
3351       operand2 = operand_subword_force (dest, WORDS_BIG_ENDIAN != 0,
3352                                         DImode);
3353       emit_move_insn (operand1, GEN_INT (c1));
3354       emit_move_insn (operand2, GEN_INT (c2));
3355     }
3356   else
3357     {
3358       HOST_WIDE_INT ud1, ud2, ud3, ud4;
3359
3360       ud1 = c1 & 0xffff;
3361       ud2 = (c1 & 0xffff0000) >> 16;
3362 #if HOST_BITS_PER_WIDE_INT >= 64
3363       c2 = c1 >> 32;
3364 #endif
3365       ud3 = c2 & 0xffff;
3366       ud4 = (c2 & 0xffff0000) >> 16;
3367
3368       if ((ud4 == 0xffff && ud3 == 0xffff && ud2 == 0xffff && (ud1 & 0x8000))
3369           || (ud4 == 0 && ud3 == 0 && ud2 == 0 && ! (ud1 & 0x8000)))
3370         {
3371           if (ud1 & 0x8000)
3372             emit_move_insn (dest, GEN_INT (((ud1 ^ 0x8000) -  0x8000)));
3373           else
3374             emit_move_insn (dest, GEN_INT (ud1));
3375         }
3376
3377       else if ((ud4 == 0xffff && ud3 == 0xffff && (ud2 & 0x8000))
3378                || (ud4 == 0 && ud3 == 0 && ! (ud2 & 0x8000)))
3379         {
3380           if (ud2 & 0x8000)
3381             emit_move_insn (dest, GEN_INT (((ud2 << 16) ^ 0x80000000)
3382                                            - 0x80000000));
3383           else
3384             emit_move_insn (dest, GEN_INT (ud2 << 16));
3385           if (ud1 != 0)
3386             emit_move_insn (dest, gen_rtx_IOR (DImode, dest, GEN_INT (ud1)));
3387         }
3388       else if ((ud4 == 0xffff && (ud3 & 0x8000))
3389                || (ud4 == 0 && ! (ud3 & 0x8000)))
3390         {
3391           if (ud3 & 0x8000)
3392             emit_move_insn (dest, GEN_INT (((ud3 << 16) ^ 0x80000000)
3393                                            - 0x80000000));
3394           else
3395             emit_move_insn (dest, GEN_INT (ud3 << 16));
3396
3397           if (ud2 != 0)
3398             emit_move_insn (dest, gen_rtx_IOR (DImode, dest, GEN_INT (ud2)));
3399           emit_move_insn (dest, gen_rtx_ASHIFT (DImode, dest, GEN_INT (16)));
3400           if (ud1 != 0)
3401             emit_move_insn (dest, gen_rtx_IOR (DImode, dest, GEN_INT (ud1)));
3402         }
3403       else
3404         {
3405           if (ud4 & 0x8000)
3406             emit_move_insn (dest, GEN_INT (((ud4 << 16) ^ 0x80000000)
3407                                            - 0x80000000));
3408           else
3409             emit_move_insn (dest, GEN_INT (ud4 << 16));
3410
3411           if (ud3 != 0)
3412             emit_move_insn (dest, gen_rtx_IOR (DImode, dest, GEN_INT (ud3)));
3413
3414           emit_move_insn (dest, gen_rtx_ASHIFT (DImode, dest, GEN_INT (32)));
3415           if (ud2 != 0)
3416             emit_move_insn (dest, gen_rtx_IOR (DImode, dest,
3417                                                GEN_INT (ud2 << 16)));
3418           if (ud1 != 0)
3419             emit_move_insn (dest, gen_rtx_IOR (DImode, dest, GEN_INT (ud1)));
3420         }
3421     }
3422   return dest;
3423 }
3424
3425 /* Helper for the following.  Get rid of [r+r] memory refs
3426    in cases where it won't work (TImode, TFmode).  */
3427
3428 static void
3429 rs6000_eliminate_indexed_memrefs (rtx operands[2])
3430 {
3431   if (GET_CODE (operands[0]) == MEM
3432       && GET_CODE (XEXP (operands[0], 0)) != REG
3433       && ! legitimate_constant_pool_address_p (XEXP (operands[0], 0))
3434       && ! reload_in_progress)
3435     operands[0]
3436       = replace_equiv_address (operands[0],
3437                                copy_addr_to_reg (XEXP (operands[0], 0)));
3438
3439   if (GET_CODE (operands[1]) == MEM
3440       && GET_CODE (XEXP (operands[1], 0)) != REG
3441       && ! legitimate_constant_pool_address_p (XEXP (operands[1], 0))
3442       && ! reload_in_progress)
3443     operands[1]
3444       = replace_equiv_address (operands[1],
3445                                copy_addr_to_reg (XEXP (operands[1], 0)));
3446 }
3447
3448 /* Emit a move from SOURCE to DEST in mode MODE.  */
3449 void
3450 rs6000_emit_move (rtx dest, rtx source, enum machine_mode mode)
3451 {
3452   rtx operands[2];
3453   operands[0] = dest;
3454   operands[1] = source;
3455
3456   /* Sanity checks.  Check that we get CONST_DOUBLE only when we should.  */
3457   if (GET_CODE (operands[1]) == CONST_DOUBLE
3458       && ! FLOAT_MODE_P (mode)
3459       && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
3460     {
3461       /* FIXME.  This should never happen.  */
3462       /* Since it seems that it does, do the safe thing and convert
3463          to a CONST_INT.  */
3464       operands[1] = gen_int_mode (CONST_DOUBLE_LOW (operands[1]), mode);
3465     }
3466   if (GET_CODE (operands[1]) == CONST_DOUBLE
3467       && ! FLOAT_MODE_P (mode)
3468       && ((CONST_DOUBLE_HIGH (operands[1]) == 0
3469            && CONST_DOUBLE_LOW (operands[1]) >= 0)
3470           || (CONST_DOUBLE_HIGH (operands[1]) == -1
3471               && CONST_DOUBLE_LOW (operands[1]) < 0)))
3472     abort ();
3473
3474   /* Check if GCC is setting up a block move that will end up using FP
3475      registers as temporaries.  We must make sure this is acceptable.  */
3476   if (GET_CODE (operands[0]) == MEM
3477       && GET_CODE (operands[1]) == MEM
3478       && mode == DImode
3479       && (SLOW_UNALIGNED_ACCESS (DImode, MEM_ALIGN (operands[0]))
3480           || SLOW_UNALIGNED_ACCESS (DImode, MEM_ALIGN (operands[1])))
3481       && ! (SLOW_UNALIGNED_ACCESS (SImode, (MEM_ALIGN (operands[0]) > 32
3482                                             ? 32 : MEM_ALIGN (operands[0])))
3483             || SLOW_UNALIGNED_ACCESS (SImode, (MEM_ALIGN (operands[1]) > 32
3484                                                ? 32
3485                                                : MEM_ALIGN (operands[1]))))
3486       && ! MEM_VOLATILE_P (operands [0])
3487       && ! MEM_VOLATILE_P (operands [1]))
3488     {
3489       emit_move_insn (adjust_address (operands[0], SImode, 0),
3490                       adjust_address (operands[1], SImode, 0));
3491       emit_move_insn (adjust_address (operands[0], SImode, 4),
3492                       adjust_address (operands[1], SImode, 4));
3493       return;
3494     }
3495
3496   if (!no_new_pseudos && GET_CODE (operands[0]) == MEM
3497       && !gpc_reg_operand (operands[1], mode))
3498     operands[1] = force_reg (mode, operands[1]);
3499
3500   if (mode == SFmode && ! TARGET_POWERPC
3501       && TARGET_HARD_FLOAT && TARGET_FPRS
3502       && GET_CODE (operands[0]) == MEM)
3503     {
3504       int regnum;
3505
3506       if (reload_in_progress || reload_completed)
3507         regnum = true_regnum (operands[1]);
3508       else if (GET_CODE (operands[1]) == REG)
3509         regnum = REGNO (operands[1]);
3510       else
3511         regnum = -1;
3512
3513       /* If operands[1] is a register, on POWER it may have
3514          double-precision data in it, so truncate it to single
3515          precision.  */
3516       if (FP_REGNO_P (regnum) || regnum >= FIRST_PSEUDO_REGISTER)
3517         {
3518           rtx newreg;
3519           newreg = (no_new_pseudos ? operands[1] : gen_reg_rtx (mode));
3520           emit_insn (gen_aux_truncdfsf2 (newreg, operands[1]));
3521           operands[1] = newreg;
3522         }
3523     }
3524
3525   /* Recognize the case where operand[1] is a reference to thread-local
3526      data and load its address to a register.  */
3527   if (GET_CODE (operands[1]) == SYMBOL_REF)
3528     {
3529       enum tls_model model = SYMBOL_REF_TLS_MODEL (operands[1]);
3530       if (model != 0)
3531         operands[1] = rs6000_legitimize_tls_address (operands[1], model);
3532     }
3533
3534   /* Handle the case where reload calls us with an invalid address.  */
3535   if (reload_in_progress && mode == Pmode
3536       && (! general_operand (operands[1], mode)
3537           || ! nonimmediate_operand (operands[0], mode)))
3538     goto emit_set;
3539
3540   /* 128-bit constant floating-point values on Darwin should really be
3541      loaded as two parts.  */
3542   if ((DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_DARWIN)
3543       && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128
3544       && mode == TFmode && GET_CODE (operands[1]) == CONST_DOUBLE)
3545     {
3546       /* DImode is used, not DFmode, because simplify_gen_subreg doesn't
3547          know how to get a DFmode SUBREG of a TFmode.  */
3548       rs6000_emit_move (simplify_gen_subreg (DImode, operands[0], mode, 0),
3549                         simplify_gen_subreg (DImode, operands[1], mode, 0),
3550                         DImode);
3551       rs6000_emit_move (simplify_gen_subreg (DImode, operands[0], mode,
3552                                              GET_MODE_SIZE (DImode)),
3553                         simplify_gen_subreg (DImode, operands[1], mode,
3554                                              GET_MODE_SIZE (DImode)),
3555                         DImode);
3556       return;
3557     }
3558
3559   /* FIXME:  In the long term, this switch statement should go away
3560      and be replaced by a sequence of tests based on things like
3561      mode == Pmode.  */
3562   switch (mode)
3563     {
3564     case HImode:
3565     case QImode:
3566       if (CONSTANT_P (operands[1])
3567           && GET_CODE (operands[1]) != CONST_INT)
3568         operands[1] = force_const_mem (mode, operands[1]);
3569       break;
3570
3571     case TFmode:
3572       rs6000_eliminate_indexed_memrefs (operands);
3573       /* fall through */
3574
3575     case DFmode:
3576     case SFmode:
3577       if (CONSTANT_P (operands[1])
3578           && ! easy_fp_constant (operands[1], mode))
3579         operands[1] = force_const_mem (mode, operands[1]);
3580       break;
3581
3582     case V16QImode:
3583     case V8HImode:
3584     case V4SFmode:
3585     case V4SImode:
3586     case V4HImode:
3587     case V2SFmode:
3588     case V2SImode:
3589     case V1DImode:
3590       if (CONSTANT_P (operands[1])
3591           && !easy_vector_constant (operands[1], mode))
3592         operands[1] = force_const_mem (mode, operands[1]);
3593       break;
3594
3595     case SImode:
3596     case DImode:
3597       /* Use default pattern for address of ELF small data */
3598       if (TARGET_ELF
3599           && mode == Pmode
3600           && DEFAULT_ABI == ABI_V4
3601           && (GET_CODE (operands[1]) == SYMBOL_REF
3602               || GET_CODE (operands[1]) == CONST)
3603           && small_data_operand (operands[1], mode))
3604         {
3605           emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
3606           return;
3607         }
3608
3609       if (DEFAULT_ABI == ABI_V4
3610           && mode == Pmode && mode == SImode
3611           && flag_pic == 1 && got_operand (operands[1], mode))
3612         {
3613           emit_insn (gen_movsi_got (operands[0], operands[1]));
3614           return;
3615         }
3616
3617       if ((TARGET_ELF || DEFAULT_ABI == ABI_DARWIN)
3618           && TARGET_NO_TOC
3619           && ! flag_pic
3620           && mode == Pmode
3621           && CONSTANT_P (operands[1])
3622           && GET_CODE (operands[1]) != HIGH
3623           && GET_CODE (operands[1]) != CONST_INT)
3624         {
3625           rtx target = (no_new_pseudos ? operands[0] : gen_reg_rtx (mode));
3626
3627           /* If this is a function address on -mcall-aixdesc,
3628              convert it to the address of the descriptor.  */
3629           if (DEFAULT_ABI == ABI_AIX
3630               && GET_CODE (operands[1]) == SYMBOL_REF
3631               && XSTR (operands[1], 0)[0] == '.')
3632             {
3633               const char *name = XSTR (operands[1], 0);
3634               rtx new_ref;
3635               while (*name == '.')
3636                 name++;
3637               new_ref = gen_rtx_SYMBOL_REF (Pmode, name);
3638               CONSTANT_POOL_ADDRESS_P (new_ref)
3639                 = CONSTANT_POOL_ADDRESS_P (operands[1]);
3640               SYMBOL_REF_FLAGS (new_ref) = SYMBOL_REF_FLAGS (operands[1]);
3641               SYMBOL_REF_USED (new_ref) = SYMBOL_REF_USED (operands[1]);
3642               SYMBOL_REF_DECL (new_ref) = SYMBOL_REF_DECL (operands[1]);
3643               operands[1] = new_ref;
3644             }
3645
3646           if (DEFAULT_ABI == ABI_DARWIN)
3647             {
3648 #if TARGET_MACHO
3649               if (MACHO_DYNAMIC_NO_PIC_P)
3650                 {
3651                   /* Take care of any required data indirection.  */
3652                   operands[1] = rs6000_machopic_legitimize_pic_address (
3653                                   operands[1], mode, operands[0]);
3654                   if (operands[0] != operands[1])
3655                     emit_insn (gen_rtx_SET (VOIDmode,
3656                                             operands[0], operands[1]));
3657                   return;
3658                 }
3659 #endif
3660               emit_insn (gen_macho_high (target, operands[1]));
3661               emit_insn (gen_macho_low (operands[0], target, operands[1]));
3662               return;
3663             }
3664
3665           emit_insn (gen_elf_high (target, operands[1]));
3666           emit_insn (gen_elf_low (operands[0], target, operands[1]));
3667           return;
3668         }
3669
3670       /* If this is a SYMBOL_REF that refers to a constant pool entry,
3671          and we have put it in the TOC, we just need to make a TOC-relative
3672          reference to it.  */
3673       if (TARGET_TOC
3674           && GET_CODE (operands[1]) == SYMBOL_REF
3675           && constant_pool_expr_p (operands[1])
3676           && ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (get_pool_constant (operands[1]),
3677                                               get_pool_mode (operands[1])))
3678         {
3679           operands[1] = create_TOC_reference (operands[1]);
3680         }
3681       else if (mode == Pmode
3682                && CONSTANT_P (operands[1])
3683                && ((GET_CODE (operands[1]) != CONST_INT
3684                     && ! easy_fp_constant (operands[1], mode))
3685                    || (GET_CODE (operands[1]) == CONST_INT
3686                        && num_insns_constant (operands[1], mode) > 2)
3687                    || (GET_CODE (operands[0]) == REG
3688                        && FP_REGNO_P (REGNO (operands[0]))))
3689                && GET_CODE (operands[1]) != HIGH
3690                && ! legitimate_constant_pool_address_p (operands[1])
3691                && ! toc_relative_expr_p (operands[1]))
3692         {
3693           /* Emit a USE operation so that the constant isn't deleted if
3694              expensive optimizations are turned on because nobody
3695              references it.  This should only be done for operands that
3696              contain SYMBOL_REFs with CONSTANT_POOL_ADDRESS_P set.
3697              This should not be done for operands that contain LABEL_REFs.
3698              For now, we just handle the obvious case.  */
3699           if (GET_CODE (operands[1]) != LABEL_REF)
3700             emit_insn (gen_rtx_USE (VOIDmode, operands[1]));
3701
3702 #if TARGET_MACHO
3703           /* Darwin uses a special PIC legitimizer.  */
3704           if (DEFAULT_ABI == ABI_DARWIN && MACHOPIC_INDIRECT)
3705             {
3706               operands[1] =
3707                 rs6000_machopic_legitimize_pic_address (operands[1], mode,
3708                                                         operands[0]);
3709               if (operands[0] != operands[1])
3710                 emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
3711               return;
3712             }
3713 #endif
3714
3715           /* If we are to limit the number of things we put in the TOC and
3716              this is a symbol plus a constant we can add in one insn,
3717              just put the symbol in the TOC and add the constant.  Don't do
3718              this if reload is in progress.  */
3719           if (GET_CODE (operands[1]) == CONST
3720               && TARGET_NO_SUM_IN_TOC && ! reload_in_progress
3721               && GET_CODE (XEXP (operands[1], 0)) == PLUS
3722               && add_operand (XEXP (XEXP (operands[1], 0), 1), mode)
3723               && (GET_CODE (XEXP (XEXP (operands[1], 0), 0)) == LABEL_REF
3724                   || GET_CODE (XEXP (XEXP (operands[1], 0), 0)) == SYMBOL_REF)
3725               && ! side_effects_p (operands[0]))
3726             {
3727               rtx sym =
3728                 force_const_mem (mode, XEXP (XEXP (operands[1], 0), 0));
3729               rtx other = XEXP (XEXP (operands[1], 0), 1);
3730
3731               sym = force_reg (mode, sym);
3732               if (mode == SImode)
3733                 emit_insn (gen_addsi3 (operands[0], sym, other));
3734               else
3735                 emit_insn (gen_adddi3 (operands[0], sym, other));
3736               return;
3737             }
3738
3739           operands[1] = force_const_mem (mode, operands[1]);
3740
3741           if (TARGET_TOC
3742               && constant_pool_expr_p (XEXP (operands[1], 0))
3743               && ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (
3744                         get_pool_constant (XEXP (operands[1], 0)),
3745                         get_pool_mode (XEXP (operands[1], 0))))
3746             {
3747               operands[1]
3748                 = gen_const_mem (mode,
3749                                  create_TOC_reference (XEXP (operands[1], 0)));
3750               set_mem_alias_set (operands[1], get_TOC_alias_set ());
3751             }
3752         }
3753       break;
3754
3755     case TImode:
3756       rs6000_eliminate_indexed_memrefs (operands);
3757
3758       if (TARGET_POWER)
3759         {
3760           emit_insn (gen_rtx_PARALLEL (VOIDmode,
3761                        gen_rtvec (2,
3762                                   gen_rtx_SET (VOIDmode,
3763                                                operands[0], operands[1]),
3764                                   gen_rtx_CLOBBER (VOIDmode,
3765                                                    gen_rtx_SCRATCH (SImode)))));
3766           return;
3767         }
3768       break;
3769
3770     default:
3771       abort ();
3772     }
3773
3774   /* Above, we may have called force_const_mem which may have returned
3775      an invalid address.  If we can, fix this up; otherwise, reload will
3776      have to deal with it.  */
3777   if (GET_CODE (operands[1]) == MEM && ! reload_in_progress)
3778     operands[1] = validize_mem (operands[1]);
3779
3780  emit_set:
3781   emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
3782 }
3783 \f
3784 /* Nonzero if we can use a floating-point register to pass this arg.  */
3785 #define USE_FP_FOR_ARG_P(CUM,MODE,TYPE)         \
3786   (GET_MODE_CLASS (MODE) == MODE_FLOAT          \
3787    && (CUM)->fregno <= FP_ARG_MAX_REG           \
3788    && TARGET_HARD_FLOAT && TARGET_FPRS)
3789
3790 /* Nonzero if we can use an AltiVec register to pass this arg.  */
3791 #define USE_ALTIVEC_FOR_ARG_P(CUM,MODE,TYPE,NAMED)      \
3792   (ALTIVEC_VECTOR_MODE (MODE)                           \
3793    && (CUM)->vregno <= ALTIVEC_ARG_MAX_REG              \
3794    && TARGET_ALTIVEC_ABI                                \
3795    && (NAMED))
3796
3797 /* Return a nonzero value to say to return the function value in
3798    memory, just as large structures are always returned.  TYPE will be
3799    the data type of the value, and FNTYPE will be the type of the
3800    function doing the returning, or @code{NULL} for libcalls.
3801
3802    The AIX ABI for the RS/6000 specifies that all structures are
3803    returned in memory.  The Darwin ABI does the same.  The SVR4 ABI
3804    specifies that structures <= 8 bytes are returned in r3/r4, but a
3805    draft put them in memory, and GCC used to implement the draft
3806    instead of the final standard.  Therefore, TARGET_AIX_STRUCT_RET
3807    controls this instead of DEFAULT_ABI; V.4 targets needing backward
3808    compatibility can change DRAFT_V4_STRUCT_RET to override the
3809    default, and -m switches get the final word.  See
3810    rs6000_override_options for more details.
3811
3812    The PPC32 SVR4 ABI uses IEEE double extended for long double, if 128-bit
3813    long double support is enabled.  These values are returned in memory.
3814
3815    int_size_in_bytes returns -1 for variable size objects, which go in
3816    memory always.  The cast to unsigned makes -1 > 8.  */
3817
3818 static bool
3819 rs6000_return_in_memory (tree type, tree fntype ATTRIBUTE_UNUSED)
3820 {
3821   /* In the darwin64 abi, try to use registers for larger structs
3822      if possible.  */
3823   if (rs6000_darwin64_abi
3824       && TREE_CODE (type) == RECORD_TYPE
3825       && int_size_in_bytes (type) > 0)
3826     {
3827       CUMULATIVE_ARGS valcum;
3828       rtx valret;
3829
3830       valcum.words = 0;
3831       valcum.fregno = FP_ARG_MIN_REG;
3832       valcum.vregno = ALTIVEC_ARG_MIN_REG;
3833       /* Do a trial code generation as if this were going to be passed
3834          as an argument; if any part goes in memory, we return NULL.  */
3835       valret = rs6000_darwin64_record_arg (&valcum, type, 1, true);
3836       if (valret)
3837         return false;
3838       /* Otherwise fall through to more conventional ABI rules.  */
3839     }
3840
3841   if (AGGREGATE_TYPE_P (type)
3842       && (TARGET_AIX_STRUCT_RET
3843           || (unsigned HOST_WIDE_INT) int_size_in_bytes (type) > 8))
3844     return true;
3845
3846   /* Allow -maltivec -mabi=no-altivec without warning.  Altivec vector
3847      modes only exist for GCC vector types if -maltivec.  */
3848   if (TARGET_32BIT && !TARGET_ALTIVEC_ABI
3849       && ALTIVEC_VECTOR_MODE (TYPE_MODE (type)))
3850     return false;
3851
3852   /* Return synthetic vectors in memory.  */
3853   if (TREE_CODE (type) == VECTOR_TYPE
3854       && int_size_in_bytes (type) > (TARGET_ALTIVEC_ABI ? 16 : 8))
3855     {
3856       static bool warned_for_return_big_vectors = false;
3857       if (!warned_for_return_big_vectors)
3858         {
3859           warning ("GCC vector returned by reference: "
3860                    "non-standard ABI extension with no compatibility guarantee");
3861           warned_for_return_big_vectors = true;
3862         }
3863       return true;
3864     }
3865
3866   if (DEFAULT_ABI == ABI_V4 && TYPE_MODE (type) == TFmode)
3867     return true;
3868
3869   return false;
3870 }
3871
3872 /* Initialize a variable CUM of type CUMULATIVE_ARGS
3873    for a call to a function whose data type is FNTYPE.
3874    For a library call, FNTYPE is 0.
3875
3876    For incoming args we set the number of arguments in the prototype large
3877    so we never return a PARALLEL.  */
3878
3879 void
3880 init_cumulative_args (CUMULATIVE_ARGS *cum, tree fntype,
3881                       rtx libname ATTRIBUTE_UNUSED, int incoming,
3882                       int libcall, int n_named_args)
3883 {
3884   static CUMULATIVE_ARGS zero_cumulative;
3885
3886   *cum = zero_cumulative;
3887   cum->words = 0;
3888   cum->fregno = FP_ARG_MIN_REG;
3889   cum->vregno = ALTIVEC_ARG_MIN_REG;
3890   cum->prototype = (fntype && TYPE_ARG_TYPES (fntype));
3891   cum->call_cookie = ((DEFAULT_ABI == ABI_V4 && libcall)
3892                       ? CALL_LIBCALL : CALL_NORMAL);
3893   cum->sysv_gregno = GP_ARG_MIN_REG;
3894   cum->stdarg = fntype
3895     && (TYPE_ARG_TYPES (fntype) != 0
3896         && (TREE_VALUE (tree_last  (TYPE_ARG_TYPES (fntype)))
3897             != void_type_node));
3898
3899   cum->nargs_prototype = 0;
3900   if (incoming || cum->prototype)
3901     cum->nargs_prototype = n_named_args;
3902
3903   /* Check for a longcall attribute.  */
3904   if ((!fntype && rs6000_default_long_calls)
3905       || (fntype
3906           && lookup_attribute ("longcall", TYPE_ATTRIBUTES (fntype))
3907           && !lookup_attribute ("shortcall", TYPE_ATTRIBUTES (fntype))))
3908     cum->call_cookie |= CALL_LONG;
3909
3910   if (TARGET_DEBUG_ARG)
3911     {
3912       fprintf (stderr, "\ninit_cumulative_args:");
3913       if (fntype)
3914         {
3915           tree ret_type = TREE_TYPE (fntype);
3916           fprintf (stderr, " ret code = %s,",
3917                    tree_code_name[ (int)TREE_CODE (ret_type) ]);
3918         }
3919
3920       if (cum->call_cookie & CALL_LONG)
3921         fprintf (stderr, " longcall,");
3922
3923       fprintf (stderr, " proto = %d, nargs = %d\n",
3924                cum->prototype, cum->nargs_prototype);
3925     }
3926
3927   if (fntype
3928       && !TARGET_ALTIVEC
3929       && TARGET_ALTIVEC_ABI
3930       && ALTIVEC_VECTOR_MODE (TYPE_MODE (TREE_TYPE (fntype))))
3931     {
3932       error ("Cannot return value in vector register because"
3933              " altivec instructions are disabled, use -maltivec"
3934              " to enable them.");
3935     }
3936 }
3937 \f
3938 /* Return true if TYPE must be passed on the stack and not in registers.  */
3939
3940 static bool
3941 rs6000_must_pass_in_stack (enum machine_mode mode, tree type)
3942 {
3943   if (DEFAULT_ABI == ABI_AIX || TARGET_64BIT)
3944     return must_pass_in_stack_var_size (mode, type);
3945   else
3946     return must_pass_in_stack_var_size_or_pad (mode, type);
3947 }
3948
3949 /* If defined, a C expression which determines whether, and in which
3950    direction, to pad out an argument with extra space.  The value
3951    should be of type `enum direction': either `upward' to pad above
3952    the argument, `downward' to pad below, or `none' to inhibit
3953    padding.
3954
3955    For the AIX ABI structs are always stored left shifted in their
3956    argument slot.  */
3957
3958 enum direction
3959 function_arg_padding (enum machine_mode mode, tree type)
3960 {
3961 #ifndef AGGREGATE_PADDING_FIXED
3962 #define AGGREGATE_PADDING_FIXED 0
3963 #endif
3964 #ifndef AGGREGATES_PAD_UPWARD_ALWAYS
3965 #define AGGREGATES_PAD_UPWARD_ALWAYS 0
3966 #endif
3967
3968   if (!AGGREGATE_PADDING_FIXED)
3969     {
3970       /* GCC used to pass structures of the same size as integer types as
3971          if they were in fact integers, ignoring FUNCTION_ARG_PADDING.
3972          i.e. Structures of size 1 or 2 (or 4 when TARGET_64BIT) were
3973          passed padded downward, except that -mstrict-align further
3974          muddied the water in that multi-component structures of 2 and 4
3975          bytes in size&nbs