OSDN Git Service

Delete remaining references to sparc little-endian support.
[pf3gnuchains/gcc-fork.git] / gcc / config / sparc / sparc.c
1 /* Subroutines for insn-output.c for SPARC.
2    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
4    2011
5    Free Software Foundation, Inc.
6    Contributed by Michael Tiemann (tiemann@cygnus.com)
7    64-bit SPARC-V9 support by Michael Tiemann, Jim Wilson, and Doug Evans,
8    at Cygnus Support.
9
10 This file is part of GCC.
11
12 GCC is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 3, or (at your option)
15 any later version.
16
17 GCC is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20 GNU General Public License for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with GCC; see the file COPYING3.  If not see
24 <http://www.gnu.org/licenses/>.  */
25
26 #include "config.h"
27 #include "system.h"
28 #include "coretypes.h"
29 #include "tm.h"
30 #include "tree.h"
31 #include "rtl.h"
32 #include "regs.h"
33 #include "hard-reg-set.h"
34 #include "insn-config.h"
35 #include "insn-codes.h"
36 #include "conditions.h"
37 #include "output.h"
38 #include "insn-attr.h"
39 #include "flags.h"
40 #include "function.h"
41 #include "except.h"
42 #include "expr.h"
43 #include "optabs.h"
44 #include "recog.h"
45 #include "diagnostic-core.h"
46 #include "ggc.h"
47 #include "tm_p.h"
48 #include "debug.h"
49 #include "target.h"
50 #include "target-def.h"
51 #include "common/common-target.h"
52 #include "cfglayout.h"
53 #include "gimple.h"
54 #include "langhooks.h"
55 #include "reload.h"
56 #include "params.h"
57 #include "df.h"
58 #include "dwarf2out.h"
59 #include "opts.h"
60
61 /* Processor costs */
62
63 struct processor_costs {
64   /* Integer load */
65   const int int_load;
66
67   /* Integer signed load */
68   const int int_sload;
69
70   /* Integer zeroed load */
71   const int int_zload;
72
73   /* Float load */
74   const int float_load;
75
76   /* fmov, fneg, fabs */
77   const int float_move;
78
79   /* fadd, fsub */
80   const int float_plusminus;
81
82   /* fcmp */
83   const int float_cmp;
84
85   /* fmov, fmovr */
86   const int float_cmove;
87
88   /* fmul */
89   const int float_mul;
90
91   /* fdivs */
92   const int float_div_sf;
93
94   /* fdivd */
95   const int float_div_df;
96
97   /* fsqrts */
98   const int float_sqrt_sf;
99
100   /* fsqrtd */
101   const int float_sqrt_df;
102
103   /* umul/smul */
104   const int int_mul;
105
106   /* mulX */
107   const int int_mulX;
108
109   /* integer multiply cost for each bit set past the most
110      significant 3, so the formula for multiply cost becomes:
111
112         if (rs1 < 0)
113           highest_bit = highest_clear_bit(rs1);
114         else
115           highest_bit = highest_set_bit(rs1);
116         if (highest_bit < 3)
117           highest_bit = 3;
118         cost = int_mul{,X} + ((highest_bit - 3) / int_mul_bit_factor);
119
120      A value of zero indicates that the multiply costs is fixed,
121      and not variable.  */
122   const int int_mul_bit_factor;
123
124   /* udiv/sdiv */
125   const int int_div;
126
127   /* divX */
128   const int int_divX;
129
130   /* movcc, movr */
131   const int int_cmove;
132
133   /* penalty for shifts, due to scheduling rules etc. */
134   const int shift_penalty;
135 };
136
137 static const
138 struct processor_costs cypress_costs = {
139   COSTS_N_INSNS (2), /* int load */
140   COSTS_N_INSNS (2), /* int signed load */
141   COSTS_N_INSNS (2), /* int zeroed load */
142   COSTS_N_INSNS (2), /* float load */
143   COSTS_N_INSNS (5), /* fmov, fneg, fabs */
144   COSTS_N_INSNS (5), /* fadd, fsub */
145   COSTS_N_INSNS (1), /* fcmp */
146   COSTS_N_INSNS (1), /* fmov, fmovr */
147   COSTS_N_INSNS (7), /* fmul */
148   COSTS_N_INSNS (37), /* fdivs */
149   COSTS_N_INSNS (37), /* fdivd */
150   COSTS_N_INSNS (63), /* fsqrts */
151   COSTS_N_INSNS (63), /* fsqrtd */
152   COSTS_N_INSNS (1), /* imul */
153   COSTS_N_INSNS (1), /* imulX */
154   0, /* imul bit factor */
155   COSTS_N_INSNS (1), /* idiv */
156   COSTS_N_INSNS (1), /* idivX */
157   COSTS_N_INSNS (1), /* movcc/movr */
158   0, /* shift penalty */
159 };
160
161 static const
162 struct processor_costs supersparc_costs = {
163   COSTS_N_INSNS (1), /* int load */
164   COSTS_N_INSNS (1), /* int signed load */
165   COSTS_N_INSNS (1), /* int zeroed load */
166   COSTS_N_INSNS (0), /* float load */
167   COSTS_N_INSNS (3), /* fmov, fneg, fabs */
168   COSTS_N_INSNS (3), /* fadd, fsub */
169   COSTS_N_INSNS (3), /* fcmp */
170   COSTS_N_INSNS (1), /* fmov, fmovr */
171   COSTS_N_INSNS (3), /* fmul */
172   COSTS_N_INSNS (6), /* fdivs */
173   COSTS_N_INSNS (9), /* fdivd */
174   COSTS_N_INSNS (12), /* fsqrts */
175   COSTS_N_INSNS (12), /* fsqrtd */
176   COSTS_N_INSNS (4), /* imul */
177   COSTS_N_INSNS (4), /* imulX */
178   0, /* imul bit factor */
179   COSTS_N_INSNS (4), /* idiv */
180   COSTS_N_INSNS (4), /* idivX */
181   COSTS_N_INSNS (1), /* movcc/movr */
182   1, /* shift penalty */
183 };
184
185 static const
186 struct processor_costs hypersparc_costs = {
187   COSTS_N_INSNS (1), /* int load */
188   COSTS_N_INSNS (1), /* int signed load */
189   COSTS_N_INSNS (1), /* int zeroed load */
190   COSTS_N_INSNS (1), /* float load */
191   COSTS_N_INSNS (1), /* fmov, fneg, fabs */
192   COSTS_N_INSNS (1), /* fadd, fsub */
193   COSTS_N_INSNS (1), /* fcmp */
194   COSTS_N_INSNS (1), /* fmov, fmovr */
195   COSTS_N_INSNS (1), /* fmul */
196   COSTS_N_INSNS (8), /* fdivs */
197   COSTS_N_INSNS (12), /* fdivd */
198   COSTS_N_INSNS (17), /* fsqrts */
199   COSTS_N_INSNS (17), /* fsqrtd */
200   COSTS_N_INSNS (17), /* imul */
201   COSTS_N_INSNS (17), /* imulX */
202   0, /* imul bit factor */
203   COSTS_N_INSNS (17), /* idiv */
204   COSTS_N_INSNS (17), /* idivX */
205   COSTS_N_INSNS (1), /* movcc/movr */
206   0, /* shift penalty */
207 };
208
209 static const
210 struct processor_costs leon_costs = {
211   COSTS_N_INSNS (1), /* int load */
212   COSTS_N_INSNS (1), /* int signed load */
213   COSTS_N_INSNS (1), /* int zeroed load */
214   COSTS_N_INSNS (1), /* float load */
215   COSTS_N_INSNS (1), /* fmov, fneg, fabs */
216   COSTS_N_INSNS (1), /* fadd, fsub */
217   COSTS_N_INSNS (1), /* fcmp */
218   COSTS_N_INSNS (1), /* fmov, fmovr */
219   COSTS_N_INSNS (1), /* fmul */
220   COSTS_N_INSNS (15), /* fdivs */
221   COSTS_N_INSNS (15), /* fdivd */
222   COSTS_N_INSNS (23), /* fsqrts */
223   COSTS_N_INSNS (23), /* fsqrtd */
224   COSTS_N_INSNS (5), /* imul */
225   COSTS_N_INSNS (5), /* imulX */
226   0, /* imul bit factor */
227   COSTS_N_INSNS (5), /* idiv */
228   COSTS_N_INSNS (5), /* idivX */
229   COSTS_N_INSNS (1), /* movcc/movr */
230   0, /* shift penalty */
231 };
232
233 static const
234 struct processor_costs sparclet_costs = {
235   COSTS_N_INSNS (3), /* int load */
236   COSTS_N_INSNS (3), /* int signed load */
237   COSTS_N_INSNS (1), /* int zeroed load */
238   COSTS_N_INSNS (1), /* float load */
239   COSTS_N_INSNS (1), /* fmov, fneg, fabs */
240   COSTS_N_INSNS (1), /* fadd, fsub */
241   COSTS_N_INSNS (1), /* fcmp */
242   COSTS_N_INSNS (1), /* fmov, fmovr */
243   COSTS_N_INSNS (1), /* fmul */
244   COSTS_N_INSNS (1), /* fdivs */
245   COSTS_N_INSNS (1), /* fdivd */
246   COSTS_N_INSNS (1), /* fsqrts */
247   COSTS_N_INSNS (1), /* fsqrtd */
248   COSTS_N_INSNS (5), /* imul */
249   COSTS_N_INSNS (5), /* imulX */
250   0, /* imul bit factor */
251   COSTS_N_INSNS (5), /* idiv */
252   COSTS_N_INSNS (5), /* idivX */
253   COSTS_N_INSNS (1), /* movcc/movr */
254   0, /* shift penalty */
255 };
256
257 static const
258 struct processor_costs ultrasparc_costs = {
259   COSTS_N_INSNS (2), /* int load */
260   COSTS_N_INSNS (3), /* int signed load */
261   COSTS_N_INSNS (2), /* int zeroed load */
262   COSTS_N_INSNS (2), /* float load */
263   COSTS_N_INSNS (1), /* fmov, fneg, fabs */
264   COSTS_N_INSNS (4), /* fadd, fsub */
265   COSTS_N_INSNS (1), /* fcmp */
266   COSTS_N_INSNS (2), /* fmov, fmovr */
267   COSTS_N_INSNS (4), /* fmul */
268   COSTS_N_INSNS (13), /* fdivs */
269   COSTS_N_INSNS (23), /* fdivd */
270   COSTS_N_INSNS (13), /* fsqrts */
271   COSTS_N_INSNS (23), /* fsqrtd */
272   COSTS_N_INSNS (4), /* imul */
273   COSTS_N_INSNS (4), /* imulX */
274   2, /* imul bit factor */
275   COSTS_N_INSNS (37), /* idiv */
276   COSTS_N_INSNS (68), /* idivX */
277   COSTS_N_INSNS (2), /* movcc/movr */
278   2, /* shift penalty */
279 };
280
281 static const
282 struct processor_costs ultrasparc3_costs = {
283   COSTS_N_INSNS (2), /* int load */
284   COSTS_N_INSNS (3), /* int signed load */
285   COSTS_N_INSNS (3), /* int zeroed load */
286   COSTS_N_INSNS (2), /* float load */
287   COSTS_N_INSNS (3), /* fmov, fneg, fabs */
288   COSTS_N_INSNS (4), /* fadd, fsub */
289   COSTS_N_INSNS (5), /* fcmp */
290   COSTS_N_INSNS (3), /* fmov, fmovr */
291   COSTS_N_INSNS (4), /* fmul */
292   COSTS_N_INSNS (17), /* fdivs */
293   COSTS_N_INSNS (20), /* fdivd */
294   COSTS_N_INSNS (20), /* fsqrts */
295   COSTS_N_INSNS (29), /* fsqrtd */
296   COSTS_N_INSNS (6), /* imul */
297   COSTS_N_INSNS (6), /* imulX */
298   0, /* imul bit factor */
299   COSTS_N_INSNS (40), /* idiv */
300   COSTS_N_INSNS (71), /* idivX */
301   COSTS_N_INSNS (2), /* movcc/movr */
302   0, /* shift penalty */
303 };
304
305 static const
306 struct processor_costs niagara_costs = {
307   COSTS_N_INSNS (3), /* int load */
308   COSTS_N_INSNS (3), /* int signed load */
309   COSTS_N_INSNS (3), /* int zeroed load */
310   COSTS_N_INSNS (9), /* float load */
311   COSTS_N_INSNS (8), /* fmov, fneg, fabs */
312   COSTS_N_INSNS (8), /* fadd, fsub */
313   COSTS_N_INSNS (26), /* fcmp */
314   COSTS_N_INSNS (8), /* fmov, fmovr */
315   COSTS_N_INSNS (29), /* fmul */
316   COSTS_N_INSNS (54), /* fdivs */
317   COSTS_N_INSNS (83), /* fdivd */
318   COSTS_N_INSNS (100), /* fsqrts - not implemented in hardware */
319   COSTS_N_INSNS (100), /* fsqrtd - not implemented in hardware */
320   COSTS_N_INSNS (11), /* imul */
321   COSTS_N_INSNS (11), /* imulX */
322   0, /* imul bit factor */
323   COSTS_N_INSNS (72), /* idiv */
324   COSTS_N_INSNS (72), /* idivX */
325   COSTS_N_INSNS (1), /* movcc/movr */
326   0, /* shift penalty */
327 };
328
329 static const
330 struct processor_costs niagara2_costs = {
331   COSTS_N_INSNS (3), /* int load */
332   COSTS_N_INSNS (3), /* int signed load */
333   COSTS_N_INSNS (3), /* int zeroed load */
334   COSTS_N_INSNS (3), /* float load */
335   COSTS_N_INSNS (6), /* fmov, fneg, fabs */
336   COSTS_N_INSNS (6), /* fadd, fsub */
337   COSTS_N_INSNS (6), /* fcmp */
338   COSTS_N_INSNS (6), /* fmov, fmovr */
339   COSTS_N_INSNS (6), /* fmul */
340   COSTS_N_INSNS (19), /* fdivs */
341   COSTS_N_INSNS (33), /* fdivd */
342   COSTS_N_INSNS (19), /* fsqrts */
343   COSTS_N_INSNS (33), /* fsqrtd */
344   COSTS_N_INSNS (5), /* imul */
345   COSTS_N_INSNS (5), /* imulX */
346   0, /* imul bit factor */
347   COSTS_N_INSNS (26), /* idiv, average of 12 - 41 cycle range */
348   COSTS_N_INSNS (26), /* idivX, average of 12 - 41 cycle range */
349   COSTS_N_INSNS (1), /* movcc/movr */
350   0, /* shift penalty */
351 };
352
353 static const
354 struct processor_costs niagara3_costs = {
355   COSTS_N_INSNS (3), /* int load */
356   COSTS_N_INSNS (3), /* int signed load */
357   COSTS_N_INSNS (3), /* int zeroed load */
358   COSTS_N_INSNS (3), /* float load */
359   COSTS_N_INSNS (9), /* fmov, fneg, fabs */
360   COSTS_N_INSNS (9), /* fadd, fsub */
361   COSTS_N_INSNS (9), /* fcmp */
362   COSTS_N_INSNS (9), /* fmov, fmovr */
363   COSTS_N_INSNS (9), /* fmul */
364   COSTS_N_INSNS (23), /* fdivs */
365   COSTS_N_INSNS (37), /* fdivd */
366   COSTS_N_INSNS (23), /* fsqrts */
367   COSTS_N_INSNS (37), /* fsqrtd */
368   COSTS_N_INSNS (9), /* imul */
369   COSTS_N_INSNS (9), /* imulX */
370   0, /* imul bit factor */
371   COSTS_N_INSNS (31), /* idiv, average of 17 - 45 cycle range */
372   COSTS_N_INSNS (30), /* idivX, average of 16 - 44 cycle range */
373   COSTS_N_INSNS (1), /* movcc/movr */
374   0, /* shift penalty */
375 };
376
377 static const struct processor_costs *sparc_costs = &cypress_costs;
378
379 #ifdef HAVE_AS_RELAX_OPTION
380 /* If 'as' and 'ld' are relaxing tail call insns into branch always, use
381    "or %o7,%g0,X; call Y; or X,%g0,%o7" always, so that it can be optimized.
382    With sethi/jmp, neither 'as' nor 'ld' has an easy way how to find out if
383    somebody does not branch between the sethi and jmp.  */
384 #define LEAF_SIBCALL_SLOT_RESERVED_P 1
385 #else
386 #define LEAF_SIBCALL_SLOT_RESERVED_P \
387   ((TARGET_ARCH64 && !TARGET_CM_MEDLOW) || flag_pic)
388 #endif
389
390 /* Vector to say how input registers are mapped to output registers.
391    HARD_FRAME_POINTER_REGNUM cannot be remapped by this function to
392    eliminate it.  You must use -fomit-frame-pointer to get that.  */
393 char leaf_reg_remap[] =
394 { 0, 1, 2, 3, 4, 5, 6, 7,
395   -1, -1, -1, -1, -1, -1, 14, -1,
396   -1, -1, -1, -1, -1, -1, -1, -1,
397   8, 9, 10, 11, 12, 13, -1, 15,
398
399   32, 33, 34, 35, 36, 37, 38, 39,
400   40, 41, 42, 43, 44, 45, 46, 47,
401   48, 49, 50, 51, 52, 53, 54, 55,
402   56, 57, 58, 59, 60, 61, 62, 63,
403   64, 65, 66, 67, 68, 69, 70, 71,
404   72, 73, 74, 75, 76, 77, 78, 79,
405   80, 81, 82, 83, 84, 85, 86, 87,
406   88, 89, 90, 91, 92, 93, 94, 95,
407   96, 97, 98, 99, 100, 101, 102};
408
409 /* Vector, indexed by hard register number, which contains 1
410    for a register that is allowable in a candidate for leaf
411    function treatment.  */
412 char sparc_leaf_regs[] =
413 { 1, 1, 1, 1, 1, 1, 1, 1,
414   0, 0, 0, 0, 0, 0, 1, 0,
415   0, 0, 0, 0, 0, 0, 0, 0,
416   1, 1, 1, 1, 1, 1, 0, 1,
417   1, 1, 1, 1, 1, 1, 1, 1,
418   1, 1, 1, 1, 1, 1, 1, 1,
419   1, 1, 1, 1, 1, 1, 1, 1,
420   1, 1, 1, 1, 1, 1, 1, 1,
421   1, 1, 1, 1, 1, 1, 1, 1,
422   1, 1, 1, 1, 1, 1, 1, 1,
423   1, 1, 1, 1, 1, 1, 1, 1,
424   1, 1, 1, 1, 1, 1, 1, 1,
425   1, 1, 1, 1, 1, 1, 1};
426
427 struct GTY(()) machine_function
428 {
429   /* Size of the frame of the function.  */
430   HOST_WIDE_INT frame_size;
431
432   /* Size of the frame of the function minus the register window save area
433      and the outgoing argument area.  */
434   HOST_WIDE_INT apparent_frame_size;
435
436   /* Register we pretend the frame pointer is allocated to.  Normally, this
437      is %fp, but if we are in a leaf procedure, this is (%sp + offset).  We
438      record "offset" separately as it may be too big for (reg + disp).  */
439   rtx frame_base_reg;
440   HOST_WIDE_INT frame_base_offset;
441
442   /* Some local-dynamic TLS symbol name.  */
443   const char *some_ld_name;
444
445   /* Number of global or FP registers to be saved (as 4-byte quantities).  */
446   int n_global_fp_regs;
447
448   /* True if the current function is leaf and uses only leaf regs,
449      so that the SPARC leaf function optimization can be applied.
450      Private version of current_function_uses_only_leaf_regs, see
451      sparc_expand_prologue for the rationale.  */
452   int leaf_function_p;
453
454   /* True if the prologue saves local or in registers.  */
455   bool save_local_in_regs_p;
456
457   /* True if the data calculated by sparc_expand_prologue are valid.  */
458   bool prologue_data_valid_p;
459 };
460
461 #define sparc_frame_size                cfun->machine->frame_size
462 #define sparc_apparent_frame_size       cfun->machine->apparent_frame_size
463 #define sparc_frame_base_reg            cfun->machine->frame_base_reg
464 #define sparc_frame_base_offset         cfun->machine->frame_base_offset
465 #define sparc_n_global_fp_regs          cfun->machine->n_global_fp_regs
466 #define sparc_leaf_function_p           cfun->machine->leaf_function_p
467 #define sparc_save_local_in_regs_p      cfun->machine->save_local_in_regs_p
468 #define sparc_prologue_data_valid_p     cfun->machine->prologue_data_valid_p
469
470 /* 1 if the next opcode is to be specially indented.  */
471 int sparc_indent_opcode = 0;
472
473 static void sparc_option_override (void);
474 static void sparc_init_modes (void);
475 static void scan_record_type (const_tree, int *, int *, int *);
476 static int function_arg_slotno (const CUMULATIVE_ARGS *, enum machine_mode,
477                                 const_tree, bool, bool, int *, int *);
478
479 static int supersparc_adjust_cost (rtx, rtx, rtx, int);
480 static int hypersparc_adjust_cost (rtx, rtx, rtx, int);
481
482 static void sparc_emit_set_const32 (rtx, rtx);
483 static void sparc_emit_set_const64 (rtx, rtx);
484 static void sparc_output_addr_vec (rtx);
485 static void sparc_output_addr_diff_vec (rtx);
486 static void sparc_output_deferred_case_vectors (void);
487 static bool sparc_legitimate_address_p (enum machine_mode, rtx, bool);
488 static bool sparc_legitimate_constant_p (enum machine_mode, rtx);
489 static rtx sparc_builtin_saveregs (void);
490 static int epilogue_renumber (rtx *, int);
491 static bool sparc_assemble_integer (rtx, unsigned int, int);
492 static int set_extends (rtx);
493 static void sparc_asm_function_prologue (FILE *, HOST_WIDE_INT);
494 static void sparc_asm_function_epilogue (FILE *, HOST_WIDE_INT);
495 #ifdef TARGET_SOLARIS
496 static void sparc_solaris_elf_asm_named_section (const char *, unsigned int,
497                                                  tree) ATTRIBUTE_UNUSED;
498 #endif
499 static int sparc_adjust_cost (rtx, rtx, rtx, int);
500 static int sparc_issue_rate (void);
501 static void sparc_sched_init (FILE *, int, int);
502 static int sparc_use_sched_lookahead (void);
503
504 static void emit_soft_tfmode_libcall (const char *, int, rtx *);
505 static void emit_soft_tfmode_binop (enum rtx_code, rtx *);
506 static void emit_soft_tfmode_unop (enum rtx_code, rtx *);
507 static void emit_soft_tfmode_cvt (enum rtx_code, rtx *);
508 static void emit_hard_tfmode_operation (enum rtx_code, rtx *);
509
510 static bool sparc_function_ok_for_sibcall (tree, tree);
511 static void sparc_init_libfuncs (void);
512 static void sparc_init_builtins (void);
513 static void sparc_vis_init_builtins (void);
514 static rtx sparc_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
515 static tree sparc_fold_builtin (tree, int, tree *, bool);
516 static int sparc_vis_mul8x16 (int, int);
517 static tree sparc_handle_vis_mul8x16 (int, tree, tree, tree);
518 static void sparc_output_mi_thunk (FILE *, tree, HOST_WIDE_INT,
519                                    HOST_WIDE_INT, tree);
520 static bool sparc_can_output_mi_thunk (const_tree, HOST_WIDE_INT,
521                                        HOST_WIDE_INT, const_tree);
522 static void sparc_reorg (void);
523 static struct machine_function * sparc_init_machine_status (void);
524 static bool sparc_cannot_force_const_mem (enum machine_mode, rtx);
525 static rtx sparc_tls_get_addr (void);
526 static rtx sparc_tls_got (void);
527 static const char *get_some_local_dynamic_name (void);
528 static int get_some_local_dynamic_name_1 (rtx *, void *);
529 static int sparc_register_move_cost (enum machine_mode,
530                                      reg_class_t, reg_class_t);
531 static bool sparc_rtx_costs (rtx, int, int, int, int *, bool);
532 static rtx sparc_function_value (const_tree, const_tree, bool);
533 static rtx sparc_libcall_value (enum machine_mode, const_rtx);
534 static bool sparc_function_value_regno_p (const unsigned int);
535 static rtx sparc_struct_value_rtx (tree, int);
536 static enum machine_mode sparc_promote_function_mode (const_tree, enum machine_mode,
537                                                       int *, const_tree, int);
538 static bool sparc_return_in_memory (const_tree, const_tree);
539 static bool sparc_strict_argument_naming (cumulative_args_t);
540 static void sparc_va_start (tree, rtx);
541 static tree sparc_gimplify_va_arg (tree, tree, gimple_seq *, gimple_seq *);
542 static bool sparc_vector_mode_supported_p (enum machine_mode);
543 static bool sparc_tls_referenced_p (rtx);
544 static rtx sparc_legitimize_tls_address (rtx);
545 static rtx sparc_legitimize_pic_address (rtx, rtx);
546 static rtx sparc_legitimize_address (rtx, rtx, enum machine_mode);
547 static rtx sparc_delegitimize_address (rtx);
548 static bool sparc_mode_dependent_address_p (const_rtx);
549 static bool sparc_pass_by_reference (cumulative_args_t,
550                                      enum machine_mode, const_tree, bool);
551 static void sparc_function_arg_advance (cumulative_args_t,
552                                         enum machine_mode, const_tree, bool);
553 static rtx sparc_function_arg_1 (cumulative_args_t,
554                                  enum machine_mode, const_tree, bool, bool);
555 static rtx sparc_function_arg (cumulative_args_t,
556                                enum machine_mode, const_tree, bool);
557 static rtx sparc_function_incoming_arg (cumulative_args_t,
558                                         enum machine_mode, const_tree, bool);
559 static unsigned int sparc_function_arg_boundary (enum machine_mode,
560                                                  const_tree);
561 static int sparc_arg_partial_bytes (cumulative_args_t,
562                                     enum machine_mode, tree, bool);
563 static void sparc_output_dwarf_dtprel (FILE *, int, rtx) ATTRIBUTE_UNUSED;
564 static void sparc_file_end (void);
565 static bool sparc_frame_pointer_required (void);
566 static bool sparc_can_eliminate (const int, const int);
567 static rtx sparc_builtin_setjmp_frame_value (void);
568 static void sparc_conditional_register_usage (void);
569 #ifdef TARGET_ALTERNATE_LONG_DOUBLE_MANGLING
570 static const char *sparc_mangle_type (const_tree);
571 #endif
572 static void sparc_trampoline_init (rtx, tree, rtx);
573 static enum machine_mode sparc_preferred_simd_mode (enum machine_mode);
574 static reg_class_t sparc_preferred_reload_class (rtx x, reg_class_t rclass);
575 static bool sparc_print_operand_punct_valid_p (unsigned char);
576 static void sparc_print_operand (FILE *, rtx, int);
577 static void sparc_print_operand_address (FILE *, rtx);
578 static reg_class_t sparc_secondary_reload (bool, rtx, reg_class_t,
579                                            enum machine_mode, secondary_reload_info *);
580 \f
581 #ifdef SUBTARGET_ATTRIBUTE_TABLE
582 /* Table of valid machine attributes.  */
583 static const struct attribute_spec sparc_attribute_table[] =
584 {
585   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
586        do_diagnostic } */
587   SUBTARGET_ATTRIBUTE_TABLE,
588   { NULL,        0, 0, false, false, false, NULL, false }
589 };
590 #endif
591 \f
592 /* Option handling.  */
593
594 /* Parsed value.  */
595 enum cmodel sparc_cmodel;
596
597 char sparc_hard_reg_printed[8];
598
599 /* Initialize the GCC target structure.  */
600
601 /* The default is to use .half rather than .short for aligned HI objects.  */
602 #undef TARGET_ASM_ALIGNED_HI_OP
603 #define TARGET_ASM_ALIGNED_HI_OP "\t.half\t"
604
605 #undef TARGET_ASM_UNALIGNED_HI_OP
606 #define TARGET_ASM_UNALIGNED_HI_OP "\t.uahalf\t"
607 #undef TARGET_ASM_UNALIGNED_SI_OP
608 #define TARGET_ASM_UNALIGNED_SI_OP "\t.uaword\t"
609 #undef TARGET_ASM_UNALIGNED_DI_OP
610 #define TARGET_ASM_UNALIGNED_DI_OP "\t.uaxword\t"
611
612 /* The target hook has to handle DI-mode values.  */
613 #undef TARGET_ASM_INTEGER
614 #define TARGET_ASM_INTEGER sparc_assemble_integer
615
616 #undef TARGET_ASM_FUNCTION_PROLOGUE
617 #define TARGET_ASM_FUNCTION_PROLOGUE sparc_asm_function_prologue
618 #undef TARGET_ASM_FUNCTION_EPILOGUE
619 #define TARGET_ASM_FUNCTION_EPILOGUE sparc_asm_function_epilogue
620
621 #undef TARGET_SCHED_ADJUST_COST
622 #define TARGET_SCHED_ADJUST_COST sparc_adjust_cost
623 #undef TARGET_SCHED_ISSUE_RATE
624 #define TARGET_SCHED_ISSUE_RATE sparc_issue_rate
625 #undef TARGET_SCHED_INIT
626 #define TARGET_SCHED_INIT sparc_sched_init
627 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
628 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD sparc_use_sched_lookahead
629
630 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
631 #define TARGET_FUNCTION_OK_FOR_SIBCALL sparc_function_ok_for_sibcall
632
633 #undef TARGET_INIT_LIBFUNCS
634 #define TARGET_INIT_LIBFUNCS sparc_init_libfuncs
635 #undef TARGET_INIT_BUILTINS
636 #define TARGET_INIT_BUILTINS sparc_init_builtins
637
638 #undef TARGET_LEGITIMIZE_ADDRESS
639 #define TARGET_LEGITIMIZE_ADDRESS sparc_legitimize_address
640 #undef TARGET_DELEGITIMIZE_ADDRESS
641 #define TARGET_DELEGITIMIZE_ADDRESS sparc_delegitimize_address
642 #undef TARGET_MODE_DEPENDENT_ADDRESS_P
643 #define TARGET_MODE_DEPENDENT_ADDRESS_P sparc_mode_dependent_address_p
644
645 #undef TARGET_EXPAND_BUILTIN
646 #define TARGET_EXPAND_BUILTIN sparc_expand_builtin
647 #undef TARGET_FOLD_BUILTIN
648 #define TARGET_FOLD_BUILTIN sparc_fold_builtin
649
650 #if TARGET_TLS
651 #undef TARGET_HAVE_TLS
652 #define TARGET_HAVE_TLS true
653 #endif
654
655 #undef TARGET_CANNOT_FORCE_CONST_MEM
656 #define TARGET_CANNOT_FORCE_CONST_MEM sparc_cannot_force_const_mem
657
658 #undef TARGET_ASM_OUTPUT_MI_THUNK
659 #define TARGET_ASM_OUTPUT_MI_THUNK sparc_output_mi_thunk
660 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
661 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK sparc_can_output_mi_thunk
662
663 #undef TARGET_MACHINE_DEPENDENT_REORG
664 #define TARGET_MACHINE_DEPENDENT_REORG sparc_reorg
665
666 #undef TARGET_RTX_COSTS
667 #define TARGET_RTX_COSTS sparc_rtx_costs
668 #undef TARGET_ADDRESS_COST
669 #define TARGET_ADDRESS_COST hook_int_rtx_bool_0
670 #undef TARGET_REGISTER_MOVE_COST
671 #define TARGET_REGISTER_MOVE_COST sparc_register_move_cost
672
673 #undef TARGET_PROMOTE_FUNCTION_MODE
674 #define TARGET_PROMOTE_FUNCTION_MODE sparc_promote_function_mode
675
676 #undef TARGET_FUNCTION_VALUE
677 #define TARGET_FUNCTION_VALUE sparc_function_value
678 #undef TARGET_LIBCALL_VALUE
679 #define TARGET_LIBCALL_VALUE sparc_libcall_value
680 #undef TARGET_FUNCTION_VALUE_REGNO_P
681 #define TARGET_FUNCTION_VALUE_REGNO_P sparc_function_value_regno_p
682
683 #undef TARGET_STRUCT_VALUE_RTX
684 #define TARGET_STRUCT_VALUE_RTX sparc_struct_value_rtx
685 #undef TARGET_RETURN_IN_MEMORY
686 #define TARGET_RETURN_IN_MEMORY sparc_return_in_memory
687 #undef TARGET_MUST_PASS_IN_STACK
688 #define TARGET_MUST_PASS_IN_STACK must_pass_in_stack_var_size
689 #undef TARGET_PASS_BY_REFERENCE
690 #define TARGET_PASS_BY_REFERENCE sparc_pass_by_reference
691 #undef TARGET_ARG_PARTIAL_BYTES
692 #define TARGET_ARG_PARTIAL_BYTES sparc_arg_partial_bytes
693 #undef TARGET_FUNCTION_ARG_ADVANCE
694 #define TARGET_FUNCTION_ARG_ADVANCE sparc_function_arg_advance
695 #undef TARGET_FUNCTION_ARG
696 #define TARGET_FUNCTION_ARG sparc_function_arg
697 #undef TARGET_FUNCTION_INCOMING_ARG
698 #define TARGET_FUNCTION_INCOMING_ARG sparc_function_incoming_arg
699 #undef TARGET_FUNCTION_ARG_BOUNDARY
700 #define TARGET_FUNCTION_ARG_BOUNDARY sparc_function_arg_boundary
701
702 #undef TARGET_EXPAND_BUILTIN_SAVEREGS
703 #define TARGET_EXPAND_BUILTIN_SAVEREGS sparc_builtin_saveregs
704 #undef TARGET_STRICT_ARGUMENT_NAMING
705 #define TARGET_STRICT_ARGUMENT_NAMING sparc_strict_argument_naming
706
707 #undef TARGET_EXPAND_BUILTIN_VA_START
708 #define TARGET_EXPAND_BUILTIN_VA_START sparc_va_start
709 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
710 #define TARGET_GIMPLIFY_VA_ARG_EXPR sparc_gimplify_va_arg
711
712 #undef TARGET_VECTOR_MODE_SUPPORTED_P
713 #define TARGET_VECTOR_MODE_SUPPORTED_P sparc_vector_mode_supported_p
714
715 #undef TARGET_VECTORIZE_PREFERRED_SIMD_MODE
716 #define TARGET_VECTORIZE_PREFERRED_SIMD_MODE sparc_preferred_simd_mode
717
718 #ifdef SUBTARGET_INSERT_ATTRIBUTES
719 #undef TARGET_INSERT_ATTRIBUTES
720 #define TARGET_INSERT_ATTRIBUTES SUBTARGET_INSERT_ATTRIBUTES
721 #endif
722
723 #ifdef SUBTARGET_ATTRIBUTE_TABLE
724 #undef TARGET_ATTRIBUTE_TABLE
725 #define TARGET_ATTRIBUTE_TABLE sparc_attribute_table
726 #endif
727
728 #undef TARGET_RELAXED_ORDERING
729 #define TARGET_RELAXED_ORDERING SPARC_RELAXED_ORDERING
730
731 #undef TARGET_OPTION_OVERRIDE
732 #define TARGET_OPTION_OVERRIDE sparc_option_override
733
734 #if TARGET_GNU_TLS && defined(HAVE_AS_SPARC_UA_PCREL)
735 #undef TARGET_ASM_OUTPUT_DWARF_DTPREL
736 #define TARGET_ASM_OUTPUT_DWARF_DTPREL sparc_output_dwarf_dtprel
737 #endif
738
739 #undef TARGET_ASM_FILE_END
740 #define TARGET_ASM_FILE_END sparc_file_end
741
742 #undef TARGET_FRAME_POINTER_REQUIRED
743 #define TARGET_FRAME_POINTER_REQUIRED sparc_frame_pointer_required
744
745 #undef TARGET_BUILTIN_SETJMP_FRAME_VALUE
746 #define TARGET_BUILTIN_SETJMP_FRAME_VALUE sparc_builtin_setjmp_frame_value
747
748 #undef TARGET_CAN_ELIMINATE
749 #define TARGET_CAN_ELIMINATE sparc_can_eliminate
750
751 #undef  TARGET_PREFERRED_RELOAD_CLASS
752 #define TARGET_PREFERRED_RELOAD_CLASS sparc_preferred_reload_class
753
754 #undef TARGET_SECONDARY_RELOAD
755 #define TARGET_SECONDARY_RELOAD sparc_secondary_reload
756
757 #undef TARGET_CONDITIONAL_REGISTER_USAGE
758 #define TARGET_CONDITIONAL_REGISTER_USAGE sparc_conditional_register_usage
759
760 #ifdef TARGET_ALTERNATE_LONG_DOUBLE_MANGLING
761 #undef TARGET_MANGLE_TYPE
762 #define TARGET_MANGLE_TYPE sparc_mangle_type
763 #endif
764
765 #undef TARGET_LEGITIMATE_ADDRESS_P
766 #define TARGET_LEGITIMATE_ADDRESS_P sparc_legitimate_address_p
767
768 #undef TARGET_LEGITIMATE_CONSTANT_P
769 #define TARGET_LEGITIMATE_CONSTANT_P sparc_legitimate_constant_p
770
771 #undef TARGET_TRAMPOLINE_INIT
772 #define TARGET_TRAMPOLINE_INIT sparc_trampoline_init
773
774 #undef TARGET_PRINT_OPERAND_PUNCT_VALID_P
775 #define TARGET_PRINT_OPERAND_PUNCT_VALID_P sparc_print_operand_punct_valid_p
776 #undef TARGET_PRINT_OPERAND
777 #define TARGET_PRINT_OPERAND sparc_print_operand
778 #undef TARGET_PRINT_OPERAND_ADDRESS
779 #define TARGET_PRINT_OPERAND_ADDRESS sparc_print_operand_address
780
781 struct gcc_target targetm = TARGET_INITIALIZER;
782
783 static void
784 dump_target_flag_bits (const int flags)
785 {
786   if (flags & MASK_64BIT)
787     fprintf (stderr, "64BIT ");
788   if (flags & MASK_APP_REGS)
789     fprintf (stderr, "APP_REGS ");
790   if (flags & MASK_FASTER_STRUCTS)
791     fprintf (stderr, "FASTER_STRUCTS ");
792   if (flags & MASK_FLAT)
793     fprintf (stderr, "FLAT ");
794   if (flags & MASK_FMAF)
795     fprintf (stderr, "FMAF ");
796   if (flags & MASK_FPU)
797     fprintf (stderr, "FPU ");
798   if (flags & MASK_HARD_QUAD)
799     fprintf (stderr, "HARD_QUAD ");
800   if (flags & MASK_POPC)
801     fprintf (stderr, "POPC ");
802   if (flags & MASK_PTR64)
803     fprintf (stderr, "PTR64 ");
804   if (flags & MASK_STACK_BIAS)
805     fprintf (stderr, "STACK_BIAS ");
806   if (flags & MASK_UNALIGNED_DOUBLES)
807     fprintf (stderr, "UNALIGNED_DOUBLES ");
808   if (flags & MASK_V8PLUS)
809     fprintf (stderr, "V8PLUS ");
810   if (flags & MASK_VIS)
811     fprintf (stderr, "VIS ");
812   if (flags & MASK_VIS2)
813     fprintf (stderr, "VIS2 ");
814   if (flags & MASK_VIS3)
815     fprintf (stderr, "VIS3 ");
816   if (flags & MASK_DEPRECATED_V8_INSNS)
817     fprintf (stderr, "DEPRECATED_V8_INSNS ");
818   if (flags & MASK_SPARCLET)
819     fprintf (stderr, "SPARCLET ");
820   if (flags & MASK_SPARCLITE)
821     fprintf (stderr, "SPARCLITE ");
822   if (flags & MASK_V8)
823     fprintf (stderr, "V8 ");
824   if (flags & MASK_V9)
825     fprintf (stderr, "V9 ");
826 }
827
828 static void
829 dump_target_flags (const char *prefix, const int flags)
830 {
831   fprintf (stderr, "%s: (%08x) [ ", prefix, flags);
832   dump_target_flag_bits (flags);
833   fprintf(stderr, "]\n");
834 }
835
836 /* Validate and override various options, and do some machine dependent
837    initialization.  */
838
839 static void
840 sparc_option_override (void)
841 {
842   static struct code_model {
843     const char *const name;
844     const enum cmodel value;
845   } const cmodels[] = {
846     { "32", CM_32 },
847     { "medlow", CM_MEDLOW },
848     { "medmid", CM_MEDMID },
849     { "medany", CM_MEDANY },
850     { "embmedany", CM_EMBMEDANY },
851     { NULL, (enum cmodel) 0 }
852   };
853   const struct code_model *cmodel;
854   /* Map TARGET_CPU_DEFAULT to value for -m{cpu,tune}=.  */
855   static struct cpu_default {
856     const int cpu;
857     const enum processor_type processor;
858   } const cpu_default[] = {
859     /* There must be one entry here for each TARGET_CPU value.  */
860     { TARGET_CPU_sparc, PROCESSOR_CYPRESS },
861     { TARGET_CPU_v8, PROCESSOR_V8 },
862     { TARGET_CPU_supersparc, PROCESSOR_SUPERSPARC },
863     { TARGET_CPU_hypersparc, PROCESSOR_HYPERSPARC },
864     { TARGET_CPU_leon, PROCESSOR_LEON },
865     { TARGET_CPU_sparclite, PROCESSOR_F930 },
866     { TARGET_CPU_sparclite86x, PROCESSOR_SPARCLITE86X },
867     { TARGET_CPU_sparclet, PROCESSOR_TSC701 },
868     { TARGET_CPU_v9, PROCESSOR_V9 },
869     { TARGET_CPU_ultrasparc, PROCESSOR_ULTRASPARC },
870     { TARGET_CPU_ultrasparc3, PROCESSOR_ULTRASPARC3 },
871     { TARGET_CPU_niagara, PROCESSOR_NIAGARA },
872     { TARGET_CPU_niagara2, PROCESSOR_NIAGARA2 },
873     { TARGET_CPU_niagara3, PROCESSOR_NIAGARA3 },
874     { TARGET_CPU_niagara4, PROCESSOR_NIAGARA4 },
875     { -1, PROCESSOR_V7 }
876   };
877   const struct cpu_default *def;
878   /* Table of values for -m{cpu,tune}=.  This must match the order of
879      the PROCESSOR_* enumeration.  */
880   static struct cpu_table {
881     const char *const name;
882     const int disable;
883     const int enable;
884   } const cpu_table[] = {
885     { "v7",             MASK_ISA, 0 },
886     { "cypress",        MASK_ISA, 0 },
887     { "v8",             MASK_ISA, MASK_V8 },
888     /* TI TMS390Z55 supersparc */
889     { "supersparc",     MASK_ISA, MASK_V8 },
890     { "hypersparc",     MASK_ISA, MASK_V8|MASK_FPU },
891     /* LEON */
892     { "leon",           MASK_ISA, MASK_V8|MASK_FPU },
893     { "sparclite",      MASK_ISA, MASK_SPARCLITE },
894     /* The Fujitsu MB86930 is the original sparclite chip, with no FPU.  */
895     { "f930",           MASK_ISA|MASK_FPU, MASK_SPARCLITE },
896     /* The Fujitsu MB86934 is the recent sparclite chip, with an FPU.  */
897     { "f934",           MASK_ISA, MASK_SPARCLITE|MASK_FPU },
898     { "sparclite86x",   MASK_ISA|MASK_FPU, MASK_SPARCLITE },
899     { "sparclet",       MASK_ISA, MASK_SPARCLET },
900     /* TEMIC sparclet */
901     { "tsc701",         MASK_ISA, MASK_SPARCLET },
902     { "v9",             MASK_ISA, MASK_V9 },
903     /* UltraSPARC I, II, IIi */
904     { "ultrasparc",     MASK_ISA,
905     /* Although insns using %y are deprecated, it is a clear win.  */
906       MASK_V9|MASK_DEPRECATED_V8_INSNS },
907     /* UltraSPARC III */
908     /* ??? Check if %y issue still holds true.  */
909     { "ultrasparc3",    MASK_ISA,
910       MASK_V9|MASK_DEPRECATED_V8_INSNS|MASK_VIS2 },
911     /* UltraSPARC T1 */
912     { "niagara",        MASK_ISA,
913       MASK_V9|MASK_DEPRECATED_V8_INSNS },
914     /* UltraSPARC T2 */
915     { "niagara2",       MASK_ISA,
916       MASK_V9|MASK_POPC|MASK_VIS2 },
917     /* UltraSPARC T3 */
918     { "niagara3",       MASK_ISA,
919       MASK_V9|MASK_POPC|MASK_VIS2|MASK_VIS3|MASK_FMAF },
920     /* UltraSPARC T4 */
921     { "niagara4",       MASK_ISA,
922       MASK_V9|MASK_POPC|MASK_VIS2|MASK_VIS3|MASK_FMAF },
923   };
924   const struct cpu_table *cpu;
925   unsigned int i;
926   int fpu;
927
928   if (sparc_debug_string != NULL)
929     {
930       const char *q;
931       char *p;
932
933       p = ASTRDUP (sparc_debug_string);
934       while ((q = strtok (p, ",")) != NULL)
935         {
936           bool invert;
937           int mask;
938
939           p = NULL;
940           if (*q == '!')
941             {
942               invert = true;
943               q++;
944             }
945           else
946             invert = false;
947
948           if (! strcmp (q, "all"))
949             mask = MASK_DEBUG_ALL;
950           else if (! strcmp (q, "options"))
951             mask = MASK_DEBUG_OPTIONS;
952           else
953             error ("unknown -mdebug-%s switch", q);
954
955           if (invert)
956             sparc_debug &= ~mask;
957           else
958             sparc_debug |= mask;
959         }
960     }
961
962   if (TARGET_DEBUG_OPTIONS)
963     {
964       dump_target_flags("Initial target_flags", target_flags);
965       dump_target_flags("target_flags_explicit", target_flags_explicit);
966     }
967
968 #ifdef SUBTARGET_OVERRIDE_OPTIONS
969   SUBTARGET_OVERRIDE_OPTIONS;
970 #endif
971
972 #ifndef SPARC_BI_ARCH
973   /* Check for unsupported architecture size.  */
974   if (! TARGET_64BIT != DEFAULT_ARCH32_P)
975     error ("%s is not supported by this configuration",
976            DEFAULT_ARCH32_P ? "-m64" : "-m32");
977 #endif
978
979   /* We force all 64bit archs to use 128 bit long double */
980   if (TARGET_64BIT && ! TARGET_LONG_DOUBLE_128)
981     {
982       error ("-mlong-double-64 not allowed with -m64");
983       target_flags |= MASK_LONG_DOUBLE_128;
984     }
985
986   /* Code model selection.  */
987   sparc_cmodel = SPARC_DEFAULT_CMODEL;
988
989 #ifdef SPARC_BI_ARCH
990   if (TARGET_ARCH32)
991     sparc_cmodel = CM_32;
992 #endif
993
994   if (sparc_cmodel_string != NULL)
995     {
996       if (TARGET_ARCH64)
997         {
998           for (cmodel = &cmodels[0]; cmodel->name; cmodel++)
999             if (strcmp (sparc_cmodel_string, cmodel->name) == 0)
1000               break;
1001           if (cmodel->name == NULL)
1002             error ("bad value (%s) for -mcmodel= switch", sparc_cmodel_string);
1003           else
1004             sparc_cmodel = cmodel->value;
1005         }
1006       else
1007         error ("-mcmodel= is not supported on 32 bit systems");
1008     }
1009
1010   /* Check that -fcall-saved-REG wasn't specified for out registers.  */
1011   for (i = 8; i < 16; i++)
1012     if (!call_used_regs [i])
1013       {
1014         error ("-fcall-saved-REG is not supported for out registers");
1015         call_used_regs [i] = 1;
1016       }
1017
1018   fpu = target_flags & MASK_FPU; /* save current -mfpu status */
1019
1020   /* Set the default CPU.  */
1021   if (!global_options_set.x_sparc_cpu_and_features)
1022     {
1023       for (def = &cpu_default[0]; def->cpu != -1; ++def)
1024         if (def->cpu == TARGET_CPU_DEFAULT)
1025           break;
1026       gcc_assert (def->cpu != -1);
1027       sparc_cpu_and_features = def->processor;
1028     }
1029
1030   if (!global_options_set.x_sparc_cpu)
1031     sparc_cpu = sparc_cpu_and_features;
1032
1033   cpu = &cpu_table[(int) sparc_cpu_and_features];
1034
1035   if (TARGET_DEBUG_OPTIONS)
1036     {
1037       fprintf (stderr, "sparc_cpu_and_features: %s\n", cpu->name);
1038       fprintf (stderr, "sparc_cpu: %s\n",
1039                cpu_table[(int) sparc_cpu].name);
1040       dump_target_flags ("cpu->disable", cpu->disable);
1041       dump_target_flags ("cpu->enable", cpu->enable);
1042     }
1043
1044   target_flags &= ~cpu->disable;
1045   target_flags |= (cpu->enable
1046 #ifndef HAVE_AS_FMAF_HPC_VIS3
1047                    & ~(MASK_FMAF | MASK_VIS3)
1048 #endif
1049                    );
1050
1051   /* If -mfpu or -mno-fpu was explicitly used, don't override with
1052      the processor default.  */
1053   if (target_flags_explicit & MASK_FPU)
1054     target_flags = (target_flags & ~MASK_FPU) | fpu;
1055
1056   /* -mvis2 implies -mvis */
1057   if (TARGET_VIS2)
1058     target_flags |= MASK_VIS;
1059
1060   /* -mvis3 implies -mvis2 and -mvis */
1061   if (TARGET_VIS3)
1062     target_flags |= MASK_VIS2 | MASK_VIS;
1063
1064   /* Don't allow -mvis, -mvis2, -mvis3, or -mfmaf if FPU is disabled.  */
1065   if (! TARGET_FPU)
1066     target_flags &= ~(MASK_VIS | MASK_VIS2 | MASK_VIS3 | MASK_FMAF);
1067
1068   /* -mvis assumes UltraSPARC+, so we are sure v9 instructions
1069      are available.
1070      -m64 also implies v9.  */
1071   if (TARGET_VIS || TARGET_ARCH64)
1072     {
1073       target_flags |= MASK_V9;
1074       target_flags &= ~(MASK_V8 | MASK_SPARCLET | MASK_SPARCLITE);
1075     }
1076
1077   /* -mvis also implies -mv8plus on 32-bit */
1078   if (TARGET_VIS && ! TARGET_ARCH64)
1079     target_flags |= MASK_V8PLUS;
1080
1081   /* Use the deprecated v8 insns for sparc64 in 32 bit mode.  */
1082   if (TARGET_V9 && TARGET_ARCH32)
1083     target_flags |= MASK_DEPRECATED_V8_INSNS;
1084
1085   /* V8PLUS requires V9, makes no sense in 64 bit mode.  */
1086   if (! TARGET_V9 || TARGET_ARCH64)
1087     target_flags &= ~MASK_V8PLUS;
1088
1089   /* Don't use stack biasing in 32 bit mode.  */
1090   if (TARGET_ARCH32)
1091     target_flags &= ~MASK_STACK_BIAS;
1092
1093   /* Supply a default value for align_functions.  */
1094   if (align_functions == 0
1095       && (sparc_cpu == PROCESSOR_ULTRASPARC
1096           || sparc_cpu == PROCESSOR_ULTRASPARC3
1097           || sparc_cpu == PROCESSOR_NIAGARA
1098           || sparc_cpu == PROCESSOR_NIAGARA2
1099           || sparc_cpu == PROCESSOR_NIAGARA3
1100           || sparc_cpu == PROCESSOR_NIAGARA4))
1101     align_functions = 32;
1102
1103   /* Validate PCC_STRUCT_RETURN.  */
1104   if (flag_pcc_struct_return == DEFAULT_PCC_STRUCT_RETURN)
1105     flag_pcc_struct_return = (TARGET_ARCH64 ? 0 : 1);
1106
1107   /* Only use .uaxword when compiling for a 64-bit target.  */
1108   if (!TARGET_ARCH64)
1109     targetm.asm_out.unaligned_op.di = NULL;
1110
1111   /* Do various machine dependent initializations.  */
1112   sparc_init_modes ();
1113
1114   /* Set up function hooks.  */
1115   init_machine_status = sparc_init_machine_status;
1116
1117   switch (sparc_cpu)
1118     {
1119     case PROCESSOR_V7:
1120     case PROCESSOR_CYPRESS:
1121       sparc_costs = &cypress_costs;
1122       break;
1123     case PROCESSOR_V8:
1124     case PROCESSOR_SPARCLITE:
1125     case PROCESSOR_SUPERSPARC:
1126       sparc_costs = &supersparc_costs;
1127       break;
1128     case PROCESSOR_F930:
1129     case PROCESSOR_F934:
1130     case PROCESSOR_HYPERSPARC:
1131     case PROCESSOR_SPARCLITE86X:
1132       sparc_costs = &hypersparc_costs;
1133       break;
1134     case PROCESSOR_LEON:
1135       sparc_costs = &leon_costs;
1136       break;
1137     case PROCESSOR_SPARCLET:
1138     case PROCESSOR_TSC701:
1139       sparc_costs = &sparclet_costs;
1140       break;
1141     case PROCESSOR_V9:
1142     case PROCESSOR_ULTRASPARC:
1143       sparc_costs = &ultrasparc_costs;
1144       break;
1145     case PROCESSOR_ULTRASPARC3:
1146       sparc_costs = &ultrasparc3_costs;
1147       break;
1148     case PROCESSOR_NIAGARA:
1149       sparc_costs = &niagara_costs;
1150       break;
1151     case PROCESSOR_NIAGARA2:
1152       sparc_costs = &niagara2_costs;
1153       break;
1154     case PROCESSOR_NIAGARA3:
1155     case PROCESSOR_NIAGARA4:
1156       sparc_costs = &niagara3_costs;
1157       break;
1158     case PROCESSOR_NATIVE:
1159       gcc_unreachable ();
1160     };
1161
1162 #ifdef TARGET_DEFAULT_LONG_DOUBLE_128
1163   if (!(target_flags_explicit & MASK_LONG_DOUBLE_128))
1164     target_flags |= MASK_LONG_DOUBLE_128;
1165 #endif
1166
1167   if (TARGET_DEBUG_OPTIONS)
1168     dump_target_flags ("Final target_flags", target_flags);
1169
1170   maybe_set_param_value (PARAM_SIMULTANEOUS_PREFETCHES,
1171                          ((sparc_cpu == PROCESSOR_ULTRASPARC
1172                            || sparc_cpu == PROCESSOR_NIAGARA
1173                            || sparc_cpu == PROCESSOR_NIAGARA2
1174                            || sparc_cpu == PROCESSOR_NIAGARA3
1175                            || sparc_cpu == PROCESSOR_NIAGARA4)
1176                           ? 2
1177                           : (sparc_cpu == PROCESSOR_ULTRASPARC3
1178                              ? 8 : 3)),
1179                          global_options.x_param_values,
1180                          global_options_set.x_param_values);
1181   maybe_set_param_value (PARAM_L1_CACHE_LINE_SIZE,
1182                          ((sparc_cpu == PROCESSOR_ULTRASPARC
1183                            || sparc_cpu == PROCESSOR_ULTRASPARC3
1184                            || sparc_cpu == PROCESSOR_NIAGARA
1185                            || sparc_cpu == PROCESSOR_NIAGARA2
1186                            || sparc_cpu == PROCESSOR_NIAGARA3
1187                            || sparc_cpu == PROCESSOR_NIAGARA4)
1188                           ? 64 : 32),
1189                          global_options.x_param_values,
1190                          global_options_set.x_param_values);
1191
1192   /* Disable save slot sharing for call-clobbered registers by default.
1193      The IRA sharing algorithm works on single registers only and this
1194      pessimizes for double floating-point registers.  */
1195   if (!global_options_set.x_flag_ira_share_save_slots)
1196     flag_ira_share_save_slots = 0;
1197 }
1198 \f
1199 /* Miscellaneous utilities.  */
1200
1201 /* Nonzero if CODE, a comparison, is suitable for use in v9 conditional move
1202    or branch on register contents instructions.  */
1203
1204 int
1205 v9_regcmp_p (enum rtx_code code)
1206 {
1207   return (code == EQ || code == NE || code == GE || code == LT
1208           || code == LE || code == GT);
1209 }
1210
1211 /* Nonzero if OP is a floating point constant which can
1212    be loaded into an integer register using a single
1213    sethi instruction.  */
1214
1215 int
1216 fp_sethi_p (rtx op)
1217 {
1218   if (GET_CODE (op) == CONST_DOUBLE)
1219     {
1220       REAL_VALUE_TYPE r;
1221       long i;
1222
1223       REAL_VALUE_FROM_CONST_DOUBLE (r, op);
1224       REAL_VALUE_TO_TARGET_SINGLE (r, i);
1225       return !SPARC_SIMM13_P (i) && SPARC_SETHI_P (i);
1226     }
1227
1228   return 0;
1229 }
1230
1231 /* Nonzero if OP is a floating point constant which can
1232    be loaded into an integer register using a single
1233    mov instruction.  */
1234
1235 int
1236 fp_mov_p (rtx op)
1237 {
1238   if (GET_CODE (op) == CONST_DOUBLE)
1239     {
1240       REAL_VALUE_TYPE r;
1241       long i;
1242
1243       REAL_VALUE_FROM_CONST_DOUBLE (r, op);
1244       REAL_VALUE_TO_TARGET_SINGLE (r, i);
1245       return SPARC_SIMM13_P (i);
1246     }
1247
1248   return 0;
1249 }
1250
1251 /* Nonzero if OP is a floating point constant which can
1252    be loaded into an integer register using a high/losum
1253    instruction sequence.  */
1254
1255 int
1256 fp_high_losum_p (rtx op)
1257 {
1258   /* The constraints calling this should only be in
1259      SFmode move insns, so any constant which cannot
1260      be moved using a single insn will do.  */
1261   if (GET_CODE (op) == CONST_DOUBLE)
1262     {
1263       REAL_VALUE_TYPE r;
1264       long i;
1265
1266       REAL_VALUE_FROM_CONST_DOUBLE (r, op);
1267       REAL_VALUE_TO_TARGET_SINGLE (r, i);
1268       return !SPARC_SIMM13_P (i) && !SPARC_SETHI_P (i);
1269     }
1270
1271   return 0;
1272 }
1273
1274 /* Return true if the address of LABEL can be loaded by means of the
1275    mov{si,di}_pic_label_ref patterns in PIC mode.  */
1276
1277 static bool
1278 can_use_mov_pic_label_ref (rtx label)
1279 {
1280   /* VxWorks does not impose a fixed gap between segments; the run-time
1281      gap can be different from the object-file gap.  We therefore can't
1282      assume X - _GLOBAL_OFFSET_TABLE_ is a link-time constant unless we
1283      are absolutely sure that X is in the same segment as the GOT.
1284      Unfortunately, the flexibility of linker scripts means that we
1285      can't be sure of that in general, so assume that GOT-relative
1286      accesses are never valid on VxWorks.  */
1287   if (TARGET_VXWORKS_RTP)
1288     return false;
1289
1290   /* Similarly, if the label is non-local, it might end up being placed
1291      in a different section than the current one; now mov_pic_label_ref
1292      requires the label and the code to be in the same section.  */
1293   if (LABEL_REF_NONLOCAL_P (label))
1294     return false;
1295
1296   /* Finally, if we are reordering basic blocks and partition into hot
1297      and cold sections, this might happen for any label.  */
1298   if (flag_reorder_blocks_and_partition)
1299     return false;
1300
1301   return true;
1302 }
1303
1304 /* Expand a move instruction.  Return true if all work is done.  */
1305
1306 bool
1307 sparc_expand_move (enum machine_mode mode, rtx *operands)
1308 {
1309   /* Handle sets of MEM first.  */
1310   if (GET_CODE (operands[0]) == MEM)
1311     {
1312       /* 0 is a register (or a pair of registers) on SPARC.  */
1313       if (register_or_zero_operand (operands[1], mode))
1314         return false;
1315
1316       if (!reload_in_progress)
1317         {
1318           operands[0] = validize_mem (operands[0]);
1319           operands[1] = force_reg (mode, operands[1]);
1320         }
1321     }
1322
1323   /* Fixup TLS cases.  */
1324   if (TARGET_HAVE_TLS
1325       && CONSTANT_P (operands[1])
1326       && sparc_tls_referenced_p (operands [1]))
1327     {
1328       operands[1] = sparc_legitimize_tls_address (operands[1]);
1329       return false;
1330     }
1331
1332   /* Fixup PIC cases.  */
1333   if (flag_pic && CONSTANT_P (operands[1]))
1334     {
1335       if (pic_address_needs_scratch (operands[1]))
1336         operands[1] = sparc_legitimize_pic_address (operands[1], NULL_RTX);
1337
1338       /* We cannot use the mov{si,di}_pic_label_ref patterns in all cases.  */
1339       if (GET_CODE (operands[1]) == LABEL_REF
1340           && can_use_mov_pic_label_ref (operands[1]))
1341         {
1342           if (mode == SImode)
1343             {
1344               emit_insn (gen_movsi_pic_label_ref (operands[0], operands[1]));
1345               return true;
1346             }
1347
1348           if (mode == DImode)
1349             {
1350               gcc_assert (TARGET_ARCH64);
1351               emit_insn (gen_movdi_pic_label_ref (operands[0], operands[1]));
1352               return true;
1353             }
1354         }
1355
1356       if (symbolic_operand (operands[1], mode))
1357         {
1358           operands[1]
1359             = sparc_legitimize_pic_address (operands[1],
1360                                             reload_in_progress
1361                                             ? operands[0] : NULL_RTX);
1362           return false;
1363         }
1364     }
1365
1366   /* If we are trying to toss an integer constant into FP registers,
1367      or loading a FP or vector constant, force it into memory.  */
1368   if (CONSTANT_P (operands[1])
1369       && REG_P (operands[0])
1370       && (SPARC_FP_REG_P (REGNO (operands[0]))
1371           || SCALAR_FLOAT_MODE_P (mode)
1372           || VECTOR_MODE_P (mode)))
1373     {
1374       /* emit_group_store will send such bogosity to us when it is
1375          not storing directly into memory.  So fix this up to avoid
1376          crashes in output_constant_pool.  */
1377       if (operands [1] == const0_rtx)
1378         operands[1] = CONST0_RTX (mode);
1379
1380       /* We can clear or set to all-ones FP registers if TARGET_VIS, and
1381          always other regs.  */
1382       if ((TARGET_VIS || REGNO (operands[0]) < SPARC_FIRST_FP_REG)
1383           && (const_zero_operand (operands[1], mode)
1384               || const_all_ones_operand (operands[1], mode)))
1385         return false;
1386
1387       if (REGNO (operands[0]) < SPARC_FIRST_FP_REG
1388           /* We are able to build any SF constant in integer registers
1389              with at most 2 instructions.  */
1390           && (mode == SFmode
1391               /* And any DF constant in integer registers.  */
1392               || (mode == DFmode
1393                   && ! can_create_pseudo_p ())))
1394         return false;
1395
1396       operands[1] = force_const_mem (mode, operands[1]);
1397       if (!reload_in_progress)
1398         operands[1] = validize_mem (operands[1]);
1399       return false;
1400     }
1401
1402   /* Accept non-constants and valid constants unmodified.  */
1403   if (!CONSTANT_P (operands[1])
1404       || GET_CODE (operands[1]) == HIGH
1405       || input_operand (operands[1], mode))
1406     return false;
1407
1408   switch (mode)
1409     {
1410     case QImode:
1411       /* All QImode constants require only one insn, so proceed.  */
1412       break;
1413
1414     case HImode:
1415     case SImode:
1416       sparc_emit_set_const32 (operands[0], operands[1]);
1417       return true;
1418
1419     case DImode:
1420       /* input_operand should have filtered out 32-bit mode.  */
1421       sparc_emit_set_const64 (operands[0], operands[1]);
1422       return true;
1423
1424     default:
1425       gcc_unreachable ();
1426     }
1427
1428   return false;
1429 }
1430
1431 /* Load OP1, a 32-bit constant, into OP0, a register.
1432    We know it can't be done in one insn when we get
1433    here, the move expander guarantees this.  */
1434
1435 static void
1436 sparc_emit_set_const32 (rtx op0, rtx op1)
1437 {
1438   enum machine_mode mode = GET_MODE (op0);
1439   rtx temp = op0;
1440
1441   if (can_create_pseudo_p ())
1442     temp = gen_reg_rtx (mode);
1443
1444   if (GET_CODE (op1) == CONST_INT)
1445     {
1446       gcc_assert (!small_int_operand (op1, mode)
1447                   && !const_high_operand (op1, mode));
1448
1449       /* Emit them as real moves instead of a HIGH/LO_SUM,
1450          this way CSE can see everything and reuse intermediate
1451          values if it wants.  */
1452       emit_insn (gen_rtx_SET (VOIDmode, temp,
1453                               GEN_INT (INTVAL (op1)
1454                                 & ~(HOST_WIDE_INT)0x3ff)));
1455
1456       emit_insn (gen_rtx_SET (VOIDmode,
1457                               op0,
1458                               gen_rtx_IOR (mode, temp,
1459                                            GEN_INT (INTVAL (op1) & 0x3ff))));
1460     }
1461   else
1462     {
1463       /* A symbol, emit in the traditional way.  */
1464       emit_insn (gen_rtx_SET (VOIDmode, temp,
1465                               gen_rtx_HIGH (mode, op1)));
1466       emit_insn (gen_rtx_SET (VOIDmode,
1467                               op0, gen_rtx_LO_SUM (mode, temp, op1)));
1468     }
1469 }
1470
1471 /* Load OP1, a symbolic 64-bit constant, into OP0, a DImode register.
1472    If TEMP is nonzero, we are forbidden to use any other scratch
1473    registers.  Otherwise, we are allowed to generate them as needed.
1474
1475    Note that TEMP may have TImode if the code model is TARGET_CM_MEDANY
1476    or TARGET_CM_EMBMEDANY (see the reload_indi and reload_outdi patterns).  */
1477
1478 void
1479 sparc_emit_set_symbolic_const64 (rtx op0, rtx op1, rtx temp)
1480 {
1481   rtx temp1, temp2, temp3, temp4, temp5;
1482   rtx ti_temp = 0;
1483
1484   if (temp && GET_MODE (temp) == TImode)
1485     {
1486       ti_temp = temp;
1487       temp = gen_rtx_REG (DImode, REGNO (temp));
1488     }
1489
1490   /* SPARC-V9 code-model support.  */
1491   switch (sparc_cmodel)
1492     {
1493     case CM_MEDLOW:
1494       /* The range spanned by all instructions in the object is less
1495          than 2^31 bytes (2GB) and the distance from any instruction
1496          to the location of the label _GLOBAL_OFFSET_TABLE_ is less
1497          than 2^31 bytes (2GB).
1498
1499          The executable must be in the low 4TB of the virtual address
1500          space.
1501
1502          sethi  %hi(symbol), %temp1
1503          or     %temp1, %lo(symbol), %reg  */
1504       if (temp)
1505         temp1 = temp;  /* op0 is allowed.  */
1506       else
1507         temp1 = gen_reg_rtx (DImode);
1508
1509       emit_insn (gen_rtx_SET (VOIDmode, temp1, gen_rtx_HIGH (DImode, op1)));
1510       emit_insn (gen_rtx_SET (VOIDmode, op0, gen_rtx_LO_SUM (DImode, temp1, op1)));
1511       break;
1512
1513     case CM_MEDMID:
1514       /* The range spanned by all instructions in the object is less
1515          than 2^31 bytes (2GB) and the distance from any instruction
1516          to the location of the label _GLOBAL_OFFSET_TABLE_ is less
1517          than 2^31 bytes (2GB).
1518
1519          The executable must be in the low 16TB of the virtual address
1520          space.
1521
1522          sethi  %h44(symbol), %temp1
1523          or     %temp1, %m44(symbol), %temp2
1524          sllx   %temp2, 12, %temp3
1525          or     %temp3, %l44(symbol), %reg  */
1526       if (temp)
1527         {
1528           temp1 = op0;
1529           temp2 = op0;
1530           temp3 = temp;  /* op0 is allowed.  */
1531         }
1532       else
1533         {
1534           temp1 = gen_reg_rtx (DImode);
1535           temp2 = gen_reg_rtx (DImode);
1536           temp3 = gen_reg_rtx (DImode);
1537         }
1538
1539       emit_insn (gen_seth44 (temp1, op1));
1540       emit_insn (gen_setm44 (temp2, temp1, op1));
1541       emit_insn (gen_rtx_SET (VOIDmode, temp3,
1542                               gen_rtx_ASHIFT (DImode, temp2, GEN_INT (12))));
1543       emit_insn (gen_setl44 (op0, temp3, op1));
1544       break;
1545
1546     case CM_MEDANY:
1547       /* The range spanned by all instructions in the object is less
1548          than 2^31 bytes (2GB) and the distance from any instruction
1549          to the location of the label _GLOBAL_OFFSET_TABLE_ is less
1550          than 2^31 bytes (2GB).
1551
1552          The executable can be placed anywhere in the virtual address
1553          space.
1554
1555          sethi  %hh(symbol), %temp1
1556          sethi  %lm(symbol), %temp2
1557          or     %temp1, %hm(symbol), %temp3
1558          sllx   %temp3, 32, %temp4
1559          or     %temp4, %temp2, %temp5
1560          or     %temp5, %lo(symbol), %reg  */
1561       if (temp)
1562         {
1563           /* It is possible that one of the registers we got for operands[2]
1564              might coincide with that of operands[0] (which is why we made
1565              it TImode).  Pick the other one to use as our scratch.  */
1566           if (rtx_equal_p (temp, op0))
1567             {
1568               gcc_assert (ti_temp);
1569               temp = gen_rtx_REG (DImode, REGNO (temp) + 1);
1570             }
1571           temp1 = op0;
1572           temp2 = temp;  /* op0 is _not_ allowed, see above.  */
1573           temp3 = op0;
1574           temp4 = op0;
1575           temp5 = op0;
1576         }
1577       else
1578         {
1579           temp1 = gen_reg_rtx (DImode);
1580           temp2 = gen_reg_rtx (DImode);
1581           temp3 = gen_reg_rtx (DImode);
1582           temp4 = gen_reg_rtx (DImode);
1583           temp5 = gen_reg_rtx (DImode);
1584         }
1585
1586       emit_insn (gen_sethh (temp1, op1));
1587       emit_insn (gen_setlm (temp2, op1));
1588       emit_insn (gen_sethm (temp3, temp1, op1));
1589       emit_insn (gen_rtx_SET (VOIDmode, temp4,
1590                               gen_rtx_ASHIFT (DImode, temp3, GEN_INT (32))));
1591       emit_insn (gen_rtx_SET (VOIDmode, temp5,
1592                               gen_rtx_PLUS (DImode, temp4, temp2)));
1593       emit_insn (gen_setlo (op0, temp5, op1));
1594       break;
1595
1596     case CM_EMBMEDANY:
1597       /* Old old old backwards compatibility kruft here.
1598          Essentially it is MEDLOW with a fixed 64-bit
1599          virtual base added to all data segment addresses.
1600          Text-segment stuff is computed like MEDANY, we can't
1601          reuse the code above because the relocation knobs
1602          look different.
1603
1604          Data segment:  sethi   %hi(symbol), %temp1
1605                         add     %temp1, EMBMEDANY_BASE_REG, %temp2
1606                         or      %temp2, %lo(symbol), %reg  */
1607       if (data_segment_operand (op1, GET_MODE (op1)))
1608         {
1609           if (temp)
1610             {
1611               temp1 = temp;  /* op0 is allowed.  */
1612               temp2 = op0;
1613             }
1614           else
1615             {
1616               temp1 = gen_reg_rtx (DImode);
1617               temp2 = gen_reg_rtx (DImode);
1618             }
1619
1620           emit_insn (gen_embmedany_sethi (temp1, op1));
1621           emit_insn (gen_embmedany_brsum (temp2, temp1));
1622           emit_insn (gen_embmedany_losum (op0, temp2, op1));
1623         }
1624
1625       /* Text segment:  sethi   %uhi(symbol), %temp1
1626                         sethi   %hi(symbol), %temp2
1627                         or      %temp1, %ulo(symbol), %temp3
1628                         sllx    %temp3, 32, %temp4
1629                         or      %temp4, %temp2, %temp5
1630                         or      %temp5, %lo(symbol), %reg  */
1631       else
1632         {
1633           if (temp)
1634             {
1635               /* It is possible that one of the registers we got for operands[2]
1636                  might coincide with that of operands[0] (which is why we made
1637                  it TImode).  Pick the other one to use as our scratch.  */
1638               if (rtx_equal_p (temp, op0))
1639                 {
1640                   gcc_assert (ti_temp);
1641                   temp = gen_rtx_REG (DImode, REGNO (temp) + 1);
1642                 }
1643               temp1 = op0;
1644               temp2 = temp;  /* op0 is _not_ allowed, see above.  */
1645               temp3 = op0;
1646               temp4 = op0;
1647               temp5 = op0;
1648             }
1649           else
1650             {
1651               temp1 = gen_reg_rtx (DImode);
1652               temp2 = gen_reg_rtx (DImode);
1653               temp3 = gen_reg_rtx (DImode);
1654               temp4 = gen_reg_rtx (DImode);
1655               temp5 = gen_reg_rtx (DImode);
1656             }
1657
1658           emit_insn (gen_embmedany_textuhi (temp1, op1));
1659           emit_insn (gen_embmedany_texthi  (temp2, op1));
1660           emit_insn (gen_embmedany_textulo (temp3, temp1, op1));
1661           emit_insn (gen_rtx_SET (VOIDmode, temp4,
1662                                   gen_rtx_ASHIFT (DImode, temp3, GEN_INT (32))));
1663           emit_insn (gen_rtx_SET (VOIDmode, temp5,
1664                                   gen_rtx_PLUS (DImode, temp4, temp2)));
1665           emit_insn (gen_embmedany_textlo  (op0, temp5, op1));
1666         }
1667       break;
1668
1669     default:
1670       gcc_unreachable ();
1671     }
1672 }
1673
1674 #if HOST_BITS_PER_WIDE_INT == 32
1675 static void
1676 sparc_emit_set_const64 (rtx op0 ATTRIBUTE_UNUSED, rtx op1 ATTRIBUTE_UNUSED)
1677 {
1678   gcc_unreachable ();
1679 }
1680 #else
1681 /* These avoid problems when cross compiling.  If we do not
1682    go through all this hair then the optimizer will see
1683    invalid REG_EQUAL notes or in some cases none at all.  */
1684 static rtx gen_safe_HIGH64 (rtx, HOST_WIDE_INT);
1685 static rtx gen_safe_SET64 (rtx, HOST_WIDE_INT);
1686 static rtx gen_safe_OR64 (rtx, HOST_WIDE_INT);
1687 static rtx gen_safe_XOR64 (rtx, HOST_WIDE_INT);
1688
1689 /* The optimizer is not to assume anything about exactly
1690    which bits are set for a HIGH, they are unspecified.
1691    Unfortunately this leads to many missed optimizations
1692    during CSE.  We mask out the non-HIGH bits, and matches
1693    a plain movdi, to alleviate this problem.  */
1694 static rtx
1695 gen_safe_HIGH64 (rtx dest, HOST_WIDE_INT val)
1696 {
1697   return gen_rtx_SET (VOIDmode, dest, GEN_INT (val & ~(HOST_WIDE_INT)0x3ff));
1698 }
1699
1700 static rtx
1701 gen_safe_SET64 (rtx dest, HOST_WIDE_INT val)
1702 {
1703   return gen_rtx_SET (VOIDmode, dest, GEN_INT (val));
1704 }
1705
1706 static rtx
1707 gen_safe_OR64 (rtx src, HOST_WIDE_INT val)
1708 {
1709   return gen_rtx_IOR (DImode, src, GEN_INT (val));
1710 }
1711
1712 static rtx
1713 gen_safe_XOR64 (rtx src, HOST_WIDE_INT val)
1714 {
1715   return gen_rtx_XOR (DImode, src, GEN_INT (val));
1716 }
1717
1718 /* Worker routines for 64-bit constant formation on arch64.
1719    One of the key things to be doing in these emissions is
1720    to create as many temp REGs as possible.  This makes it
1721    possible for half-built constants to be used later when
1722    such values are similar to something required later on.
1723    Without doing this, the optimizer cannot see such
1724    opportunities.  */
1725
1726 static void sparc_emit_set_const64_quick1 (rtx, rtx,
1727                                            unsigned HOST_WIDE_INT, int);
1728
1729 static void
1730 sparc_emit_set_const64_quick1 (rtx op0, rtx temp,
1731                                unsigned HOST_WIDE_INT low_bits, int is_neg)
1732 {
1733   unsigned HOST_WIDE_INT high_bits;
1734
1735   if (is_neg)
1736     high_bits = (~low_bits) & 0xffffffff;
1737   else
1738     high_bits = low_bits;
1739
1740   emit_insn (gen_safe_HIGH64 (temp, high_bits));
1741   if (!is_neg)
1742     {
1743       emit_insn (gen_rtx_SET (VOIDmode, op0,
1744                               gen_safe_OR64 (temp, (high_bits & 0x3ff))));
1745     }
1746   else
1747     {
1748       /* If we are XOR'ing with -1, then we should emit a one's complement
1749          instead.  This way the combiner will notice logical operations
1750          such as ANDN later on and substitute.  */
1751       if ((low_bits & 0x3ff) == 0x3ff)
1752         {
1753           emit_insn (gen_rtx_SET (VOIDmode, op0,
1754                                   gen_rtx_NOT (DImode, temp)));
1755         }
1756       else
1757         {
1758           emit_insn (gen_rtx_SET (VOIDmode, op0,
1759                                   gen_safe_XOR64 (temp,
1760                                                   (-(HOST_WIDE_INT)0x400
1761                                                    | (low_bits & 0x3ff)))));
1762         }
1763     }
1764 }
1765
1766 static void sparc_emit_set_const64_quick2 (rtx, rtx, unsigned HOST_WIDE_INT,
1767                                            unsigned HOST_WIDE_INT, int);
1768
1769 static void
1770 sparc_emit_set_const64_quick2 (rtx op0, rtx temp,
1771                                unsigned HOST_WIDE_INT high_bits,
1772                                unsigned HOST_WIDE_INT low_immediate,
1773                                int shift_count)
1774 {
1775   rtx temp2 = op0;
1776
1777   if ((high_bits & 0xfffffc00) != 0)
1778     {
1779       emit_insn (gen_safe_HIGH64 (temp, high_bits));
1780       if ((high_bits & ~0xfffffc00) != 0)
1781         emit_insn (gen_rtx_SET (VOIDmode, op0,
1782                                 gen_safe_OR64 (temp, (high_bits & 0x3ff))));
1783       else
1784         temp2 = temp;
1785     }
1786   else
1787     {
1788       emit_insn (gen_safe_SET64 (temp, high_bits));
1789       temp2 = temp;
1790     }
1791
1792   /* Now shift it up into place.  */
1793   emit_insn (gen_rtx_SET (VOIDmode, op0,
1794                           gen_rtx_ASHIFT (DImode, temp2,
1795                                           GEN_INT (shift_count))));
1796
1797   /* If there is a low immediate part piece, finish up by
1798      putting that in as well.  */
1799   if (low_immediate != 0)
1800     emit_insn (gen_rtx_SET (VOIDmode, op0,
1801                             gen_safe_OR64 (op0, low_immediate)));
1802 }
1803
1804 static void sparc_emit_set_const64_longway (rtx, rtx, unsigned HOST_WIDE_INT,
1805                                             unsigned HOST_WIDE_INT);
1806
1807 /* Full 64-bit constant decomposition.  Even though this is the
1808    'worst' case, we still optimize a few things away.  */
1809 static void
1810 sparc_emit_set_const64_longway (rtx op0, rtx temp,
1811                                 unsigned HOST_WIDE_INT high_bits,
1812                                 unsigned HOST_WIDE_INT low_bits)
1813 {
1814   rtx sub_temp = op0;
1815
1816   if (can_create_pseudo_p ())
1817     sub_temp = gen_reg_rtx (DImode);
1818
1819   if ((high_bits & 0xfffffc00) != 0)
1820     {
1821       emit_insn (gen_safe_HIGH64 (temp, high_bits));
1822       if ((high_bits & ~0xfffffc00) != 0)
1823         emit_insn (gen_rtx_SET (VOIDmode,
1824                                 sub_temp,
1825                                 gen_safe_OR64 (temp, (high_bits & 0x3ff))));
1826       else
1827         sub_temp = temp;
1828     }
1829   else
1830     {
1831       emit_insn (gen_safe_SET64 (temp, high_bits));
1832       sub_temp = temp;
1833     }
1834
1835   if (can_create_pseudo_p ())
1836     {
1837       rtx temp2 = gen_reg_rtx (DImode);
1838       rtx temp3 = gen_reg_rtx (DImode);
1839       rtx temp4 = gen_reg_rtx (DImode);
1840
1841       emit_insn (gen_rtx_SET (VOIDmode, temp4,
1842                               gen_rtx_ASHIFT (DImode, sub_temp,
1843                                               GEN_INT (32))));
1844
1845       emit_insn (gen_safe_HIGH64 (temp2, low_bits));
1846       if ((low_bits & ~0xfffffc00) != 0)
1847         {
1848           emit_insn (gen_rtx_SET (VOIDmode, temp3,
1849                                   gen_safe_OR64 (temp2, (low_bits & 0x3ff))));
1850           emit_insn (gen_rtx_SET (VOIDmode, op0,
1851                                   gen_rtx_PLUS (DImode, temp4, temp3)));
1852         }
1853       else
1854         {
1855           emit_insn (gen_rtx_SET (VOIDmode, op0,
1856                                   gen_rtx_PLUS (DImode, temp4, temp2)));
1857         }
1858     }
1859   else
1860     {
1861       rtx low1 = GEN_INT ((low_bits >> (32 - 12))          & 0xfff);
1862       rtx low2 = GEN_INT ((low_bits >> (32 - 12 - 12))     & 0xfff);
1863       rtx low3 = GEN_INT ((low_bits >> (32 - 12 - 12 - 8)) & 0x0ff);
1864       int to_shift = 12;
1865
1866       /* We are in the middle of reload, so this is really
1867          painful.  However we do still make an attempt to
1868          avoid emitting truly stupid code.  */
1869       if (low1 != const0_rtx)
1870         {
1871           emit_insn (gen_rtx_SET (VOIDmode, op0,
1872                                   gen_rtx_ASHIFT (DImode, sub_temp,
1873                                                   GEN_INT (to_shift))));
1874           emit_insn (gen_rtx_SET (VOIDmode, op0,
1875                                   gen_rtx_IOR (DImode, op0, low1)));
1876           sub_temp = op0;
1877           to_shift = 12;
1878         }
1879       else
1880         {
1881           to_shift += 12;
1882         }
1883       if (low2 != const0_rtx)
1884         {
1885           emit_insn (gen_rtx_SET (VOIDmode, op0,
1886                                   gen_rtx_ASHIFT (DImode, sub_temp,
1887                                                   GEN_INT (to_shift))));
1888           emit_insn (gen_rtx_SET (VOIDmode, op0,
1889                                   gen_rtx_IOR (DImode, op0, low2)));
1890           sub_temp = op0;
1891           to_shift = 8;
1892         }
1893       else
1894         {
1895           to_shift += 8;
1896         }
1897       emit_insn (gen_rtx_SET (VOIDmode, op0,
1898                               gen_rtx_ASHIFT (DImode, sub_temp,
1899                                               GEN_INT (to_shift))));
1900       if (low3 != const0_rtx)
1901         emit_insn (gen_rtx_SET (VOIDmode, op0,
1902                                 gen_rtx_IOR (DImode, op0, low3)));
1903       /* phew...  */
1904     }
1905 }
1906
1907 /* Analyze a 64-bit constant for certain properties.  */
1908 static void analyze_64bit_constant (unsigned HOST_WIDE_INT,
1909                                     unsigned HOST_WIDE_INT,
1910                                     int *, int *, int *);
1911
1912 static void
1913 analyze_64bit_constant (unsigned HOST_WIDE_INT high_bits,
1914                         unsigned HOST_WIDE_INT low_bits,
1915                         int *hbsp, int *lbsp, int *abbasp)
1916 {
1917   int lowest_bit_set, highest_bit_set, all_bits_between_are_set;
1918   int i;
1919
1920   lowest_bit_set = highest_bit_set = -1;
1921   i = 0;
1922   do
1923     {
1924       if ((lowest_bit_set == -1)
1925           && ((low_bits >> i) & 1))
1926         lowest_bit_set = i;
1927       if ((highest_bit_set == -1)
1928           && ((high_bits >> (32 - i - 1)) & 1))
1929         highest_bit_set = (64 - i - 1);
1930     }
1931   while (++i < 32
1932          && ((highest_bit_set == -1)
1933              || (lowest_bit_set == -1)));
1934   if (i == 32)
1935     {
1936       i = 0;
1937       do
1938         {
1939           if ((lowest_bit_set == -1)
1940               && ((high_bits >> i) & 1))
1941             lowest_bit_set = i + 32;
1942           if ((highest_bit_set == -1)
1943               && ((low_bits >> (32 - i - 1)) & 1))
1944             highest_bit_set = 32 - i - 1;
1945         }
1946       while (++i < 32
1947              && ((highest_bit_set == -1)
1948                  || (lowest_bit_set == -1)));
1949     }
1950   /* If there are no bits set this should have gone out
1951      as one instruction!  */
1952   gcc_assert (lowest_bit_set != -1 && highest_bit_set != -1);
1953   all_bits_between_are_set = 1;
1954   for (i = lowest_bit_set; i <= highest_bit_set; i++)
1955     {
1956       if (i < 32)
1957         {
1958           if ((low_bits & (1 << i)) != 0)
1959             continue;
1960         }
1961       else
1962         {
1963           if ((high_bits & (1 << (i - 32))) != 0)
1964             continue;
1965         }
1966       all_bits_between_are_set = 0;
1967       break;
1968     }
1969   *hbsp = highest_bit_set;
1970   *lbsp = lowest_bit_set;
1971   *abbasp = all_bits_between_are_set;
1972 }
1973
1974 static int const64_is_2insns (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
1975
1976 static int
1977 const64_is_2insns (unsigned HOST_WIDE_INT high_bits,
1978                    unsigned HOST_WIDE_INT low_bits)
1979 {
1980   int highest_bit_set, lowest_bit_set, all_bits_between_are_set;
1981
1982   if (high_bits == 0
1983       || high_bits == 0xffffffff)
1984     return 1;
1985
1986   analyze_64bit_constant (high_bits, low_bits,
1987                           &highest_bit_set, &lowest_bit_set,
1988                           &all_bits_between_are_set);
1989
1990   if ((highest_bit_set == 63
1991        || lowest_bit_set == 0)
1992       && all_bits_between_are_set != 0)
1993     return 1;
1994
1995   if ((highest_bit_set - lowest_bit_set) < 21)
1996     return 1;
1997
1998   return 0;
1999 }
2000
2001 static unsigned HOST_WIDE_INT create_simple_focus_bits (unsigned HOST_WIDE_INT,
2002                                                         unsigned HOST_WIDE_INT,
2003                                                         int, int);
2004
2005 static unsigned HOST_WIDE_INT
2006 create_simple_focus_bits (unsigned HOST_WIDE_INT high_bits,
2007                           unsigned HOST_WIDE_INT low_bits,
2008                           int lowest_bit_set, int shift)
2009 {
2010   HOST_WIDE_INT hi, lo;
2011
2012   if (lowest_bit_set < 32)
2013     {
2014       lo = (low_bits >> lowest_bit_set) << shift;
2015       hi = ((high_bits << (32 - lowest_bit_set)) << shift);
2016     }
2017   else
2018     {
2019       lo = 0;
2020       hi = ((high_bits >> (lowest_bit_set - 32)) << shift);
2021     }
2022   gcc_assert (! (hi & lo));
2023   return (hi | lo);
2024 }
2025
2026 /* Here we are sure to be arch64 and this is an integer constant
2027    being loaded into a register.  Emit the most efficient
2028    insn sequence possible.  Detection of all the 1-insn cases
2029    has been done already.  */
2030 static void
2031 sparc_emit_set_const64 (rtx op0, rtx op1)
2032 {
2033   unsigned HOST_WIDE_INT high_bits, low_bits;
2034   int lowest_bit_set, highest_bit_set;
2035   int all_bits_between_are_set;
2036   rtx temp = 0;
2037
2038   /* Sanity check that we know what we are working with.  */
2039   gcc_assert (TARGET_ARCH64
2040               && (GET_CODE (op0) == SUBREG
2041                   || (REG_P (op0) && ! SPARC_FP_REG_P (REGNO (op0)))));
2042
2043   if (! can_create_pseudo_p ())
2044     temp = op0;
2045
2046   if (GET_CODE (op1) != CONST_INT)
2047     {
2048       sparc_emit_set_symbolic_const64 (op0, op1, temp);
2049       return;
2050     }
2051
2052   if (! temp)
2053     temp = gen_reg_rtx (DImode);
2054
2055   high_bits = ((INTVAL (op1) >> 32) & 0xffffffff);
2056   low_bits = (INTVAL (op1) & 0xffffffff);
2057
2058   /* low_bits   bits 0  --> 31
2059      high_bits  bits 32 --> 63  */
2060
2061   analyze_64bit_constant (high_bits, low_bits,
2062                           &highest_bit_set, &lowest_bit_set,
2063                           &all_bits_between_are_set);
2064
2065   /* First try for a 2-insn sequence.  */
2066
2067   /* These situations are preferred because the optimizer can
2068    * do more things with them:
2069    * 1) mov     -1, %reg
2070    *    sllx    %reg, shift, %reg
2071    * 2) mov     -1, %reg
2072    *    srlx    %reg, shift, %reg
2073    * 3) mov     some_small_const, %reg
2074    *    sllx    %reg, shift, %reg
2075    */
2076   if (((highest_bit_set == 63
2077         || lowest_bit_set == 0)
2078        && all_bits_between_are_set != 0)
2079       || ((highest_bit_set - lowest_bit_set) < 12))
2080     {
2081       HOST_WIDE_INT the_const = -1;
2082       int shift = lowest_bit_set;
2083
2084       if ((highest_bit_set != 63
2085            && lowest_bit_set != 0)
2086           || all_bits_between_are_set == 0)
2087         {
2088           the_const =
2089             create_simple_focus_bits (high_bits, low_bits,
2090                                       lowest_bit_set, 0);
2091         }
2092       else if (lowest_bit_set == 0)
2093         shift = -(63 - highest_bit_set);
2094
2095       gcc_assert (SPARC_SIMM13_P (the_const));
2096       gcc_assert (shift != 0);
2097
2098       emit_insn (gen_safe_SET64 (temp, the_const));
2099       if (shift > 0)
2100         emit_insn (gen_rtx_SET (VOIDmode,
2101                                 op0,
2102                                 gen_rtx_ASHIFT (DImode,
2103                                                 temp,
2104                                                 GEN_INT (shift))));
2105       else if (shift < 0)
2106         emit_insn (gen_rtx_SET (VOIDmode,
2107                                 op0,
2108                                 gen_rtx_LSHIFTRT (DImode,
2109                                                   temp,
2110                                                   GEN_INT (-shift))));
2111       return;
2112     }
2113
2114   /* Now a range of 22 or less bits set somewhere.
2115    * 1) sethi   %hi(focus_bits), %reg
2116    *    sllx    %reg, shift, %reg
2117    * 2) sethi   %hi(focus_bits), %reg
2118    *    srlx    %reg, shift, %reg
2119    */
2120   if ((highest_bit_set - lowest_bit_set) < 21)
2121     {
2122       unsigned HOST_WIDE_INT focus_bits =
2123         create_simple_focus_bits (high_bits, low_bits,
2124                                   lowest_bit_set, 10);
2125
2126       gcc_assert (SPARC_SETHI_P (focus_bits));
2127       gcc_assert (lowest_bit_set != 10);
2128
2129       emit_insn (gen_safe_HIGH64 (temp, focus_bits));
2130
2131       /* If lowest_bit_set == 10 then a sethi alone could have done it.  */
2132       if (lowest_bit_set < 10)
2133         emit_insn (gen_rtx_SET (VOIDmode,
2134                                 op0,
2135                                 gen_rtx_LSHIFTRT (DImode, temp,
2136                                                   GEN_INT (10 - lowest_bit_set))));
2137       else if (lowest_bit_set > 10)
2138         emit_insn (gen_rtx_SET (VOIDmode,
2139                                 op0,
2140                                 gen_rtx_ASHIFT (DImode, temp,
2141                                                 GEN_INT (lowest_bit_set - 10))));
2142       return;
2143     }
2144
2145   /* 1) sethi   %hi(low_bits), %reg
2146    *    or      %reg, %lo(low_bits), %reg
2147    * 2) sethi   %hi(~low_bits), %reg
2148    *    xor     %reg, %lo(-0x400 | (low_bits & 0x3ff)), %reg
2149    */
2150   if (high_bits == 0
2151       || high_bits == 0xffffffff)
2152     {
2153       sparc_emit_set_const64_quick1 (op0, temp, low_bits,
2154                                      (high_bits == 0xffffffff));
2155       return;
2156     }
2157
2158   /* Now, try 3-insn sequences.  */
2159
2160   /* 1) sethi   %hi(high_bits), %reg
2161    *    or      %reg, %lo(high_bits), %reg
2162    *    sllx    %reg, 32, %reg
2163    */
2164   if (low_bits == 0)
2165     {
2166       sparc_emit_set_const64_quick2 (op0, temp, high_bits, 0, 32);
2167       return;
2168     }
2169
2170   /* We may be able to do something quick
2171      when the constant is negated, so try that.  */
2172   if (const64_is_2insns ((~high_bits) & 0xffffffff,
2173                          (~low_bits) & 0xfffffc00))
2174     {
2175       /* NOTE: The trailing bits get XOR'd so we need the
2176          non-negated bits, not the negated ones.  */
2177       unsigned HOST_WIDE_INT trailing_bits = low_bits & 0x3ff;
2178
2179       if ((((~high_bits) & 0xffffffff) == 0
2180            && ((~low_bits) & 0x80000000) == 0)
2181           || (((~high_bits) & 0xffffffff) == 0xffffffff
2182               && ((~low_bits) & 0x80000000) != 0))
2183         {
2184           unsigned HOST_WIDE_INT fast_int = (~low_bits & 0xffffffff);
2185
2186           if ((SPARC_SETHI_P (fast_int)
2187                && (~high_bits & 0xffffffff) == 0)
2188               || SPARC_SIMM13_P (fast_int))
2189             emit_insn (gen_safe_SET64 (temp, fast_int));
2190           else
2191             sparc_emit_set_const64 (temp, GEN_INT (fast_int));
2192         }
2193       else
2194         {
2195           rtx negated_const;
2196           negated_const = GEN_INT (((~low_bits) & 0xfffffc00) |
2197                                    (((HOST_WIDE_INT)((~high_bits) & 0xffffffff))<<32));
2198           sparc_emit_set_const64 (temp, negated_const);
2199         }
2200
2201       /* If we are XOR'ing with -1, then we should emit a one's complement
2202          instead.  This way the combiner will notice logical operations
2203          such as ANDN later on and substitute.  */
2204       if (trailing_bits == 0x3ff)
2205         {
2206           emit_insn (gen_rtx_SET (VOIDmode, op0,
2207                                   gen_rtx_NOT (DImode, temp)));
2208         }
2209       else
2210         {
2211           emit_insn (gen_rtx_SET (VOIDmode,
2212                                   op0,
2213                                   gen_safe_XOR64 (temp,
2214                                                   (-0x400 | trailing_bits))));
2215         }
2216       return;
2217     }
2218
2219   /* 1) sethi   %hi(xxx), %reg
2220    *    or      %reg, %lo(xxx), %reg
2221    *    sllx    %reg, yyy, %reg
2222    *
2223    * ??? This is just a generalized version of the low_bits==0
2224    * thing above, FIXME...
2225    */
2226   if ((highest_bit_set - lowest_bit_set) < 32)
2227     {
2228       unsigned HOST_WIDE_INT focus_bits =
2229         create_simple_focus_bits (high_bits, low_bits,
2230                                   lowest_bit_set, 0);
2231
2232       /* We can't get here in this state.  */
2233       gcc_assert (highest_bit_set >= 32 && lowest_bit_set < 32);
2234
2235       /* So what we know is that the set bits straddle the
2236          middle of the 64-bit word.  */
2237       sparc_emit_set_const64_quick2 (op0, temp,
2238                                      focus_bits, 0,
2239                                      lowest_bit_set);
2240       return;
2241     }
2242
2243   /* 1) sethi   %hi(high_bits), %reg
2244    *    or      %reg, %lo(high_bits), %reg
2245    *    sllx    %reg, 32, %reg
2246    *    or      %reg, low_bits, %reg
2247    */
2248   if (SPARC_SIMM13_P(low_bits)
2249       && ((int)low_bits > 0))
2250     {
2251       sparc_emit_set_const64_quick2 (op0, temp, high_bits, low_bits, 32);
2252       return;
2253     }
2254
2255   /* The easiest way when all else fails, is full decomposition.  */
2256   sparc_emit_set_const64_longway (op0, temp, high_bits, low_bits);
2257 }
2258 #endif /* HOST_BITS_PER_WIDE_INT == 32 */
2259
2260 /* Given a comparison code (EQ, NE, etc.) and the first operand of a COMPARE,
2261    return the mode to be used for the comparison.  For floating-point,
2262    CCFP[E]mode is used.  CC_NOOVmode should be used when the first operand
2263    is a PLUS, MINUS, NEG, or ASHIFT.  CCmode should be used when no special
2264    processing is needed.  */
2265
2266 enum machine_mode
2267 select_cc_mode (enum rtx_code op, rtx x, rtx y ATTRIBUTE_UNUSED)
2268 {
2269   if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2270     {
2271       switch (op)
2272         {
2273         case EQ:
2274         case NE:
2275         case UNORDERED:
2276         case ORDERED:
2277         case UNLT:
2278         case UNLE:
2279         case UNGT:
2280         case UNGE:
2281         case UNEQ:
2282         case LTGT:
2283           return CCFPmode;
2284
2285         case LT:
2286         case LE:
2287         case GT:
2288         case GE:
2289           return CCFPEmode;
2290
2291         default:
2292           gcc_unreachable ();
2293         }
2294     }
2295   else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
2296            || GET_CODE (x) == NEG || GET_CODE (x) == ASHIFT)
2297     {
2298       if (TARGET_ARCH64 && GET_MODE (x) == DImode)
2299         return CCX_NOOVmode;
2300       else
2301         return CC_NOOVmode;
2302     }
2303   else
2304     {
2305       if (TARGET_ARCH64 && GET_MODE (x) == DImode)
2306         return CCXmode;
2307       else
2308         return CCmode;
2309     }
2310 }
2311
2312 /* Emit the compare insn and return the CC reg for a CODE comparison
2313    with operands X and Y.  */
2314
2315 static rtx
2316 gen_compare_reg_1 (enum rtx_code code, rtx x, rtx y)
2317 {
2318   enum machine_mode mode;
2319   rtx cc_reg;
2320
2321   if (GET_MODE_CLASS (GET_MODE (x)) == MODE_CC)
2322     return x;
2323
2324   mode = SELECT_CC_MODE (code, x, y);
2325
2326   /* ??? We don't have movcc patterns so we cannot generate pseudo regs for the
2327      fcc regs (cse can't tell they're really call clobbered regs and will
2328      remove a duplicate comparison even if there is an intervening function
2329      call - it will then try to reload the cc reg via an int reg which is why
2330      we need the movcc patterns).  It is possible to provide the movcc
2331      patterns by using the ldxfsr/stxfsr v9 insns.  I tried it: you need two
2332      registers (say %g1,%g5) and it takes about 6 insns.  A better fix would be
2333      to tell cse that CCFPE mode registers (even pseudos) are call
2334      clobbered.  */
2335
2336   /* ??? This is an experiment.  Rather than making changes to cse which may
2337      or may not be easy/clean, we do our own cse.  This is possible because
2338      we will generate hard registers.  Cse knows they're call clobbered (it
2339      doesn't know the same thing about pseudos). If we guess wrong, no big
2340      deal, but if we win, great!  */
2341
2342   if (TARGET_V9 && GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2343 #if 1 /* experiment */
2344     {
2345       int reg;
2346       /* We cycle through the registers to ensure they're all exercised.  */
2347       static int next_fcc_reg = 0;
2348       /* Previous x,y for each fcc reg.  */
2349       static rtx prev_args[4][2];
2350
2351       /* Scan prev_args for x,y.  */
2352       for (reg = 0; reg < 4; reg++)
2353         if (prev_args[reg][0] == x && prev_args[reg][1] == y)
2354           break;
2355       if (reg == 4)
2356         {
2357           reg = next_fcc_reg;
2358           prev_args[reg][0] = x;
2359           prev_args[reg][1] = y;
2360           next_fcc_reg = (next_fcc_reg + 1) & 3;
2361         }
2362       cc_reg = gen_rtx_REG (mode, reg + SPARC_FIRST_V9_FCC_REG);
2363     }
2364 #else
2365     cc_reg = gen_reg_rtx (mode);
2366 #endif /* ! experiment */
2367   else if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2368     cc_reg = gen_rtx_REG (mode, SPARC_FCC_REG);
2369   else
2370     cc_reg = gen_rtx_REG (mode, SPARC_ICC_REG);
2371
2372   /* We shouldn't get there for TFmode if !TARGET_HARD_QUAD.  If we do, this
2373      will only result in an unrecognizable insn so no point in asserting.  */
2374   emit_insn (gen_rtx_SET (VOIDmode, cc_reg, gen_rtx_COMPARE (mode, x, y)));
2375
2376   return cc_reg;
2377 }
2378
2379
2380 /* Emit the compare insn and return the CC reg for the comparison in CMP.  */
2381
2382 rtx
2383 gen_compare_reg (rtx cmp)
2384 {
2385   return gen_compare_reg_1 (GET_CODE (cmp), XEXP (cmp, 0), XEXP (cmp, 1));
2386 }
2387
2388 /* This function is used for v9 only.
2389    DEST is the target of the Scc insn.
2390    CODE is the code for an Scc's comparison.
2391    X and Y are the values we compare.
2392
2393    This function is needed to turn
2394
2395            (set (reg:SI 110)
2396                (gt (reg:CCX 100 %icc)
2397                    (const_int 0)))
2398    into
2399            (set (reg:SI 110)
2400                (gt:DI (reg:CCX 100 %icc)
2401                    (const_int 0)))
2402
2403    IE: The instruction recognizer needs to see the mode of the comparison to
2404    find the right instruction. We could use "gt:DI" right in the
2405    define_expand, but leaving it out allows us to handle DI, SI, etc.  */
2406
2407 static int
2408 gen_v9_scc (rtx dest, enum rtx_code compare_code, rtx x, rtx y)
2409 {
2410   if (! TARGET_ARCH64
2411       && (GET_MODE (x) == DImode
2412           || GET_MODE (dest) == DImode))
2413     return 0;
2414
2415   /* Try to use the movrCC insns.  */
2416   if (TARGET_ARCH64
2417       && GET_MODE_CLASS (GET_MODE (x)) == MODE_INT
2418       && y == const0_rtx
2419       && v9_regcmp_p (compare_code))
2420     {
2421       rtx op0 = x;
2422       rtx temp;
2423
2424       /* Special case for op0 != 0.  This can be done with one instruction if
2425          dest == x.  */
2426
2427       if (compare_code == NE
2428           && GET_MODE (dest) == DImode
2429           && rtx_equal_p (op0, dest))
2430         {
2431           emit_insn (gen_rtx_SET (VOIDmode, dest,
2432                               gen_rtx_IF_THEN_ELSE (DImode,
2433                                        gen_rtx_fmt_ee (compare_code, DImode,
2434                                                        op0, const0_rtx),
2435                                        const1_rtx,
2436                                        dest)));
2437           return 1;
2438         }
2439
2440       if (reg_overlap_mentioned_p (dest, op0))
2441         {
2442           /* Handle the case where dest == x.
2443              We "early clobber" the result.  */
2444           op0 = gen_reg_rtx (GET_MODE (x));
2445           emit_move_insn (op0, x);
2446         }
2447
2448       emit_insn (gen_rtx_SET (VOIDmode, dest, const0_rtx));
2449       if (GET_MODE (op0) != DImode)
2450         {
2451           temp = gen_reg_rtx (DImode);
2452           convert_move (temp, op0, 0);
2453         }
2454       else
2455         temp = op0;
2456       emit_insn (gen_rtx_SET (VOIDmode, dest,
2457                           gen_rtx_IF_THEN_ELSE (GET_MODE (dest),
2458                                    gen_rtx_fmt_ee (compare_code, DImode,
2459                                                    temp, const0_rtx),
2460                                    const1_rtx,
2461                                    dest)));
2462       return 1;
2463     }
2464   else
2465     {
2466       x = gen_compare_reg_1 (compare_code, x, y);
2467       y = const0_rtx;
2468
2469       gcc_assert (GET_MODE (x) != CC_NOOVmode
2470                   && GET_MODE (x) != CCX_NOOVmode);
2471
2472       emit_insn (gen_rtx_SET (VOIDmode, dest, const0_rtx));
2473       emit_insn (gen_rtx_SET (VOIDmode, dest,
2474                           gen_rtx_IF_THEN_ELSE (GET_MODE (dest),
2475                                    gen_rtx_fmt_ee (compare_code,
2476                                                    GET_MODE (x), x, y),
2477                                     const1_rtx, dest)));
2478       return 1;
2479     }
2480 }
2481
2482
2483 /* Emit an scc insn.  For seq, sne, sgeu, and sltu, we can do this
2484    without jumps using the addx/subx instructions.  */
2485
2486 bool
2487 emit_scc_insn (rtx operands[])
2488 {
2489   rtx tem;
2490   rtx x;
2491   rtx y;
2492   enum rtx_code code;
2493
2494   /* The quad-word fp compare library routines all return nonzero to indicate
2495      true, which is different from the equivalent libgcc routines, so we must
2496      handle them specially here.  */
2497   if (GET_MODE (operands[2]) == TFmode && ! TARGET_HARD_QUAD)
2498     {
2499       operands[1] = sparc_emit_float_lib_cmp (operands[2], operands[3],
2500                                               GET_CODE (operands[1]));
2501       operands[2] = XEXP (operands[1], 0);
2502       operands[3] = XEXP (operands[1], 1);
2503     }
2504
2505   code = GET_CODE (operands[1]);
2506   x = operands[2];
2507   y = operands[3];
2508
2509   /* For seq/sne on v9 we use the same code as v8 (the addx/subx method has
2510      more applications).  The exception to this is "reg != 0" which can
2511      be done in one instruction on v9 (so we do it).  */
2512   if (code == EQ)
2513     {
2514       if (GET_MODE (x) == SImode)
2515         {
2516           rtx pat = gen_seqsi_special (operands[0], x, y);
2517           emit_insn (pat);
2518           return true;
2519         }
2520       else if (GET_MODE (x) == DImode)
2521         {
2522           rtx pat = gen_seqdi_special (operands[0], x, y);
2523           emit_insn (pat);
2524           return true;
2525         }
2526     }
2527
2528   if (code == NE)
2529     {
2530       if (GET_MODE (x) == SImode)
2531         {
2532           rtx pat = gen_snesi_special (operands[0], x, y);
2533           emit_insn (pat);
2534           return true;
2535         }
2536       else if (GET_MODE (x) == DImode)
2537         {
2538           rtx pat = gen_snedi_special (operands[0], x, y);
2539           emit_insn (pat);
2540           return true;
2541         }
2542     }
2543
2544   /* For the rest, on v9 we can use conditional moves.  */
2545
2546   if (TARGET_V9)
2547     {
2548       if (gen_v9_scc (operands[0], code, x, y))
2549         return true;
2550     }
2551
2552   /* We can do LTU and GEU using the addx/subx instructions too.  And
2553      for GTU/LEU, if both operands are registers swap them and fall
2554      back to the easy case.  */
2555   if (code == GTU || code == LEU)
2556     {
2557       if ((GET_CODE (x) == REG || GET_CODE (x) == SUBREG)
2558           && (GET_CODE (y) == REG || GET_CODE (y) == SUBREG))
2559         {
2560           tem = x;
2561           x = y;
2562           y = tem;
2563           code = swap_condition (code);
2564         }
2565     }
2566
2567   if (code == LTU || code == GEU)
2568     {
2569       emit_insn (gen_rtx_SET (VOIDmode, operands[0],
2570                               gen_rtx_fmt_ee (code, SImode,
2571                                               gen_compare_reg_1 (code, x, y),
2572                                               const0_rtx)));
2573       return true;
2574     }
2575
2576   /* Nope, do branches.  */
2577   return false;
2578 }
2579
2580 /* Emit a conditional jump insn for the v9 architecture using comparison code
2581    CODE and jump target LABEL.
2582    This function exists to take advantage of the v9 brxx insns.  */
2583
2584 static void
2585 emit_v9_brxx_insn (enum rtx_code code, rtx op0, rtx label)
2586 {
2587   emit_jump_insn (gen_rtx_SET (VOIDmode,
2588                            pc_rtx,
2589                            gen_rtx_IF_THEN_ELSE (VOIDmode,
2590                                     gen_rtx_fmt_ee (code, GET_MODE (op0),
2591                                                     op0, const0_rtx),
2592                                     gen_rtx_LABEL_REF (VOIDmode, label),
2593                                     pc_rtx)));
2594 }
2595
2596 void
2597 emit_conditional_branch_insn (rtx operands[])
2598 {
2599   /* The quad-word fp compare library routines all return nonzero to indicate
2600      true, which is different from the equivalent libgcc routines, so we must
2601      handle them specially here.  */
2602   if (GET_MODE (operands[1]) == TFmode && ! TARGET_HARD_QUAD)
2603     {
2604       operands[0] = sparc_emit_float_lib_cmp (operands[1], operands[2],
2605                                               GET_CODE (operands[0]));
2606       operands[1] = XEXP (operands[0], 0);
2607       operands[2] = XEXP (operands[0], 1);
2608     }
2609
2610   if (TARGET_ARCH64 && operands[2] == const0_rtx
2611       && GET_CODE (operands[1]) == REG
2612       && GET_MODE (operands[1]) == DImode)
2613     {
2614       emit_v9_brxx_insn (GET_CODE (operands[0]), operands[1], operands[3]);
2615       return;
2616     }
2617
2618   operands[1] = gen_compare_reg (operands[0]);
2619   operands[2] = const0_rtx;
2620   operands[0] = gen_rtx_fmt_ee (GET_CODE (operands[0]), VOIDmode,
2621                                 operands[1], operands[2]);
2622   emit_jump_insn (gen_cbranchcc4 (operands[0], operands[1], operands[2],
2623                                   operands[3]));
2624 }
2625
2626
2627 /* Generate a DFmode part of a hard TFmode register.
2628    REG is the TFmode hard register, LOW is 1 for the
2629    low 64bit of the register and 0 otherwise.
2630  */
2631 rtx
2632 gen_df_reg (rtx reg, int low)
2633 {
2634   int regno = REGNO (reg);
2635
2636   if ((WORDS_BIG_ENDIAN == 0) ^ (low != 0))
2637     regno += (TARGET_ARCH64 && SPARC_INT_REG_P (regno)) ? 1 : 2;
2638   return gen_rtx_REG (DFmode, regno);
2639 }
2640 \f
2641 /* Generate a call to FUNC with OPERANDS.  Operand 0 is the return value.
2642    Unlike normal calls, TFmode operands are passed by reference.  It is
2643    assumed that no more than 3 operands are required.  */
2644
2645 static void
2646 emit_soft_tfmode_libcall (const char *func_name, int nargs, rtx *operands)
2647 {
2648   rtx ret_slot = NULL, arg[3], func_sym;
2649   int i;
2650
2651   /* We only expect to be called for conversions, unary, and binary ops.  */
2652   gcc_assert (nargs == 2 || nargs == 3);
2653
2654   for (i = 0; i < nargs; ++i)
2655     {
2656       rtx this_arg = operands[i];
2657       rtx this_slot;
2658
2659       /* TFmode arguments and return values are passed by reference.  */
2660       if (GET_MODE (this_arg) == TFmode)
2661         {
2662           int force_stack_temp;
2663
2664           force_stack_temp = 0;
2665           if (TARGET_BUGGY_QP_LIB && i == 0)
2666             force_stack_temp = 1;
2667
2668           if (GET_CODE (this_arg) == MEM
2669               && ! force_stack_temp)
2670             this_arg = XEXP (this_arg, 0);
2671           else if (CONSTANT_P (this_arg)
2672                    && ! force_stack_temp)
2673             {
2674               this_slot = force_const_mem (TFmode, this_arg);
2675               this_arg = XEXP (this_slot, 0);
2676             }
2677           else
2678             {
2679               this_slot = assign_stack_temp (TFmode, GET_MODE_SIZE (TFmode), 0);
2680
2681               /* Operand 0 is the return value.  We'll copy it out later.  */
2682               if (i > 0)
2683                 emit_move_insn (this_slot, this_arg);
2684               else
2685                 ret_slot = this_slot;
2686
2687               this_arg = XEXP (this_slot, 0);
2688             }
2689         }
2690
2691       arg[i] = this_arg;
2692     }
2693
2694   func_sym = gen_rtx_SYMBOL_REF (Pmode, func_name);
2695
2696   if (GET_MODE (operands[0]) == TFmode)
2697     {
2698       if (nargs == 2)
2699         emit_library_call (func_sym, LCT_NORMAL, VOIDmode, 2,
2700                            arg[0], GET_MODE (arg[0]),
2701                            arg[1], GET_MODE (arg[1]));
2702       else
2703         emit_library_call (func_sym, LCT_NORMAL, VOIDmode, 3,
2704                            arg[0], GET_MODE (arg[0]),
2705                            arg[1], GET_MODE (arg[1]),
2706                            arg[2], GET_MODE (arg[2]));
2707
2708       if (ret_slot)
2709         emit_move_insn (operands[0], ret_slot);
2710     }
2711   else
2712     {
2713       rtx ret;
2714
2715       gcc_assert (nargs == 2);
2716
2717       ret = emit_library_call_value (func_sym, operands[0], LCT_NORMAL,
2718                                      GET_MODE (operands[0]), 1,
2719                                      arg[1], GET_MODE (arg[1]));
2720
2721       if (ret != operands[0])
2722         emit_move_insn (operands[0], ret);
2723     }
2724 }
2725
2726 /* Expand soft-float TFmode calls to sparc abi routines.  */
2727
2728 static void
2729 emit_soft_tfmode_binop (enum rtx_code code, rtx *operands)
2730 {
2731   const char *func;
2732
2733   switch (code)
2734     {
2735     case PLUS:
2736       func = "_Qp_add";
2737       break;
2738     case MINUS:
2739       func = "_Qp_sub";
2740       break;
2741     case MULT:
2742       func = "_Qp_mul";
2743       break;
2744     case DIV:
2745       func = "_Qp_div";
2746       break;
2747     default:
2748       gcc_unreachable ();
2749     }
2750
2751   emit_soft_tfmode_libcall (func, 3, operands);
2752 }
2753
2754 static void
2755 emit_soft_tfmode_unop (enum rtx_code code, rtx *operands)
2756 {
2757   const char *func;
2758
2759   gcc_assert (code == SQRT);
2760   func = "_Qp_sqrt";
2761
2762   emit_soft_tfmode_libcall (func, 2, operands);
2763 }
2764
2765 static void
2766 emit_soft_tfmode_cvt (enum rtx_code code, rtx *operands)
2767 {
2768   const char *func;
2769
2770   switch (code)
2771     {
2772     case FLOAT_EXTEND:
2773       switch (GET_MODE (operands[1]))
2774         {
2775         case SFmode:
2776           func = "_Qp_stoq";
2777           break;
2778         case DFmode:
2779           func = "_Qp_dtoq";
2780           break;
2781         default:
2782           gcc_unreachable ();
2783         }
2784       break;
2785
2786     case FLOAT_TRUNCATE:
2787       switch (GET_MODE (operands[0]))
2788         {
2789         case SFmode:
2790           func = "_Qp_qtos";
2791           break;
2792         case DFmode:
2793           func = "_Qp_qtod";
2794           break;
2795         default:
2796           gcc_unreachable ();
2797         }
2798       break;
2799
2800     case FLOAT:
2801       switch (GET_MODE (operands[1]))
2802         {
2803         case SImode:
2804           func = "_Qp_itoq";
2805           if (TARGET_ARCH64)
2806             operands[1] = gen_rtx_SIGN_EXTEND (DImode, operands[1]);
2807           break;
2808         case DImode:
2809           func = "_Qp_xtoq";
2810           break;
2811         default:
2812           gcc_unreachable ();
2813         }
2814       break;
2815
2816     case UNSIGNED_FLOAT:
2817       switch (GET_MODE (operands[1]))
2818         {
2819         case SImode:
2820           func = "_Qp_uitoq";
2821           if (TARGET_ARCH64)
2822             operands[1] = gen_rtx_ZERO_EXTEND (DImode, operands[1]);
2823           break;
2824         case DImode:
2825           func = "_Qp_uxtoq";
2826           break;
2827         default:
2828           gcc_unreachable ();
2829         }
2830       break;
2831
2832     case FIX:
2833       switch (GET_MODE (operands[0]))
2834         {
2835         case SImode:
2836           func = "_Qp_qtoi";
2837           break;
2838         case DImode:
2839           func = "_Qp_qtox";
2840           break;
2841         default:
2842           gcc_unreachable ();
2843         }
2844       break;
2845
2846     case UNSIGNED_FIX:
2847       switch (GET_MODE (operands[0]))
2848         {
2849         case SImode:
2850           func = "_Qp_qtoui";
2851           break;
2852         case DImode:
2853           func = "_Qp_qtoux";
2854           break;
2855         default:
2856           gcc_unreachable ();
2857         }
2858       break;
2859
2860     default:
2861       gcc_unreachable ();
2862     }
2863
2864   emit_soft_tfmode_libcall (func, 2, operands);
2865 }
2866
2867 /* Expand a hard-float tfmode operation.  All arguments must be in
2868    registers.  */
2869
2870 static void
2871 emit_hard_tfmode_operation (enum rtx_code code, rtx *operands)
2872 {
2873   rtx op, dest;
2874
2875   if (GET_RTX_CLASS (code) == RTX_UNARY)
2876     {
2877       operands[1] = force_reg (GET_MODE (operands[1]), operands[1]);
2878       op = gen_rtx_fmt_e (code, GET_MODE (operands[0]), operands[1]);
2879     }
2880   else
2881     {
2882       operands[1] = force_reg (GET_MODE (operands[1]), operands[1]);
2883       operands[2] = force_reg (GET_MODE (operands[2]), operands[2]);
2884       op = gen_rtx_fmt_ee (code, GET_MODE (operands[0]),
2885                            operands[1], operands[2]);
2886     }
2887
2888   if (register_operand (operands[0], VOIDmode))
2889     dest = operands[0];
2890   else
2891     dest = gen_reg_rtx (GET_MODE (operands[0]));
2892
2893   emit_insn (gen_rtx_SET (VOIDmode, dest, op));
2894
2895   if (dest != operands[0])
2896     emit_move_insn (operands[0], dest);
2897 }
2898
2899 void
2900 emit_tfmode_binop (enum rtx_code code, rtx *operands)
2901 {
2902   if (TARGET_HARD_QUAD)
2903     emit_hard_tfmode_operation (code, operands);
2904   else
2905     emit_soft_tfmode_binop (code, operands);
2906 }
2907
2908 void
2909 emit_tfmode_unop (enum rtx_code code, rtx *operands)
2910 {
2911   if (TARGET_HARD_QUAD)
2912     emit_hard_tfmode_operation (code, operands);
2913   else
2914     emit_soft_tfmode_unop (code, operands);
2915 }
2916
2917 void
2918 emit_tfmode_cvt (enum rtx_code code, rtx *operands)
2919 {
2920   if (TARGET_HARD_QUAD)
2921     emit_hard_tfmode_operation (code, operands);
2922   else
2923     emit_soft_tfmode_cvt (code, operands);
2924 }
2925 \f
2926 /* Return nonzero if a branch/jump/call instruction will be emitting
2927    nop into its delay slot.  */
2928
2929 int
2930 empty_delay_slot (rtx insn)
2931 {
2932   rtx seq;
2933
2934   /* If no previous instruction (should not happen), return true.  */
2935   if (PREV_INSN (insn) == NULL)
2936     return 1;
2937
2938   seq = NEXT_INSN (PREV_INSN (insn));
2939   if (GET_CODE (PATTERN (seq)) == SEQUENCE)
2940     return 0;
2941
2942   return 1;
2943 }
2944
2945 /* Return nonzero if TRIAL can go into the call delay slot.  */
2946
2947 int
2948 tls_call_delay (rtx trial)
2949 {
2950   rtx pat;
2951
2952   /* Binutils allows
2953        call __tls_get_addr, %tgd_call (foo)
2954         add %l7, %o0, %o0, %tgd_add (foo)
2955      while Sun as/ld does not.  */
2956   if (TARGET_GNU_TLS || !TARGET_TLS)
2957     return 1;
2958
2959   pat = PATTERN (trial);
2960
2961   /* We must reject tgd_add{32|64}, i.e.
2962        (set (reg) (plus (reg) (unspec [(reg) (symbol_ref)] UNSPEC_TLSGD)))
2963      and tldm_add{32|64}, i.e.
2964        (set (reg) (plus (reg) (unspec [(reg) (symbol_ref)] UNSPEC_TLSLDM)))
2965      for Sun as/ld.  */
2966   if (GET_CODE (pat) == SET
2967       && GET_CODE (SET_SRC (pat)) == PLUS)
2968     {
2969       rtx unspec = XEXP (SET_SRC (pat), 1);
2970
2971       if (GET_CODE (unspec) == UNSPEC
2972           && (XINT (unspec, 1) == UNSPEC_TLSGD
2973               || XINT (unspec, 1) == UNSPEC_TLSLDM))
2974         return 0;
2975     }
2976
2977   return 1;
2978 }
2979
2980 /* Return nonzero if TRIAL, an insn, can be combined with a 'restore'
2981    instruction.  RETURN_P is true if the v9 variant 'return' is to be
2982    considered in the test too.
2983
2984    TRIAL must be a SET whose destination is a REG appropriate for the
2985    'restore' instruction or, if RETURN_P is true, for the 'return'
2986    instruction.  */
2987
2988 static int
2989 eligible_for_restore_insn (rtx trial, bool return_p)
2990 {
2991   rtx pat = PATTERN (trial);
2992   rtx src = SET_SRC (pat);
2993   bool src_is_freg = false;
2994   rtx src_reg;
2995
2996   /* Since we now can do moves between float and integer registers when
2997      VIS3 is enabled, we have to catch this case.  We can allow such
2998      moves when doing a 'return' however.  */
2999   src_reg = src;
3000   if (GET_CODE (src_reg) == SUBREG)
3001     src_reg = SUBREG_REG (src_reg);
3002   if (GET_CODE (src_reg) == REG
3003       && SPARC_FP_REG_P (REGNO (src_reg)))
3004     src_is_freg = true;
3005
3006   /* The 'restore src,%g0,dest' pattern for word mode and below.  */
3007   if (GET_MODE_CLASS (GET_MODE (src)) != MODE_FLOAT
3008       && arith_operand (src, GET_MODE (src))
3009       && ! src_is_freg)
3010     {
3011       if (TARGET_ARCH64)
3012         return GET_MODE_SIZE (GET_MODE (src)) <= GET_MODE_SIZE (DImode);
3013       else
3014         return GET_MODE_SIZE (GET_MODE (src)) <= GET_MODE_SIZE (SImode);
3015     }
3016
3017   /* The 'restore src,%g0,dest' pattern for double-word mode.  */
3018   else if (GET_MODE_CLASS (GET_MODE (src)) != MODE_FLOAT
3019            && arith_double_operand (src, GET_MODE (src))
3020            && ! src_is_freg)
3021     return GET_MODE_SIZE (GET_MODE (src)) <= GET_MODE_SIZE (DImode);
3022
3023   /* The 'restore src,%g0,dest' pattern for float if no FPU.  */
3024   else if (! TARGET_FPU && register_operand (src, SFmode))
3025     return 1;
3026
3027   /* The 'restore src,%g0,dest' pattern for double if no FPU.  */
3028   else if (! TARGET_FPU && TARGET_ARCH64 && register_operand (src, DFmode))
3029     return 1;
3030
3031   /* If we have the 'return' instruction, anything that does not use
3032      local or output registers and can go into a delay slot wins.  */
3033   else if (return_p
3034            && TARGET_V9
3035            && !epilogue_renumber (&pat, 1)
3036            && get_attr_in_uncond_branch_delay (trial)
3037                == IN_UNCOND_BRANCH_DELAY_TRUE)
3038     return 1;
3039
3040   /* The 'restore src1,src2,dest' pattern for SImode.  */
3041   else if (GET_CODE (src) == PLUS
3042            && register_operand (XEXP (src, 0), SImode)
3043            && arith_operand (XEXP (src, 1), SImode))
3044     return 1;
3045
3046   /* The 'restore src1,src2,dest' pattern for DImode.  */
3047   else if (GET_CODE (src) == PLUS
3048            && register_operand (XEXP (src, 0), DImode)
3049            && arith_double_operand (XEXP (src, 1), DImode))
3050     return 1;
3051
3052   /* The 'restore src1,%lo(src2),dest' pattern.  */
3053   else if (GET_CODE (src) == LO_SUM
3054            && ! TARGET_CM_MEDMID
3055            && ((register_operand (XEXP (src, 0), SImode)
3056                 && immediate_operand (XEXP (src, 1), SImode))
3057                || (TARGET_ARCH64
3058                    && register_operand (XEXP (src, 0), DImode)
3059                    && immediate_operand (XEXP (src, 1), DImode))))
3060     return 1;
3061
3062   /* The 'restore src,src,dest' pattern.  */
3063   else if (GET_CODE (src) == ASHIFT
3064            && (register_operand (XEXP (src, 0), SImode)
3065                || register_operand (XEXP (src, 0), DImode))
3066            && XEXP (src, 1) == const1_rtx)
3067     return 1;
3068
3069   return 0;
3070 }
3071
3072 /* Return nonzero if TRIAL can go into the function return's delay slot.  */
3073
3074 int
3075 eligible_for_return_delay (rtx trial)
3076 {
3077   int regno;
3078   rtx pat;
3079
3080   if (GET_CODE (trial) != INSN)
3081     return 0;
3082
3083   if (get_attr_length (trial) != 1)
3084     return 0;
3085
3086   /* If the function uses __builtin_eh_return, the eh_return machinery
3087      occupies the delay slot.  */
3088   if (crtl->calls_eh_return)
3089     return 0;
3090
3091   /* In the case of a leaf or flat function, anything can go into the slot.  */
3092   if (sparc_leaf_function_p || TARGET_FLAT)
3093     return
3094       get_attr_in_uncond_branch_delay (trial) == IN_UNCOND_BRANCH_DELAY_TRUE;
3095
3096   pat = PATTERN (trial);
3097   if (GET_CODE (pat) == PARALLEL)
3098     {
3099       int i;
3100
3101       if (! TARGET_V9)
3102         return 0;
3103       for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)
3104         {
3105           rtx expr = XVECEXP (pat, 0, i);
3106           if (GET_CODE (expr) != SET)
3107             return 0;
3108           if (GET_CODE (SET_DEST (expr)) != REG)
3109             return 0;
3110           regno = REGNO (SET_DEST (expr));
3111           if (regno >= 8 && regno < 24)
3112             return 0;
3113         }
3114       return !epilogue_renumber (&pat, 1)
3115         && (get_attr_in_uncond_branch_delay (trial)
3116             == IN_UNCOND_BRANCH_DELAY_TRUE);
3117     }
3118
3119   if (GET_CODE (pat) != SET)
3120     return 0;
3121
3122   if (GET_CODE (SET_DEST (pat)) != REG)
3123     return 0;
3124
3125   regno = REGNO (SET_DEST (pat));
3126
3127   /* Otherwise, only operations which can be done in tandem with
3128      a `restore' or `return' insn can go into the delay slot.  */
3129   if (regno >= 8 && regno < 24)
3130     return 0;
3131
3132   /* If this instruction sets up floating point register and we have a return
3133      instruction, it can probably go in.  But restore will not work
3134      with FP_REGS.  */
3135   if (! SPARC_INT_REG_P (regno))
3136     return (TARGET_V9
3137             && !epilogue_renumber (&pat, 1)
3138             && get_attr_in_uncond_branch_delay (trial)
3139                == IN_UNCOND_BRANCH_DELAY_TRUE);
3140
3141   return eligible_for_restore_insn (trial, true);
3142 }
3143
3144 /* Return nonzero if TRIAL can go into the sibling call's delay slot.  */
3145
3146 int
3147 eligible_for_sibcall_delay (rtx trial)
3148 {
3149   rtx pat;
3150
3151   if (GET_CODE (trial) != INSN || GET_CODE (PATTERN (trial)) != SET)
3152     return 0;
3153
3154   if (get_attr_length (trial) != 1)
3155     return 0;
3156
3157   pat = PATTERN (trial);
3158
3159   if (sparc_leaf_function_p || TARGET_FLAT)
3160     {
3161       /* If the tail call is done using the call instruction,
3162          we have to restore %o7 in the delay slot.  */
3163       if (LEAF_SIBCALL_SLOT_RESERVED_P)
3164         return 0;
3165
3166       /* %g1 is used to build the function address */
3167       if (reg_mentioned_p (gen_rtx_REG (Pmode, 1), pat))
3168         return 0;
3169
3170       return 1;
3171     }
3172
3173   /* Otherwise, only operations which can be done in tandem with
3174      a `restore' insn can go into the delay slot.  */
3175   if (GET_CODE (SET_DEST (pat)) != REG
3176       || (REGNO (SET_DEST (pat)) >= 8 && REGNO (SET_DEST (pat)) < 24)
3177       || ! SPARC_INT_REG_P (REGNO (SET_DEST (pat))))
3178     return 0;
3179
3180   /* If it mentions %o7, it can't go in, because sibcall will clobber it
3181      in most cases.  */
3182   if (reg_mentioned_p (gen_rtx_REG (Pmode, 15), pat))
3183     return 0;
3184
3185   return eligible_for_restore_insn (trial, false);
3186 }
3187 \f
3188 /* Determine if it's legal to put X into the constant pool.  This
3189    is not possible if X contains the address of a symbol that is
3190    not constant (TLS) or not known at final link time (PIC).  */
3191
3192 static bool
3193 sparc_cannot_force_const_mem (enum machine_mode mode, rtx x)
3194 {
3195   switch (GET_CODE (x))
3196     {
3197     case CONST_INT:
3198     case CONST_DOUBLE:
3199     case CONST_VECTOR:
3200       /* Accept all non-symbolic constants.  */
3201       return false;
3202
3203     case LABEL_REF:
3204       /* Labels are OK iff we are non-PIC.  */
3205       return flag_pic != 0;
3206
3207     case SYMBOL_REF:
3208       /* 'Naked' TLS symbol references are never OK,
3209          non-TLS symbols are OK iff we are non-PIC.  */
3210       if (SYMBOL_REF_TLS_MODEL (x))
3211         return true;
3212       else
3213         return flag_pic != 0;
3214
3215     case CONST:
3216       return sparc_cannot_force_const_mem (mode, XEXP (x, 0));
3217     case PLUS:
3218     case MINUS:
3219       return sparc_cannot_force_const_mem (mode, XEXP (x, 0))
3220          || sparc_cannot_force_const_mem (mode, XEXP (x, 1));
3221     case UNSPEC:
3222       return true;
3223     default:
3224       gcc_unreachable ();
3225     }
3226 }
3227 \f
3228 /* Global Offset Table support.  */
3229 static GTY(()) rtx got_helper_rtx = NULL_RTX;
3230 static GTY(()) rtx global_offset_table_rtx = NULL_RTX;
3231
3232 /* Return the SYMBOL_REF for the Global Offset Table.  */
3233
3234 static GTY(()) rtx sparc_got_symbol = NULL_RTX;
3235
3236 static rtx
3237 sparc_got (void)
3238 {
3239   if (!sparc_got_symbol)
3240     sparc_got_symbol = gen_rtx_SYMBOL_REF (Pmode, "_GLOBAL_OFFSET_TABLE_");
3241
3242   return sparc_got_symbol;
3243 }
3244
3245 /* Ensure that we are not using patterns that are not OK with PIC.  */
3246
3247 int
3248 check_pic (int i)
3249 {
3250   rtx op;
3251
3252   switch (flag_pic)
3253     {
3254     case 1:
3255       op = recog_data.operand[i];
3256       gcc_assert (GET_CODE (op) != SYMBOL_REF
3257                   && (GET_CODE (op) != CONST
3258                       || (GET_CODE (XEXP (op, 0)) == MINUS
3259                           && XEXP (XEXP (op, 0), 0) == sparc_got ()
3260                           && GET_CODE (XEXP (XEXP (op, 0), 1)) == CONST)));
3261     case 2:
3262     default:
3263       return 1;
3264     }
3265 }
3266
3267 /* Return true if X is an address which needs a temporary register when
3268    reloaded while generating PIC code.  */
3269
3270 int
3271 pic_address_needs_scratch (rtx x)
3272 {
3273   /* An address which is a symbolic plus a non SMALL_INT needs a temp reg.  */
3274   if (GET_CODE (x) == CONST && GET_CODE (XEXP (x, 0)) == PLUS
3275       && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
3276       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
3277       && ! SMALL_INT (XEXP (XEXP (x, 0), 1)))
3278     return 1;
3279
3280   return 0;
3281 }
3282
3283 /* Determine if a given RTX is a valid constant.  We already know this
3284    satisfies CONSTANT_P.  */
3285
3286 static bool
3287 sparc_legitimate_constant_p (enum machine_mode mode, rtx x)
3288 {
3289   switch (GET_CODE (x))
3290     {
3291     case CONST:
3292     case SYMBOL_REF:
3293       if (sparc_tls_referenced_p (x))
3294         return false;
3295       break;
3296
3297     case CONST_DOUBLE:
3298       if (GET_MODE (x) == VOIDmode)
3299         return true;
3300
3301       /* Floating point constants are generally not ok.
3302          The only exception is 0.0 and all-ones in VIS.  */
3303       if (TARGET_VIS
3304           && SCALAR_FLOAT_MODE_P (mode)
3305           && (const_zero_operand (x, mode)
3306               || const_all_ones_operand (x, mode)))
3307         return true;
3308
3309       return false;
3310
3311     case CONST_VECTOR:
3312       /* Vector constants are generally not ok.
3313          The only exception is 0 or -1 in VIS.  */
3314       if (TARGET_VIS
3315           && (const_zero_operand (x, mode)
3316               || const_all_ones_operand (x, mode)))
3317         return true;
3318
3319       return false;
3320
3321     default:
3322       break;
3323     }
3324
3325   return true;
3326 }
3327
3328 /* Determine if a given RTX is a valid constant address.  */
3329
3330 bool
3331 constant_address_p (rtx x)
3332 {
3333   switch (GET_CODE (x))
3334     {
3335     case LABEL_REF:
3336     case CONST_INT:
3337     case HIGH:
3338       return true;
3339
3340     case CONST:
3341       if (flag_pic && pic_address_needs_scratch (x))
3342         return false;
3343       return sparc_legitimate_constant_p (Pmode, x);
3344
3345     case SYMBOL_REF:
3346       return !flag_pic && sparc_legitimate_constant_p (Pmode, x);
3347
3348     default:
3349       return false;
3350     }
3351 }
3352
3353 /* Nonzero if the constant value X is a legitimate general operand
3354    when generating PIC code.  It is given that flag_pic is on and
3355    that X satisfies CONSTANT_P or is a CONST_DOUBLE.  */
3356
3357 bool
3358 legitimate_pic_operand_p (rtx x)
3359 {
3360   if (pic_address_needs_scratch (x))
3361     return false;
3362   if (sparc_tls_referenced_p (x))
3363     return false;
3364   return true;
3365 }
3366
3367 #define RTX_OK_FOR_OFFSET_P(X, MODE)                    \
3368   (CONST_INT_P (X)                                      \
3369    && INTVAL (X) >= -0x1000                             \
3370    && INTVAL (X) < (0x1000 - GET_MODE_SIZE (MODE)))
3371
3372 #define RTX_OK_FOR_OLO10_P(X, MODE)                     \
3373   (CONST_INT_P (X)                                      \
3374    && INTVAL (X) >= -0x1000                             \
3375    && INTVAL (X) < (0xc00 - GET_MODE_SIZE (MODE)))
3376
3377 /* Handle the TARGET_LEGITIMATE_ADDRESS_P target hook.
3378
3379    On SPARC, the actual legitimate addresses must be REG+REG or REG+SMALLINT
3380    ordinarily.  This changes a bit when generating PIC.  */
3381
3382 static bool
3383 sparc_legitimate_address_p (enum machine_mode mode, rtx addr, bool strict)
3384 {
3385   rtx rs1 = NULL, rs2 = NULL, imm1 = NULL;
3386
3387   if (REG_P (addr) || GET_CODE (addr) == SUBREG)
3388     rs1 = addr;
3389   else if (GET_CODE (addr) == PLUS)
3390     {
3391       rs1 = XEXP (addr, 0);
3392       rs2 = XEXP (addr, 1);
3393
3394       /* Canonicalize.  REG comes first, if there are no regs,
3395          LO_SUM comes first.  */
3396       if (!REG_P (rs1)
3397           && GET_CODE (rs1) != SUBREG
3398           && (REG_P (rs2)
3399               || GET_CODE (rs2) == SUBREG
3400               || (GET_CODE (rs2) == LO_SUM && GET_CODE (rs1) != LO_SUM)))
3401         {
3402           rs1 = XEXP (addr, 1);
3403           rs2 = XEXP (addr, 0);
3404         }
3405
3406       if ((flag_pic == 1
3407            && rs1 == pic_offset_table_rtx
3408            && !REG_P (rs2)
3409            && GET_CODE (rs2) != SUBREG
3410            && GET_CODE (rs2) != LO_SUM
3411            && GET_CODE (rs2) != MEM
3412            && !(GET_CODE (rs2) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (rs2))
3413            && (! symbolic_operand (rs2, VOIDmode) || mode == Pmode)
3414            && (GET_CODE (rs2) != CONST_INT || SMALL_INT (rs2)))
3415           || ((REG_P (rs1)
3416                || GET_CODE (rs1) == SUBREG)
3417               && RTX_OK_FOR_OFFSET_P (rs2, mode)))
3418         {
3419           imm1 = rs2;
3420           rs2 = NULL;
3421         }
3422       else if ((REG_P (rs1) || GET_CODE (rs1) == SUBREG)
3423                && (REG_P (rs2) || GET_CODE (rs2) == SUBREG))
3424         {
3425           /* We prohibit REG + REG for TFmode when there are no quad move insns
3426              and we consequently need to split.  We do this because REG+REG
3427              is not an offsettable address.  If we get the situation in reload
3428              where source and destination of a movtf pattern are both MEMs with
3429              REG+REG address, then only one of them gets converted to an
3430              offsettable address.  */
3431           if (mode == TFmode
3432               && ! (TARGET_FPU && TARGET_ARCH64 && TARGET_HARD_QUAD))
3433             return 0;
3434
3435           /* We prohibit REG + REG on ARCH32 if not optimizing for
3436              DFmode/DImode because then mem_min_alignment is likely to be zero
3437              after reload and the  forced split would lack a matching splitter
3438              pattern.  */
3439           if (TARGET_ARCH32 && !optimize
3440               && (mode == DFmode || mode == DImode))
3441             return 0;
3442         }
3443       else if (USE_AS_OFFSETABLE_LO10
3444                && GET_CODE (rs1) == LO_SUM
3445                && TARGET_ARCH64
3446                && ! TARGET_CM_MEDMID
3447                && RTX_OK_FOR_OLO10_P (rs2, mode))
3448         {
3449           rs2 = NULL;
3450           imm1 = XEXP (rs1, 1);
3451           rs1 = XEXP (rs1, 0);
3452           if (!CONSTANT_P (imm1)
3453               || (GET_CODE (rs1) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (rs1)))
3454             return 0;
3455         }
3456     }
3457   else if (GET_CODE (addr) == LO_SUM)
3458     {
3459       rs1 = XEXP (addr, 0);
3460       imm1 = XEXP (addr, 1);
3461
3462       if (!CONSTANT_P (imm1)