OSDN Git Service

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