OSDN Git Service

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