OSDN Git Service

29d2922ba9227904ad758ecaa8f4be21d34089f6
[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_LITTLE_ENDIAN)
819     fprintf (stderr, "LITTLE_ENDIAN ");
820   if (flags & MASK_SPARCLET)
821     fprintf (stderr, "SPARCLET ");
822   if (flags & MASK_SPARCLITE)
823     fprintf (stderr, "SPARCLITE ");
824   if (flags & MASK_V8)
825     fprintf (stderr, "V8 ");
826   if (flags & MASK_V9)
827     fprintf (stderr, "V9 ");
828 }
829
830 static void
831 dump_target_flags (const char *prefix, const int flags)
832 {
833   fprintf (stderr, "%s: (%08x) [ ", prefix, flags);
834   dump_target_flag_bits (flags);
835   fprintf(stderr, "]\n");
836 }
837
838 /* Validate and override various options, and do some machine dependent
839    initialization.  */
840
841 static void
842 sparc_option_override (void)
843 {
844   static struct code_model {
845     const char *const name;
846     const enum cmodel value;
847   } const cmodels[] = {
848     { "32", CM_32 },
849     { "medlow", CM_MEDLOW },
850     { "medmid", CM_MEDMID },
851     { "medany", CM_MEDANY },
852     { "embmedany", CM_EMBMEDANY },
853     { NULL, (enum cmodel) 0 }
854   };
855   const struct code_model *cmodel;
856   /* Map TARGET_CPU_DEFAULT to value for -m{cpu,tune}=.  */
857   static struct cpu_default {
858     const int cpu;
859     const enum processor_type processor;
860   } const cpu_default[] = {
861     /* There must be one entry here for each TARGET_CPU value.  */
862     { TARGET_CPU_sparc, PROCESSOR_CYPRESS },
863     { TARGET_CPU_v8, PROCESSOR_V8 },
864     { TARGET_CPU_supersparc, PROCESSOR_SUPERSPARC },
865     { TARGET_CPU_hypersparc, PROCESSOR_HYPERSPARC },
866     { TARGET_CPU_leon, PROCESSOR_LEON },
867     { TARGET_CPU_sparclite, PROCESSOR_F930 },
868     { TARGET_CPU_sparclite86x, PROCESSOR_SPARCLITE86X },
869     { TARGET_CPU_sparclet, PROCESSOR_TSC701 },
870     { TARGET_CPU_v9, PROCESSOR_V9 },
871     { TARGET_CPU_ultrasparc, PROCESSOR_ULTRASPARC },
872     { TARGET_CPU_ultrasparc3, PROCESSOR_ULTRASPARC3 },
873     { TARGET_CPU_niagara, PROCESSOR_NIAGARA },
874     { TARGET_CPU_niagara2, PROCESSOR_NIAGARA2 },
875     { TARGET_CPU_niagara3, PROCESSOR_NIAGARA3 },
876     { TARGET_CPU_niagara4, PROCESSOR_NIAGARA4 },
877     { -1, PROCESSOR_V7 }
878   };
879   const struct cpu_default *def;
880   /* Table of values for -m{cpu,tune}=.  This must match the order of
881      the PROCESSOR_* enumeration.  */
882   static struct cpu_table {
883     const char *const name;
884     const int disable;
885     const int enable;
886   } const cpu_table[] = {
887     { "v7",             MASK_ISA, 0 },
888     { "cypress",        MASK_ISA, 0 },
889     { "v8",             MASK_ISA, MASK_V8 },
890     /* TI TMS390Z55 supersparc */
891     { "supersparc",     MASK_ISA, MASK_V8 },
892     { "hypersparc",     MASK_ISA, MASK_V8|MASK_FPU },
893     /* LEON */
894     { "leon",           MASK_ISA, MASK_V8|MASK_FPU },
895     { "sparclite",      MASK_ISA, MASK_SPARCLITE },
896     /* The Fujitsu MB86930 is the original sparclite chip, with no FPU.  */
897     { "f930",           MASK_ISA|MASK_FPU, MASK_SPARCLITE },
898     /* The Fujitsu MB86934 is the recent sparclite chip, with an FPU.  */
899     { "f934",           MASK_ISA, MASK_SPARCLITE|MASK_FPU },
900     { "sparclite86x",   MASK_ISA|MASK_FPU, MASK_SPARCLITE },
901     { "sparclet",       MASK_ISA, MASK_SPARCLET },
902     /* TEMIC sparclet */
903     { "tsc701",         MASK_ISA, MASK_SPARCLET },
904     { "v9",             MASK_ISA, MASK_V9 },
905     /* UltraSPARC I, II, IIi */
906     { "ultrasparc",     MASK_ISA,
907     /* Although insns using %y are deprecated, it is a clear win.  */
908       MASK_V9|MASK_DEPRECATED_V8_INSNS },
909     /* UltraSPARC III */
910     /* ??? Check if %y issue still holds true.  */
911     { "ultrasparc3",    MASK_ISA,
912       MASK_V9|MASK_DEPRECATED_V8_INSNS|MASK_VIS2 },
913     /* UltraSPARC T1 */
914     { "niagara",        MASK_ISA,
915       MASK_V9|MASK_DEPRECATED_V8_INSNS },
916     /* UltraSPARC T2 */
917     { "niagara2",       MASK_ISA,
918       MASK_V9|MASK_POPC|MASK_VIS2 },
919     /* UltraSPARC T3 */
920     { "niagara3",       MASK_ISA,
921       MASK_V9|MASK_POPC|MASK_VIS2|MASK_VIS3|MASK_FMAF },
922     /* UltraSPARC T4 */
923     { "niagara4",       MASK_ISA,
924       MASK_V9|MASK_POPC|MASK_VIS2|MASK_VIS3|MASK_FMAF },
925   };
926   const struct cpu_table *cpu;
927   unsigned int i;
928   int fpu;
929
930   if (sparc_debug_string != NULL)
931     {
932       const char *q;
933       char *p;
934
935       p = ASTRDUP (sparc_debug_string);
936       while ((q = strtok (p, ",")) != NULL)
937         {
938           bool invert;
939           int mask;
940
941           p = NULL;
942           if (*q == '!')
943             {
944               invert = true;
945               q++;
946             }
947           else
948             invert = false;
949
950           if (! strcmp (q, "all"))
951             mask = MASK_DEBUG_ALL;
952           else if (! strcmp (q, "options"))
953             mask = MASK_DEBUG_OPTIONS;
954           else
955             error ("unknown -mdebug-%s switch", q);
956
957           if (invert)
958             sparc_debug &= ~mask;
959           else
960             sparc_debug |= mask;
961         }
962     }
963
964   if (TARGET_DEBUG_OPTIONS)
965     {
966       dump_target_flags("Initial target_flags", target_flags);
967       dump_target_flags("target_flags_explicit", target_flags_explicit);
968     }
969
970 #ifdef SUBTARGET_OVERRIDE_OPTIONS
971   SUBTARGET_OVERRIDE_OPTIONS;
972 #endif
973
974 #ifndef SPARC_BI_ARCH
975   /* Check for unsupported architecture size.  */
976   if (! TARGET_64BIT != DEFAULT_ARCH32_P)
977     error ("%s is not supported by this configuration",
978            DEFAULT_ARCH32_P ? "-m64" : "-m32");
979 #endif
980
981   /* We force all 64bit archs to use 128 bit long double */
982   if (TARGET_64BIT && ! TARGET_LONG_DOUBLE_128)
983     {
984       error ("-mlong-double-64 not allowed with -m64");
985       target_flags |= MASK_LONG_DOUBLE_128;
986     }
987
988   /* Code model selection.  */
989   sparc_cmodel = SPARC_DEFAULT_CMODEL;
990
991 #ifdef SPARC_BI_ARCH
992   if (TARGET_ARCH32)
993     sparc_cmodel = CM_32;
994 #endif
995
996   if (sparc_cmodel_string != NULL)
997     {
998       if (TARGET_ARCH64)
999         {
1000           for (cmodel = &cmodels[0]; cmodel->name; cmodel++)
1001             if (strcmp (sparc_cmodel_string, cmodel->name) == 0)
1002               break;
1003           if (cmodel->name == NULL)
1004             error ("bad value (%s) for -mcmodel= switch", sparc_cmodel_string);
1005           else
1006             sparc_cmodel = cmodel->value;
1007         }
1008       else
1009         error ("-mcmodel= is not supported on 32 bit systems");
1010     }
1011
1012   /* Check that -fcall-saved-REG wasn't specified for out registers.  */
1013   for (i = 8; i < 16; i++)
1014     if (!call_used_regs [i])
1015       {
1016         error ("-fcall-saved-REG is not supported for out registers");
1017         call_used_regs [i] = 1;
1018       }
1019
1020   fpu = target_flags & MASK_FPU; /* save current -mfpu status */
1021
1022   /* Set the default CPU.  */
1023   if (!global_options_set.x_sparc_cpu_and_features)
1024     {
1025       for (def = &cpu_default[0]; def->cpu != -1; ++def)
1026         if (def->cpu == TARGET_CPU_DEFAULT)
1027           break;
1028       gcc_assert (def->cpu != -1);
1029       sparc_cpu_and_features = def->processor;
1030     }
1031
1032   if (!global_options_set.x_sparc_cpu)
1033     sparc_cpu = sparc_cpu_and_features;
1034
1035   cpu = &cpu_table[(int) sparc_cpu_and_features];
1036
1037   if (TARGET_DEBUG_OPTIONS)
1038     {
1039       fprintf (stderr, "sparc_cpu_and_features: %s\n", cpu->name);
1040       fprintf (stderr, "sparc_cpu: %s\n",
1041                cpu_table[(int) sparc_cpu].name);
1042       dump_target_flags ("cpu->disable", cpu->disable);
1043       dump_target_flags ("cpu->enable", cpu->enable);
1044     }
1045
1046   target_flags &= ~cpu->disable;
1047   target_flags |= (cpu->enable
1048 #ifndef HAVE_AS_FMAF_HPC_VIS3
1049                    & ~(MASK_FMAF | MASK_VIS3)
1050 #endif
1051                    );
1052
1053   /* If -mfpu or -mno-fpu was explicitly used, don't override with
1054      the processor default.  */
1055   if (target_flags_explicit & MASK_FPU)
1056     target_flags = (target_flags & ~MASK_FPU) | fpu;
1057
1058   /* -mvis2 implies -mvis */
1059   if (TARGET_VIS2)
1060     target_flags |= MASK_VIS;
1061
1062   /* -mvis3 implies -mvis2 and -mvis */
1063   if (TARGET_VIS3)
1064     target_flags |= MASK_VIS2 | MASK_VIS;
1065
1066   /* Don't allow -mvis, -mvis2, -mvis3, or -mfmaf if FPU is disabled.  */
1067   if (! TARGET_FPU)
1068     target_flags &= ~(MASK_VIS | MASK_VIS2 | MASK_VIS3 | MASK_FMAF);
1069
1070   /* -mvis assumes UltraSPARC+, so we are sure v9 instructions
1071      are available.
1072      -m64 also implies v9.  */
1073   if (TARGET_VIS || TARGET_ARCH64)
1074     {
1075       target_flags |= MASK_V9;
1076       target_flags &= ~(MASK_V8 | MASK_SPARCLET | MASK_SPARCLITE);
1077     }
1078
1079   /* -mvis also implies -mv8plus on 32-bit */
1080   if (TARGET_VIS && ! TARGET_ARCH64)
1081     target_flags |= MASK_V8PLUS;
1082
1083   /* Use the deprecated v8 insns for sparc64 in 32 bit mode.  */
1084   if (TARGET_V9 && TARGET_ARCH32)
1085     target_flags |= MASK_DEPRECATED_V8_INSNS;
1086
1087   /* V8PLUS requires V9, makes no sense in 64 bit mode.  */
1088   if (! TARGET_V9 || TARGET_ARCH64)
1089     target_flags &= ~MASK_V8PLUS;
1090
1091   /* Don't use stack biasing in 32 bit mode.  */
1092   if (TARGET_ARCH32)
1093     target_flags &= ~MASK_STACK_BIAS;
1094
1095   /* Supply a default value for align_functions.  */
1096   if (align_functions == 0
1097       && (sparc_cpu == PROCESSOR_ULTRASPARC
1098           || sparc_cpu == PROCESSOR_ULTRASPARC3
1099           || sparc_cpu == PROCESSOR_NIAGARA
1100           || sparc_cpu == PROCESSOR_NIAGARA2
1101           || sparc_cpu == PROCESSOR_NIAGARA3
1102           || sparc_cpu == PROCESSOR_NIAGARA4))
1103     align_functions = 32;
1104
1105   /* Validate PCC_STRUCT_RETURN.  */
1106   if (flag_pcc_struct_return == DEFAULT_PCC_STRUCT_RETURN)
1107     flag_pcc_struct_return = (TARGET_ARCH64 ? 0 : 1);
1108
1109   /* Only use .uaxword when compiling for a 64-bit target.  */
1110   if (!TARGET_ARCH64)
1111     targetm.asm_out.unaligned_op.di = NULL;
1112
1113   /* Do various machine dependent initializations.  */
1114   sparc_init_modes ();
1115
1116   /* Set up function hooks.  */
1117   init_machine_status = sparc_init_machine_status;
1118
1119   switch (sparc_cpu)
1120     {
1121     case PROCESSOR_V7:
1122     case PROCESSOR_CYPRESS:
1123       sparc_costs = &cypress_costs;
1124       break;
1125     case PROCESSOR_V8:
1126     case PROCESSOR_SPARCLITE:
1127     case PROCESSOR_SUPERSPARC:
1128       sparc_costs = &supersparc_costs;
1129       break;
1130     case PROCESSOR_F930:
1131     case PROCESSOR_F934:
1132     case PROCESSOR_HYPERSPARC:
1133     case PROCESSOR_SPARCLITE86X:
1134       sparc_costs = &hypersparc_costs;
1135       break;
1136     case PROCESSOR_LEON:
1137       sparc_costs = &leon_costs;
1138       break;
1139     case PROCESSOR_SPARCLET:
1140     case PROCESSOR_TSC701:
1141       sparc_costs = &sparclet_costs;
1142       break;
1143     case PROCESSOR_V9:
1144     case PROCESSOR_ULTRASPARC:
1145       sparc_costs = &ultrasparc_costs;
1146       break;
1147     case PROCESSOR_ULTRASPARC3:
1148       sparc_costs = &ultrasparc3_costs;
1149       break;
1150     case PROCESSOR_NIAGARA:
1151       sparc_costs = &niagara_costs;
1152       break;
1153     case PROCESSOR_NIAGARA2:
1154       sparc_costs = &niagara2_costs;
1155       break;
1156     case PROCESSOR_NIAGARA3:
1157     case PROCESSOR_NIAGARA4:
1158       sparc_costs = &niagara3_costs;
1159       break;
1160     case PROCESSOR_NATIVE:
1161       gcc_unreachable ();
1162     };
1163
1164 #ifdef TARGET_DEFAULT_LONG_DOUBLE_128
1165   if (!(target_flags_explicit & MASK_LONG_DOUBLE_128))
1166     target_flags |= MASK_LONG_DOUBLE_128;
1167 #endif
1168
1169   if (TARGET_DEBUG_OPTIONS)
1170     dump_target_flags ("Final target_flags", target_flags);
1171
1172   maybe_set_param_value (PARAM_SIMULTANEOUS_PREFETCHES,
1173                          ((sparc_cpu == PROCESSOR_ULTRASPARC
1174                            || sparc_cpu == PROCESSOR_NIAGARA
1175                            || sparc_cpu == PROCESSOR_NIAGARA2
1176                            || sparc_cpu == PROCESSOR_NIAGARA3
1177                            || sparc_cpu == PROCESSOR_NIAGARA4)
1178                           ? 2
1179                           : (sparc_cpu == PROCESSOR_ULTRASPARC3
1180                              ? 8 : 3)),
1181                          global_options.x_param_values,
1182                          global_options_set.x_param_values);
1183   maybe_set_param_value (PARAM_L1_CACHE_LINE_SIZE,
1184                          ((sparc_cpu == PROCESSOR_ULTRASPARC
1185                            || sparc_cpu == PROCESSOR_ULTRASPARC3
1186                            || sparc_cpu == PROCESSOR_NIAGARA
1187                            || sparc_cpu == PROCESSOR_NIAGARA2
1188                            || sparc_cpu == PROCESSOR_NIAGARA3
1189                            || sparc_cpu == PROCESSOR_NIAGARA4)
1190                           ? 64 : 32),
1191                          global_options.x_param_values,
1192                          global_options_set.x_param_values);
1193
1194   /* Disable save slot sharing for call-clobbered registers by default.
1195      The IRA sharing algorithm works on single registers only and this
1196      pessimizes for double floating-point registers.  */
1197   if (!global_options_set.x_flag_ira_share_save_slots)
1198     flag_ira_share_save_slots = 0;
1199 }
1200 \f
1201 /* Miscellaneous utilities.  */
1202
1203 /* Nonzero if CODE, a comparison, is suitable for use in v9 conditional move
1204    or branch on register contents instructions.  */
1205
1206 int
1207 v9_regcmp_p (enum rtx_code code)
1208 {
1209   return (code == EQ || code == NE || code == GE || code == LT
1210           || code == LE || code == GT);
1211 }
1212
1213 /* Nonzero if OP is a floating point constant which can
1214    be loaded into an integer register using a single
1215    sethi instruction.  */
1216
1217 int
1218 fp_sethi_p (rtx op)
1219 {
1220   if (GET_CODE (op) == CONST_DOUBLE)
1221     {
1222       REAL_VALUE_TYPE r;
1223       long i;
1224
1225       REAL_VALUE_FROM_CONST_DOUBLE (r, op);
1226       REAL_VALUE_TO_TARGET_SINGLE (r, i);
1227       return !SPARC_SIMM13_P (i) && SPARC_SETHI_P (i);
1228     }
1229
1230   return 0;
1231 }
1232
1233 /* Nonzero if OP is a floating point constant which can
1234    be loaded into an integer register using a single
1235    mov instruction.  */
1236
1237 int
1238 fp_mov_p (rtx op)
1239 {
1240   if (GET_CODE (op) == CONST_DOUBLE)
1241     {
1242       REAL_VALUE_TYPE r;
1243       long i;
1244
1245       REAL_VALUE_FROM_CONST_DOUBLE (r, op);
1246       REAL_VALUE_TO_TARGET_SINGLE (r, i);
1247       return SPARC_SIMM13_P (i);
1248     }
1249
1250   return 0;
1251 }
1252
1253 /* Nonzero if OP is a floating point constant which can
1254    be loaded into an integer register using a high/losum
1255    instruction sequence.  */
1256
1257 int
1258 fp_high_losum_p (rtx op)
1259 {
1260   /* The constraints calling this should only be in
1261      SFmode move insns, so any constant which cannot
1262      be moved using a single insn will do.  */
1263   if (GET_CODE (op) == CONST_DOUBLE)
1264     {
1265       REAL_VALUE_TYPE r;
1266       long i;
1267
1268       REAL_VALUE_FROM_CONST_DOUBLE (r, op);
1269       REAL_VALUE_TO_TARGET_SINGLE (r, i);
1270       return !SPARC_SIMM13_P (i) && !SPARC_SETHI_P (i);
1271     }
1272
1273   return 0;
1274 }
1275
1276 /* Return true if the address of LABEL can be loaded by means of the
1277    mov{si,di}_pic_label_ref patterns in PIC mode.  */
1278
1279 static bool
1280 can_use_mov_pic_label_ref (rtx label)
1281 {
1282   /* VxWorks does not impose a fixed gap between segments; the run-time
1283      gap can be different from the object-file gap.  We therefore can't
1284      assume X - _GLOBAL_OFFSET_TABLE_ is a link-time constant unless we
1285      are absolutely sure that X is in the same segment as the GOT.
1286      Unfortunately, the flexibility of linker scripts means that we
1287      can't be sure of that in general, so assume that GOT-relative
1288      accesses are never valid on VxWorks.  */
1289   if (TARGET_VXWORKS_RTP)
1290     return false;
1291
1292   /* Similarly, if the label is non-local, it might end up being placed
1293      in a different section than the current one; now mov_pic_label_ref
1294      requires the label and the code to be in the same section.  */
1295   if (LABEL_REF_NONLOCAL_P (label))
1296     return false;
1297
1298   /* Finally, if we are reordering basic blocks and partition into hot
1299      and cold sections, this might happen for any label.  */
1300   if (flag_reorder_blocks_and_partition)
1301     return false;
1302
1303   return true;
1304 }
1305
1306 /* Expand a move instruction.  Return true if all work is done.  */
1307
1308 bool
1309 sparc_expand_move (enum machine_mode mode, rtx *operands)
1310 {
1311   /* Handle sets of MEM first.  */
1312   if (GET_CODE (operands[0]) == MEM)
1313     {
1314       /* 0 is a register (or a pair of registers) on SPARC.  */
1315       if (register_or_zero_operand (operands[1], mode))
1316         return false;
1317
1318       if (!reload_in_progress)
1319         {
1320           operands[0] = validize_mem (operands[0]);
1321           operands[1] = force_reg (mode, operands[1]);
1322         }
1323     }
1324
1325   /* Fixup TLS cases.  */
1326   if (TARGET_HAVE_TLS
1327       && CONSTANT_P (operands[1])
1328       && sparc_tls_referenced_p (operands [1]))
1329     {
1330       operands[1] = sparc_legitimize_tls_address (operands[1]);
1331       return false;
1332     }
1333
1334   /* Fixup PIC cases.  */
1335   if (flag_pic && CONSTANT_P (operands[1]))
1336     {
1337       if (pic_address_needs_scratch (operands[1]))
1338         operands[1] = sparc_legitimize_pic_address (operands[1], NULL_RTX);
1339
1340       /* We cannot use the mov{si,di}_pic_label_ref patterns in all cases.  */
1341       if (GET_CODE (operands[1]) == LABEL_REF
1342           && can_use_mov_pic_label_ref (operands[1]))
1343         {
1344           if (mode == SImode)
1345             {
1346               emit_insn (gen_movsi_pic_label_ref (operands[0], operands[1]));
1347               return true;
1348             }
1349
1350           if (mode == DImode)
1351             {
1352               gcc_assert (TARGET_ARCH64);
1353               emit_insn (gen_movdi_pic_label_ref (operands[0], operands[1]));
1354               return true;
1355             }
1356         }
1357
1358       if (symbolic_operand (operands[1], mode))
1359         {
1360           operands[1]
1361             = sparc_legitimize_pic_address (operands[1],
1362                                             reload_in_progress
1363                                             ? operands[0] : NULL_RTX);
1364           return false;
1365         }
1366     }
1367
1368   /* If we are trying to toss an integer constant into FP registers,
1369      or loading a FP or vector constant, force it into memory.  */
1370   if (CONSTANT_P (operands[1])
1371       && REG_P (operands[0])
1372       && (SPARC_FP_REG_P (REGNO (operands[0]))
1373           || SCALAR_FLOAT_MODE_P (mode)
1374           || VECTOR_MODE_P (mode)))
1375     {
1376       /* emit_group_store will send such bogosity to us when it is
1377          not storing directly into memory.  So fix this up to avoid
1378          crashes in output_constant_pool.  */
1379       if (operands [1] == const0_rtx)
1380         operands[1] = CONST0_RTX (mode);
1381
1382       /* We can clear or set to all-ones FP registers if TARGET_VIS, and
1383          always other regs.  */
1384       if ((TARGET_VIS || REGNO (operands[0]) < SPARC_FIRST_FP_REG)
1385           && (const_zero_operand (operands[1], mode)
1386               || const_all_ones_operand (operands[1], mode)))
1387         return false;
1388
1389       if (REGNO (operands[0]) < SPARC_FIRST_FP_REG
1390           /* We are able to build any SF constant in integer registers
1391              with at most 2 instructions.  */
1392           && (mode == SFmode
1393               /* And any DF constant in integer registers.  */
1394               || (mode == DFmode
1395                   && ! can_create_pseudo_p ())))
1396         return false;
1397
1398       operands[1] = force_const_mem (mode, operands[1]);
1399       if (!reload_in_progress)
1400         operands[1] = validize_mem (operands[1]);
1401       return false;
1402     }
1403
1404   /* Accept non-constants and valid constants unmodified.  */
1405   if (!CONSTANT_P (operands[1])
1406       || GET_CODE (operands[1]) == HIGH
1407       || input_operand (operands[1], mode))
1408     return false;
1409
1410   switch (mode)
1411     {
1412     case QImode:
1413       /* All QImode constants require only one insn, so proceed.  */
1414       break;
1415
1416     case HImode:
1417     case SImode:
1418       sparc_emit_set_const32 (operands[0], operands[1]);
1419       return true;
1420
1421     case DImode:
1422       /* input_operand should have filtered out 32-bit mode.  */
1423       sparc_emit_set_const64 (operands[0], operands[1]);
1424       return true;
1425
1426     default:
1427       gcc_unreachable ();
1428     }
1429
1430   return false;
1431 }
1432
1433 /* Load OP1, a 32-bit constant, into OP0, a register.
1434    We know it can't be done in one insn when we get
1435    here, the move expander guarantees this.  */
1436
1437 static void
1438 sparc_emit_set_const32 (rtx op0, rtx op1)
1439 {
1440   enum machine_mode mode = GET_MODE (op0);
1441   rtx temp = op0;
1442
1443   if (can_create_pseudo_p ())
1444     temp = gen_reg_rtx (mode);
1445
1446   if (GET_CODE (op1) == CONST_INT)
1447     {
1448       gcc_assert (!small_int_operand (op1, mode)
1449                   && !const_high_operand (op1, mode));
1450
1451       /* Emit them as real moves instead of a HIGH/LO_SUM,
1452          this way CSE can see everything and reuse intermediate
1453          values if it wants.  */
1454       emit_insn (gen_rtx_SET (VOIDmode, temp,
1455                               GEN_INT (INTVAL (op1)
1456                                 & ~(HOST_WIDE_INT)0x3ff)));
1457
1458       emit_insn (gen_rtx_SET (VOIDmode,
1459                               op0,
1460                               gen_rtx_IOR (mode, temp,
1461                                            GEN_INT (INTVAL (op1) & 0x3ff))));
1462     }
1463   else
1464     {
1465       /* A symbol, emit in the traditional way.  */
1466       emit_insn (gen_rtx_SET (VOIDmode, temp,
1467                               gen_rtx_HIGH (mode, op1)));
1468       emit_insn (gen_rtx_SET (VOIDmode,
1469                               op0, gen_rtx_LO_SUM (mode, temp, op1)));
1470     }
1471 }
1472
1473 /* Load OP1, a symbolic 64-bit constant, into OP0, a DImode register.
1474    If TEMP is nonzero, we are forbidden to use any other scratch
1475    registers.  Otherwise, we are allowed to generate them as needed.
1476
1477    Note that TEMP may have TImode if the code model is TARGET_CM_MEDANY
1478    or TARGET_CM_EMBMEDANY (see the reload_indi and reload_outdi patterns).  */
1479
1480 void
1481 sparc_emit_set_symbolic_const64 (rtx op0, rtx op1, rtx temp)
1482 {
1483   rtx temp1, temp2, temp3, temp4, temp5;
1484   rtx ti_temp = 0;
1485
1486   if (temp && GET_MODE (temp) == TImode)
1487     {
1488       ti_temp = temp;
1489       temp = gen_rtx_REG (DImode, REGNO (temp));
1490     }
1491
1492   /* SPARC-V9 code-model support.  */
1493   switch (sparc_cmodel)
1494     {
1495     case CM_MEDLOW:
1496       /* The range spanned by all instructions in the object is less
1497          than 2^31 bytes (2GB) and the distance from any instruction
1498          to the location of the label _GLOBAL_OFFSET_TABLE_ is less
1499          than 2^31 bytes (2GB).
1500
1501          The executable must be in the low 4TB of the virtual address
1502          space.
1503
1504          sethi  %hi(symbol), %temp1
1505          or     %temp1, %lo(symbol), %reg  */
1506       if (temp)
1507         temp1 = temp;  /* op0 is allowed.  */
1508       else
1509         temp1 = gen_reg_rtx (DImode);
1510
1511       emit_insn (gen_rtx_SET (VOIDmode, temp1, gen_rtx_HIGH (DImode, op1)));
1512       emit_insn (gen_rtx_SET (VOIDmode, op0, gen_rtx_LO_SUM (DImode, temp1, op1)));
1513       break;
1514
1515     case CM_MEDMID:
1516       /* The range spanned by all instructions in the object is less
1517          than 2^31 bytes (2GB) and the distance from any instruction
1518          to the location of the label _GLOBAL_OFFSET_TABLE_ is less
1519          than 2^31 bytes (2GB).
1520
1521          The executable must be in the low 16TB of the virtual address
1522          space.
1523
1524          sethi  %h44(symbol), %temp1
1525          or     %temp1, %m44(symbol), %temp2
1526          sllx   %temp2, 12, %temp3
1527          or     %temp3, %l44(symbol), %reg  */
1528       if (temp)
1529         {
1530           temp1 = op0;
1531           temp2 = op0;
1532           temp3 = temp;  /* op0 is allowed.  */
1533         }
1534       else
1535         {
1536           temp1 = gen_reg_rtx (DImode);
1537           temp2 = gen_reg_rtx (DImode);
1538           temp3 = gen_reg_rtx (DImode);
1539         }
1540
1541       emit_insn (gen_seth44 (temp1, op1));
1542       emit_insn (gen_setm44 (temp2, temp1, op1));
1543       emit_insn (gen_rtx_SET (VOIDmode, temp3,
1544                               gen_rtx_ASHIFT (DImode, temp2, GEN_INT (12))));
1545       emit_insn (gen_setl44 (op0, temp3, op1));
1546       break;
1547
1548     case CM_MEDANY:
1549       /* The range spanned by all instructions in the object is less
1550          than 2^31 bytes (2GB) and the distance from any instruction
1551          to the location of the label _GLOBAL_OFFSET_TABLE_ is less
1552          than 2^31 bytes (2GB).
1553
1554          The executable can be placed anywhere in the virtual address
1555          space.
1556
1557          sethi  %hh(symbol), %temp1
1558          sethi  %lm(symbol), %temp2
1559          or     %temp1, %hm(symbol), %temp3
1560          sllx   %temp3, 32, %temp4
1561          or     %temp4, %temp2, %temp5
1562          or     %temp5, %lo(symbol), %reg  */
1563       if (temp)
1564         {
1565           /* It is possible that one of the registers we got for operands[2]
1566              might coincide with that of operands[0] (which is why we made
1567              it TImode).  Pick the other one to use as our scratch.  */
1568           if (rtx_equal_p (temp, op0))
1569             {
1570               gcc_assert (ti_temp);
1571               temp = gen_rtx_REG (DImode, REGNO (temp) + 1);
1572             }
1573           temp1 = op0;
1574           temp2 = temp;  /* op0 is _not_ allowed, see above.  */
1575           temp3 = op0;
1576           temp4 = op0;
1577           temp5 = op0;
1578         }
1579       else
1580         {
1581           temp1 = gen_reg_rtx (DImode);
1582           temp2 = gen_reg_rtx (DImode);
1583           temp3 = gen_reg_rtx (DImode);
1584           temp4 = gen_reg_rtx (DImode);
1585           temp5 = gen_reg_rtx (DImode);
1586         }
1587
1588       emit_insn (gen_sethh (temp1, op1));
1589       emit_insn (gen_setlm (temp2, op1));
1590       emit_insn (gen_sethm (temp3, temp1, op1));
1591       emit_insn (gen_rtx_SET (VOIDmode, temp4,
1592                               gen_rtx_ASHIFT (DImode, temp3, GEN_INT (32))));
1593       emit_insn (gen_rtx_SET (VOIDmode, temp5,
1594                               gen_rtx_PLUS (DImode, temp4, temp2)));
1595       emit_insn (gen_setlo (op0, temp5, op1));
1596       break;
1597
1598     case CM_EMBMEDANY:
1599       /* Old old old backwards compatibility kruft here.
1600          Essentially it is MEDLOW with a fixed 64-bit
1601          virtual base added to all data segment addresses.
1602          Text-segment stuff is computed like MEDANY, we can't
1603          reuse the code above because the relocation knobs
1604          look different.
1605
1606          Data segment:  sethi   %hi(symbol), %temp1
1607                         add     %temp1, EMBMEDANY_BASE_REG, %temp2
1608                         or      %temp2, %lo(symbol), %reg  */
1609       if (data_segment_operand (op1, GET_MODE (op1)))
1610         {
1611           if (temp)
1612             {
1613               temp1 = temp;  /* op0 is allowed.  */
1614               temp2 = op0;
1615             }
1616           else
1617             {
1618               temp1 = gen_reg_rtx (DImode);
1619               temp2 = gen_reg_rtx (DImode);
1620             }
1621
1622           emit_insn (gen_embmedany_sethi (temp1, op1));
1623           emit_insn (gen_embmedany_brsum (temp2, temp1));
1624           emit_insn (gen_embmedany_losum (op0, temp2, op1));
1625         }
1626
1627       /* Text segment:  sethi   %uhi(symbol), %temp1
1628                         sethi   %hi(symbol), %temp2
1629                         or      %temp1, %ulo(symbol), %temp3
1630                         sllx    %temp3, 32, %temp4
1631                         or      %temp4, %temp2, %temp5
1632                         or      %temp5, %lo(symbol), %reg  */
1633       else
1634         {
1635           if (temp)
1636             {
1637               /* It is possible that one of the registers we got for operands[2]
1638                  might coincide with that of operands[0] (which is why we made
1639                  it TImode).  Pick the other one to use as our scratch.  */
1640               if (rtx_equal_p (temp, op0))
1641                 {
1642                   gcc_assert (ti_temp);
1643                   temp = gen_rtx_REG (DImode, REGNO (temp) + 1);
1644                 }
1645               temp1 = op0;
1646               temp2 = temp;  /* op0 is _not_ allowed, see above.  */
1647               temp3 = op0;
1648               temp4 = op0;
1649               temp5 = op0;
1650             }
1651           else
1652             {
1653               temp1 = gen_reg_rtx (DImode);
1654               temp2 = gen_reg_rtx (DImode);
1655               temp3 = gen_reg_rtx (DImode);
1656               temp4 = gen_reg_rtx (DImode);
1657               temp5 = gen_reg_rtx (DImode);
1658             }
1659
1660           emit_insn (gen_embmedany_textuhi (temp1, op1));
1661           emit_insn (gen_embmedany_texthi  (temp2, op1));
1662           emit_insn (gen_embmedany_textulo (temp3, temp1, op1));
1663           emit_insn (gen_rtx_SET (VOIDmode, temp4,
1664                                   gen_rtx_ASHIFT (DImode, temp3, GEN_INT (32))));
1665           emit_insn (gen_rtx_SET (VOIDmode, temp5,
1666                                   gen_rtx_PLUS (DImode, temp4, temp2)));
1667           emit_insn (gen_embmedany_textlo  (op0, temp5, op1));
1668         }
1669       break;
1670
1671     default:
1672       gcc_unreachable ();
1673     }
1674 }
1675
1676 #if HOST_BITS_PER_WIDE_INT == 32
1677 static void
1678 sparc_emit_set_const64 (rtx op0 ATTRIBUTE_UNUSED, rtx op1 ATTRIBUTE_UNUSED)
1679 {
1680   gcc_unreachable ();
1681 }
1682 #else
1683 /* These avoid problems when cross compiling.  If we do not
1684    go through all this hair then the optimizer will see
1685    invalid REG_EQUAL notes or in some cases none at all.  */
1686 static rtx gen_safe_HIGH64 (rtx, HOST_WIDE_INT);
1687 static rtx gen_safe_SET64 (rtx, HOST_WIDE_INT);
1688 static rtx gen_safe_OR64 (rtx, HOST_WIDE_INT);
1689 static rtx gen_safe_XOR64 (rtx, HOST_WIDE_INT);
1690
1691 /* The optimizer is not to assume anything about exactly
1692    which bits are set for a HIGH, they are unspecified.
1693    Unfortunately this leads to many missed optimizations
1694    during CSE.  We mask out the non-HIGH bits, and matches
1695    a plain movdi, to alleviate this problem.  */
1696 static rtx
1697 gen_safe_HIGH64 (rtx dest, HOST_WIDE_INT val)
1698 {
1699   return gen_rtx_SET (VOIDmode, dest, GEN_INT (val & ~(HOST_WIDE_INT)0x3ff));
1700 }
1701
1702 static rtx
1703 gen_safe_SET64 (rtx dest, HOST_WIDE_INT val)
1704 {
1705   return gen_rtx_SET (VOIDmode, dest, GEN_INT (val));
1706 }
1707
1708 static rtx
1709 gen_safe_OR64 (rtx src, HOST_WIDE_INT val)
1710 {
1711   return gen_rtx_IOR (DImode, src, GEN_INT (val));
1712 }
1713
1714 static rtx
1715 gen_safe_XOR64 (rtx src, HOST_WIDE_INT val)
1716 {
1717   return gen_rtx_XOR (DImode, src, GEN_INT (val));
1718 }
1719
1720 /* Worker routines for 64-bit constant formation on arch64.
1721    One of the key things to be doing in these emissions is
1722    to create as many temp REGs as possible.  This makes it
1723    possible for half-built constants to be used later when
1724    such values are similar to something required later on.
1725    Without doing this, the optimizer cannot see such
1726    opportunities.  */
1727
1728 static void sparc_emit_set_const64_quick1 (rtx, rtx,
1729                                            unsigned HOST_WIDE_INT, int);
1730
1731 static void
1732 sparc_emit_set_const64_quick1 (rtx op0, rtx temp,
1733                                unsigned HOST_WIDE_INT low_bits, int is_neg)
1734 {
1735   unsigned HOST_WIDE_INT high_bits;
1736
1737   if (is_neg)
1738     high_bits = (~low_bits) & 0xffffffff;
1739   else
1740     high_bits = low_bits;
1741
1742   emit_insn (gen_safe_HIGH64 (temp, high_bits));
1743   if (!is_neg)
1744     {
1745       emit_insn (gen_rtx_SET (VOIDmode, op0,
1746                               gen_safe_OR64 (temp, (high_bits & 0x3ff))));
1747     }
1748   else
1749     {
1750       /* If we are XOR'ing with -1, then we should emit a one's complement
1751          instead.  This way the combiner will notice logical operations
1752          such as ANDN later on and substitute.  */
1753       if ((low_bits & 0x3ff) == 0x3ff)
1754         {
1755           emit_insn (gen_rtx_SET (VOIDmode, op0,
1756                                   gen_rtx_NOT (DImode, temp)));
1757         }
1758       else
1759         {
1760           emit_insn (gen_rtx_SET (VOIDmode, op0,
1761                                   gen_safe_XOR64 (temp,
1762                                                   (-(HOST_WIDE_INT)0x400
1763                                                    | (low_bits & 0x3ff)))));
1764         }
1765     }
1766 }
1767
1768 static void sparc_emit_set_const64_quick2 (rtx, rtx, unsigned HOST_WIDE_INT,
1769                                            unsigned HOST_WIDE_INT, int);
1770
1771 static void
1772 sparc_emit_set_const64_quick2 (rtx op0, rtx temp,
1773                                unsigned HOST_WIDE_INT high_bits,
1774                                unsigned HOST_WIDE_INT low_immediate,
1775                                int shift_count)
1776 {
1777   rtx temp2 = op0;
1778
1779   if ((high_bits & 0xfffffc00) != 0)
1780     {
1781       emit_insn (gen_safe_HIGH64 (temp, high_bits));
1782       if ((high_bits & ~0xfffffc00) != 0)
1783         emit_insn (gen_rtx_SET (VOIDmode, op0,
1784                                 gen_safe_OR64 (temp, (high_bits & 0x3ff))));
1785       else
1786         temp2 = temp;
1787     }
1788   else
1789     {
1790       emit_insn (gen_safe_SET64 (temp, high_bits));
1791       temp2 = temp;
1792     }
1793
1794   /* Now shift it up into place.  */
1795   emit_insn (gen_rtx_SET (VOIDmode, op0,
1796                           gen_rtx_ASHIFT (DImode, temp2,
1797                                           GEN_INT (shift_count))));
1798
1799   /* If there is a low immediate part piece, finish up by
1800      putting that in as well.  */
1801   if (low_immediate != 0)
1802     emit_insn (gen_rtx_SET (VOIDmode, op0,
1803                             gen_safe_OR64 (op0, low_immediate)));
1804 }
1805
1806 static void sparc_emit_set_const64_longway (rtx, rtx, unsigned HOST_WIDE_INT,
1807                                             unsigned HOST_WIDE_INT);
1808
1809 /* Full 64-bit constant decomposition.  Even though this is the
1810    'worst' case, we still optimize a few things away.  */
1811 static void
1812 sparc_emit_set_const64_longway (rtx op0, rtx temp,
1813                                 unsigned HOST_WIDE_INT high_bits,
1814                                 unsigned HOST_WIDE_INT low_bits)
1815 {
1816   rtx sub_temp = op0;
1817
1818   if (can_create_pseudo_p ())
1819     sub_temp = gen_reg_rtx (DImode);
1820
1821   if ((high_bits & 0xfffffc00) != 0)
1822     {
1823       emit_insn (gen_safe_HIGH64 (temp, high_bits));
1824       if ((high_bits & ~0xfffffc00) != 0)
1825         emit_insn (gen_rtx_SET (VOIDmode,
1826                                 sub_temp,
1827                                 gen_safe_OR64 (temp, (high_bits & 0x3ff))));
1828       else
1829         sub_temp = temp;
1830     }
1831   else
1832     {
1833       emit_insn (gen_safe_SET64 (temp, high_bits));
1834       sub_temp = temp;
1835     }
1836
1837   if (can_create_pseudo_p ())
1838     {
1839       rtx temp2 = gen_reg_rtx (DImode);
1840       rtx temp3 = gen_reg_rtx (DImode);
1841       rtx temp4 = gen_reg_rtx (DImode);
1842
1843       emit_insn (gen_rtx_SET (VOIDmode, temp4,
1844                               gen_rtx_ASHIFT (DImode, sub_temp,
1845                                               GEN_INT (32))));
1846
1847       emit_insn (gen_safe_HIGH64 (temp2, low_bits));
1848       if ((low_bits & ~0xfffffc00) != 0)
1849         {
1850           emit_insn (gen_rtx_SET (VOIDmode, temp3,
1851                                   gen_safe_OR64 (temp2, (low_bits & 0x3ff))));
1852           emit_insn (gen_rtx_SET (VOIDmode, op0,
1853                                   gen_rtx_PLUS (DImode, temp4, temp3)));
1854         }
1855       else
1856         {
1857           emit_insn (gen_rtx_SET (VOIDmode, op0,
1858                                   gen_rtx_PLUS (DImode, temp4, temp2)));
1859         }
1860     }
1861   else
1862     {
1863       rtx low1 = GEN_INT ((low_bits >> (32 - 12))          & 0xfff);
1864       rtx low2 = GEN_INT ((low_bits >> (32 - 12 - 12))     & 0xfff);
1865       rtx low3 = GEN_INT ((low_bits >> (32 - 12 - 12 - 8)) & 0x0ff);
1866       int to_shift = 12;
1867
1868       /* We are in the middle of reload, so this is really
1869          painful.  However we do still make an attempt to
1870          avoid emitting truly stupid code.  */
1871       if (low1 != const0_rtx)
1872         {
1873           emit_insn (gen_rtx_SET (VOIDmode, op0,
1874                                   gen_rtx_ASHIFT (DImode, sub_temp,
1875                                                   GEN_INT (to_shift))));
1876           emit_insn (gen_rtx_SET (VOIDmode, op0,
1877                                   gen_rtx_IOR (DImode, op0, low1)));
1878           sub_temp = op0;
1879           to_shift = 12;
1880         }
1881       else
1882         {
1883           to_shift += 12;
1884         }
1885       if (low2 != const0_rtx)
1886         {
1887           emit_insn (gen_rtx_SET (VOIDmode, op0,
1888                                   gen_rtx_ASHIFT (DImode, sub_temp,
1889                                                   GEN_INT (to_shift))));
1890           emit_insn (gen_rtx_SET (VOIDmode, op0,
1891                                   gen_rtx_IOR (DImode, op0, low2)));
1892           sub_temp = op0;
1893           to_shift = 8;
1894         }
1895       else
1896         {
1897           to_shift += 8;
1898         }
1899       emit_insn (gen_rtx_SET (VOIDmode, op0,
1900                               gen_rtx_ASHIFT (DImode, sub_temp,
1901                                               GEN_INT (to_shift))));
1902       if (low3 != const0_rtx)
1903         emit_insn (gen_rtx_SET (VOIDmode, op0,
1904                                 gen_rtx_IOR (DImode, op0, low3)));
1905       /* phew...  */
1906     }
1907 }
1908
1909 /* Analyze a 64-bit constant for certain properties.  */
1910 static void analyze_64bit_constant (unsigned HOST_WIDE_INT,
1911                                     unsigned HOST_WIDE_INT,
1912                                     int *, int *, int *);
1913
1914 static void
1915 analyze_64bit_constant (unsigned HOST_WIDE_INT high_bits,
1916                         unsigned HOST_WIDE_INT low_bits,
1917                         int *hbsp, int *lbsp, int *abbasp)
1918 {
1919   int lowest_bit_set, highest_bit_set, all_bits_between_are_set;
1920   int i;
1921
1922   lowest_bit_set = highest_bit_set = -1;
1923   i = 0;
1924   do
1925     {
1926       if ((lowest_bit_set == -1)
1927           && ((low_bits >> i) & 1))
1928         lowest_bit_set = i;
1929       if ((highest_bit_set == -1)
1930           && ((high_bits >> (32 - i - 1)) & 1))
1931         highest_bit_set = (64 - i - 1);
1932     }
1933   while (++i < 32
1934          && ((highest_bit_set == -1)
1935              || (lowest_bit_set == -1)));
1936   if (i == 32)
1937     {
1938       i = 0;
1939       do
1940         {
1941           if ((lowest_bit_set == -1)
1942               && ((high_bits >> i) & 1))
1943             lowest_bit_set = i + 32;
1944           if ((highest_bit_set == -1)
1945               && ((low_bits >> (32 - i - 1)) & 1))
1946             highest_bit_set = 32 - i - 1;
1947         }
1948       while (++i < 32
1949              && ((highest_bit_set == -1)
1950                  || (lowest_bit_set == -1)));
1951     }
1952   /* If there are no bits set this should have gone out
1953      as one instruction!  */
1954   gcc_assert (lowest_bit_set != -1 && highest_bit_set != -1);
1955   all_bits_between_are_set = 1;
1956   for (i = lowest_bit_set; i <= highest_bit_set; i++)
1957     {
1958       if (i < 32)
1959         {
1960           if ((low_bits & (1 << i)) != 0)
1961             continue;
1962         }
1963       else
1964         {
1965           if ((high_bits & (1 << (i - 32))) != 0)
1966             continue;
1967         }
1968       all_bits_between_are_set = 0;
1969       break;
1970     }
1971   *hbsp = highest_bit_set;
1972   *lbsp = lowest_bit_set;
1973   *abbasp = all_bits_between_are_set;
1974 }
1975
1976 static int const64_is_2insns (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
1977
1978 static int
1979 const64_is_2insns (unsigned HOST_WIDE_INT high_bits,
1980                    unsigned HOST_WIDE_INT low_bits)
1981 {
1982   int highest_bit_set, lowest_bit_set, all_bits_between_are_set;
1983
1984   if (high_bits == 0
1985       || high_bits == 0xffffffff)
1986     return 1;
1987
1988   analyze_64bit_constant (high_bits, low_bits,
1989                           &highest_bit_set, &lowest_bit_set,
1990                           &all_bits_between_are_set);
1991
1992   if ((highest_bit_set == 63
1993        || lowest_bit_set == 0)
1994       && all_bits_between_are_set != 0)
1995     return 1;
1996
1997   if ((highest_bit_set - lowest_bit_set) < 21)
1998     return 1;
1999
2000   return 0;
2001 }
2002
2003 static unsigned HOST_WIDE_INT create_simple_focus_bits (unsigned HOST_WIDE_INT,
2004                                                         unsigned HOST_WIDE_INT,
2005                                                         int, int);
2006
2007 static unsigned HOST_WIDE_INT
2008 create_simple_focus_bits (unsigned HOST_WIDE_INT high_bits,
2009                           unsigned HOST_WIDE_INT low_bits,
2010                           int lowest_bit_set, int shift)
2011 {
2012   HOST_WIDE_INT hi, lo;
2013
2014   if (lowest_bit_set < 32)
2015     {
2016       lo = (low_bits >> lowest_bit_set) << shift;
2017       hi = ((high_bits << (32 - lowest_bit_set)) << shift);
2018     }
2019   else
2020     {
2021       lo = 0;
2022       hi = ((high_bits >> (lowest_bit_set - 32)) << shift);
2023     }
2024   gcc_assert (! (hi & lo));
2025   return (hi | lo);
2026 }
2027
2028 /* Here we are sure to be arch64 and this is an integer constant
2029    being loaded into a register.  Emit the most efficient
2030    insn sequence possible.  Detection of all the 1-insn cases
2031    has been done already.  */
2032 static void
2033 sparc_emit_set_const64 (rtx op0, rtx op1)
2034 {
2035   unsigned HOST_WIDE_INT high_bits, low_bits;
2036   int lowest_bit_set, highest_bit_set;
2037   int all_bits_between_are_set;
2038   rtx temp = 0;
2039
2040   /* Sanity check that we know what we are working with.  */
2041   gcc_assert (TARGET_ARCH64
2042               && (GET_CODE (op0) == SUBREG
2043                   || (REG_P (op0) && ! SPARC_FP_REG_P (REGNO (op0)))));
2044
2045   if (! can_create_pseudo_p ())
2046     temp = op0;
2047
2048   if (GET_CODE (op1) != CONST_INT)
2049     {
2050       sparc_emit_set_symbolic_const64 (op0, op1, temp);
2051       return;
2052     }
2053
2054   if (! temp)
2055     temp = gen_reg_rtx (DImode);
2056
2057   high_bits = ((INTVAL (op1) >> 32) & 0xffffffff);
2058   low_bits = (INTVAL (op1) & 0xffffffff);
2059
2060   /* low_bits   bits 0  --> 31
2061      high_bits  bits 32 --> 63  */
2062
2063   analyze_64bit_constant (high_bits, low_bits,
2064                           &highest_bit_set, &lowest_bit_set,
2065                           &all_bits_between_are_set);
2066
2067   /* First try for a 2-insn sequence.  */
2068
2069   /* These situations are preferred because the optimizer can
2070    * do more things with them:
2071    * 1) mov     -1, %reg
2072    *    sllx    %reg, shift, %reg
2073    * 2) mov     -1, %reg
2074    *    srlx    %reg, shift, %reg
2075    * 3) mov     some_small_const, %reg
2076    *    sllx    %reg, shift, %reg
2077    */
2078   if (((highest_bit_set == 63
2079         || lowest_bit_set == 0)
2080        && all_bits_between_are_set != 0)
2081       || ((highest_bit_set - lowest_bit_set) < 12))
2082     {
2083       HOST_WIDE_INT the_const = -1;
2084       int shift = lowest_bit_set;
2085
2086       if ((highest_bit_set != 63
2087            && lowest_bit_set != 0)
2088           || all_bits_between_are_set == 0)
2089         {
2090           the_const =
2091             create_simple_focus_bits (high_bits, low_bits,
2092                                       lowest_bit_set, 0);
2093         }
2094       else if (lowest_bit_set == 0)
2095         shift = -(63 - highest_bit_set);
2096
2097       gcc_assert (SPARC_SIMM13_P (the_const));
2098       gcc_assert (shift != 0);
2099
2100       emit_insn (gen_safe_SET64 (temp, the_const));
2101       if (shift > 0)
2102         emit_insn (gen_rtx_SET (VOIDmode,
2103                                 op0,
2104                                 gen_rtx_ASHIFT (DImode,
2105                                                 temp,
2106                                                 GEN_INT (shift))));
2107       else if (shift < 0)
2108         emit_insn (gen_rtx_SET (VOIDmode,
2109                                 op0,
2110                                 gen_rtx_LSHIFTRT (DImode,
2111                                                   temp,
2112                                                   GEN_INT (-shift))));
2113       return;
2114     }
2115
2116   /* Now a range of 22 or less bits set somewhere.
2117    * 1) sethi   %hi(focus_bits), %reg
2118    *    sllx    %reg, shift, %reg
2119    * 2) sethi   %hi(focus_bits), %reg
2120    *    srlx    %reg, shift, %reg
2121    */
2122   if ((highest_bit_set - lowest_bit_set) < 21)
2123     {
2124       unsigned HOST_WIDE_INT focus_bits =
2125         create_simple_focus_bits (high_bits, low_bits,
2126                                   lowest_bit_set, 10);
2127
2128       gcc_assert (SPARC_SETHI_P (focus_bits));
2129       gcc_assert (lowest_bit_set != 10);
2130
2131       emit_insn (gen_safe_HIGH64 (temp, focus_bits));
2132
2133       /* If lowest_bit_set == 10 then a sethi alone could have done it.  */
2134       if (lowest_bit_set < 10)
2135         emit_insn (gen_rtx_SET (VOIDmode,
2136                                 op0,
2137                                 gen_rtx_LSHIFTRT (DImode, temp,
2138                                                   GEN_INT (10 - lowest_bit_set))));
2139       else if (lowest_bit_set > 10)
2140         emit_insn (gen_rtx_SET (VOIDmode,
2141                                 op0,
2142                                 gen_rtx_ASHIFT (DImode, temp,
2143                                                 GEN_INT (lowest_bit_set - 10))));
2144       return;
2145     }
2146
2147   /* 1) sethi   %hi(low_bits), %reg
2148    *    or      %reg, %lo(low_bits), %reg
2149    * 2) sethi   %hi(~low_bits), %reg
2150    *    xor     %reg, %lo(-0x400 | (low_bits & 0x3ff)), %reg
2151    */
2152   if (high_bits == 0
2153       || high_bits == 0xffffffff)
2154     {
2155       sparc_emit_set_const64_quick1 (op0, temp, low_bits,
2156                                      (high_bits == 0xffffffff));
2157       return;
2158     }
2159
2160   /* Now, try 3-insn sequences.  */
2161
2162   /* 1) sethi   %hi(high_bits), %reg
2163    *    or      %reg, %lo(high_bits), %reg
2164    *    sllx    %reg, 32, %reg
2165    */
2166   if (low_bits == 0)
2167     {
2168       sparc_emit_set_const64_quick2 (op0, temp, high_bits, 0, 32);
2169       return;
2170     }
2171
2172   /* We may be able to do something quick
2173      when the constant is negated, so try that.  */
2174   if (const64_is_2insns ((~high_bits) & 0xffffffff,
2175                          (~low_bits) & 0xfffffc00))
2176     {
2177       /* NOTE: The trailing bits get XOR'd so we need the
2178          non-negated bits, not the negated ones.  */
2179       unsigned HOST_WIDE_INT trailing_bits = low_bits & 0x3ff;
2180
2181       if ((((~high_bits) & 0xffffffff) == 0
2182            && ((~low_bits) & 0x80000000) == 0)
2183           || (((~high_bits) & 0xffffffff) == 0xffffffff
2184               && ((~low_bits) & 0x80000000) != 0))
2185         {
2186           unsigned HOST_WIDE_INT fast_int = (~low_bits & 0xffffffff);
2187
2188           if ((SPARC_SETHI_P (fast_int)
2189                && (~high_bits & 0xffffffff) == 0)
2190               || SPARC_SIMM13_P (fast_int))
2191             emit_insn (gen_safe_SET64 (temp, fast_int));
2192           else
2193             sparc_emit_set_const64 (temp, GEN_INT (fast_int));
2194         }
2195       else
2196         {
2197           rtx negated_const;
2198           negated_const = GEN_INT (((~low_bits) & 0xfffffc00) |
2199                                    (((HOST_WIDE_INT)((~high_bits) & 0xffffffff))<<32));
2200           sparc_emit_set_const64 (temp, negated_const);
2201         }
2202
2203       /* If we are XOR'ing with -1, then we should emit a one's complement
2204          instead.  This way the combiner will notice logical operations
2205          such as ANDN later on and substitute.  */
2206       if (trailing_bits == 0x3ff)
2207         {
2208           emit_insn (gen_rtx_SET (VOIDmode, op0,
2209                                   gen_rtx_NOT (DImode, temp)));
2210         }
2211       else
2212         {
2213           emit_insn (gen_rtx_SET (VOIDmode,
2214                                   op0,
2215                                   gen_safe_XOR64 (temp,
2216                                                   (-0x400 | trailing_bits))));
2217         }
2218       return;
2219     }
2220
2221   /* 1) sethi   %hi(xxx), %reg
2222    *    or      %reg, %lo(xxx), %reg
2223    *    sllx    %reg, yyy, %reg
2224    *
2225    * ??? This is just a generalized version of the low_bits==0
2226    * thing above, FIXME...
2227    */
2228   if ((highest_bit_set - lowest_bit_set) < 32)
2229     {
2230       unsigned HOST_WIDE_INT focus_bits =
2231         create_simple_focus_bits (high_bits, low_bits,
2232                                   lowest_bit_set, 0);
2233
2234       /* We can't get here in this state.  */
2235       gcc_assert (highest_bit_set >= 32 && lowest_bit_set < 32);
2236
2237       /* So what we know is that the set bits straddle the
2238          middle of the 64-bit word.  */
2239       sparc_emit_set_const64_quick2 (op0, temp,
2240                                      focus_bits, 0,
2241                                      lowest_bit_set);
2242       return;
2243     }
2244
2245   /* 1) sethi   %hi(high_bits), %reg
2246    *    or      %reg, %lo(high_bits), %reg
2247    *    sllx    %reg, 32, %reg
2248    *    or      %reg, low_bits, %reg
2249    */
2250   if (SPARC_SIMM13_P(low_bits)
2251       && ((int)low_bits > 0))
2252     {
2253       sparc_emit_set_const64_quick2 (op0, temp, high_bits, low_bits, 32);
2254       return;
2255     }
2256
2257   /* The easiest way when all else fails, is full decomposition.  */
2258   sparc_emit_set_const64_longway (op0, temp, high_bits, low_bits);
2259 }
2260 #endif /* HOST_BITS_PER_WIDE_INT == 32 */
2261
2262 /* Given a comparison code (EQ, NE, etc.) and the first operand of a COMPARE,
2263    return the mode to be used for the comparison.  For floating-point,
2264    CCFP[E]mode is used.  CC_NOOVmode should be used when the first operand
2265    is a PLUS, MINUS, NEG, or ASHIFT.  CCmode should be used when no special
2266    processing is needed.  */
2267
2268 enum machine_mode
2269 select_cc_mode (enum rtx_code op, rtx x, rtx y ATTRIBUTE_UNUSED)
2270 {
2271   if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2272     {
2273       switch (op)
2274         {
2275         case EQ:
2276         case NE:
2277         case UNORDERED:
2278         case ORDERED:
2279         case UNLT:
2280         case UNLE:
2281         case UNGT:
2282         case UNGE:
2283         case UNEQ:
2284         case LTGT:
2285           return CCFPmode;
2286
2287         case LT:
2288         case LE:
2289         case GT:
2290         case GE:
2291           return CCFPEmode;
2292
2293         default:
2294           gcc_unreachable ();
2295         }
2296     }
2297   else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
2298            || GET_CODE (x) == NEG || GET_CODE (x) == ASHIFT)
2299     {
2300       if (TARGET_ARCH64 && GET_MODE (x) == DImode)
2301         return CCX_NOOVmode;
2302       else
2303         return CC_NOOVmode;
2304     }
2305   else
2306     {
2307       if (TARGET_ARCH64 && GET_MODE (x) == DImode)
2308         return CCXmode;
2309       else
2310         return CCmode;
2311     }
2312 }
2313
2314 /* Emit the compare insn and return the CC reg for a CODE comparison
2315    with operands X and Y.  */
2316
2317 static rtx
2318 gen_compare_reg_1 (enum rtx_code code, rtx x, rtx y)
2319 {
2320   enum machine_mode mode;
2321   rtx cc_reg;
2322
2323   if (GET_MODE_CLASS (GET_MODE (x)) == MODE_CC)
2324     return x;
2325
2326   mode = SELECT_CC_MODE (code, x, y);
2327
2328   /* ??? We don't have movcc patterns so we cannot generate pseudo regs for the
2329      fcc regs (cse can't tell they're really call clobbered regs and will
2330      remove a duplicate comparison even if there is an intervening function
2331      call - it will then try to reload the cc reg via an int reg which is why
2332      we need the movcc patterns).  It is possible to provide the movcc
2333      patterns by using the ldxfsr/stxfsr v9 insns.  I tried it: you need two
2334      registers (say %g1,%g5) and it takes about 6 insns.  A better fix would be
2335      to tell cse that CCFPE mode registers (even pseudos) are call
2336      clobbered.  */
2337
2338   /* ??? This is an experiment.  Rather than making changes to cse which may
2339      or may not be easy/clean, we do our own cse.  This is possible because
2340      we will generate hard registers.  Cse knows they're call clobbered (it
2341      doesn't know the same thing about pseudos). If we guess wrong, no big
2342      deal, but if we win, great!  */
2343
2344   if (TARGET_V9 && GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2345 #if 1 /* experiment */
2346     {
2347       int reg;
2348       /* We cycle through the registers to ensure they're all exercised.  */
2349       static int next_fcc_reg = 0;
2350       /* Previous x,y for each fcc reg.  */
2351       static rtx prev_args[4][2];
2352
2353       /* Scan prev_args for x,y.  */
2354       for (reg = 0; reg < 4; reg++)
2355         if (prev_args[reg][0] == x && prev_args[reg][1] == y)
2356           break;
2357       if (reg == 4)
2358         {
2359           reg = next_fcc_reg;
2360           prev_args[reg][0] = x;
2361           prev_args[reg][1] = y;
2362           next_fcc_reg = (next_fcc_reg + 1) & 3;
2363         }
2364       cc_reg = gen_rtx_REG (mode, reg + SPARC_FIRST_V9_FCC_REG);
2365     }
2366 #else
2367     cc_reg = gen_reg_rtx (mode);
2368 #endif /* ! experiment */
2369   else if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2370     cc_reg = gen_rtx_REG (mode, SPARC_FCC_REG);
2371   else
2372     cc_reg = gen_rtx_REG (mode, SPARC_ICC_REG);
2373
2374   /* We shouldn't get there for TFmode if !TARGET_HARD_QUAD.  If we do, this
2375      will only result in an unrecognizable insn so no point in asserting.  */
2376   emit_insn (gen_rtx_SET (VOIDmode, cc_reg, gen_rtx_COMPARE (mode, x, y)));
2377
2378   return cc_reg;
2379 }
2380
2381
2382 /* Emit the compare insn and return the CC reg for the comparison in CMP.  */
2383
2384 rtx
2385 gen_compare_reg (rtx cmp)
2386 {
2387   return gen_compare_reg_1 (GET_CODE (cmp), XEXP (cmp, 0), XEXP (cmp, 1));
2388 }
2389
2390 /* This function is used for v9 only.
2391    DEST is the target of the Scc insn.
2392    CODE is the code for an Scc's comparison.
2393    X and Y are the values we compare.
2394
2395    This function is needed to turn
2396
2397            (set (reg:SI 110)
2398                (gt (reg:CCX 100 %icc)
2399                    (const_int 0)))
2400    into
2401            (set (reg:SI 110)
2402                (gt:DI (reg:CCX 100 %icc)
2403                    (const_int 0)))
2404
2405    IE: The instruction recognizer needs to see the mode of the comparison to
2406    find the right instruction. We could use "gt:DI" right in the
2407    define_expand, but leaving it out allows us to handle DI, SI, etc.  */
2408
2409 static int
2410 gen_v9_scc (rtx dest, enum rtx_code compare_code, rtx x, rtx y)
2411 {
2412   if (! TARGET_ARCH64
2413       && (GET_MODE (x) == DImode
2414           || GET_MODE (dest) == DImode))
2415     return 0;
2416
2417   /* Try to use the movrCC insns.  */
2418   if (TARGET_ARCH64
2419       && GET_MODE_CLASS (GET_MODE (x)) == MODE_INT
2420       && y == const0_rtx
2421       && v9_regcmp_p (compare_code))
2422     {
2423       rtx op0 = x;
2424       rtx temp;
2425
2426       /* Special case for op0 != 0.  This can be done with one instruction if
2427          dest == x.  */
2428
2429       if (compare_code == NE
2430           && GET_MODE (dest) == DImode
2431           && rtx_equal_p (op0, dest))
2432         {
2433           emit_insn (gen_rtx_SET (VOIDmode, dest,
2434                               gen_rtx_IF_THEN_ELSE (DImode,
2435                                        gen_rtx_fmt_ee (compare_code, DImode,
2436                                                        op0, const0_rtx),
2437                                        const1_rtx,
2438                                        dest)));
2439           return 1;
2440         }
2441
2442       if (reg_overlap_mentioned_p (dest, op0))
2443         {
2444           /* Handle the case where dest == x.
2445              We "early clobber" the result.  */
2446           op0 = gen_reg_rtx (GET_MODE (x));
2447           emit_move_insn (op0, x);
2448         }
2449
2450       emit_insn (gen_rtx_SET (VOIDmode, dest, const0_rtx));
2451       if (GET_MODE (op0) != DImode)
2452         {
2453           temp = gen_reg_rtx (DImode);
2454           convert_move (temp, op0, 0);
2455         }
2456       else
2457         temp = op0;
2458       emit_insn (gen_rtx_SET (VOIDmode, dest,
2459                           gen_rtx_IF_THEN_ELSE (GET_MODE (dest),
2460                                    gen_rtx_fmt_ee (compare_code, DImode,
2461                                                    temp, const0_rtx),
2462                                    const1_rtx,
2463                                    dest)));
2464       return 1;
2465     }
2466   else
2467     {
2468       x = gen_compare_reg_1 (compare_code, x, y);
2469       y = const0_rtx;
2470
2471       gcc_assert (GET_MODE (x) != CC_NOOVmode
2472                   && GET_MODE (x) != CCX_NOOVmode);
2473
2474       emit_insn (gen_rtx_SET (VOIDmode, dest, const0_rtx));
2475       emit_insn (gen_rtx_SET (VOIDmode, dest,
2476                           gen_rtx_IF_THEN_ELSE (GET_MODE (dest),
2477                                    gen_rtx_fmt_ee (compare_code,
2478                                                    GET_MODE (x), x, y),
2479                                     const1_rtx, dest)));
2480       return 1;
2481     }
2482 }
2483
2484
2485 /* Emit an scc insn.  For seq, sne, sgeu, and sltu, we can do this
2486    without jumps using the addx/subx instructions.  */
2487
2488 bool
2489 emit_scc_insn (rtx operands[])
2490 {
2491   rtx tem;
2492   rtx x;
2493   rtx y;
2494   enum rtx_code code;
2495
2496   /* The quad-word fp compare library routines all return nonzero to indicate
2497      true, which is different from the equivalent libgcc routines, so we must
2498      handle them specially here.  */
2499   if (GET_MODE (operands[2]) == TFmode && ! TARGET_HARD_QUAD)
2500     {
2501       operands[1] = sparc_emit_float_lib_cmp (operands[2], operands[3],
2502                                               GET_CODE (operands[1]));
2503       operands[2] = XEXP (operands[1], 0);
2504       operands[3] = XEXP (operands[1], 1);
2505     }
2506
2507   code = GET_CODE (operands[1]);
2508   x = operands[2];
2509   y = operands[3];
2510
2511   /* For seq/sne on v9 we use the same code as v8 (the addx/subx method has
2512      more applications).  The exception to this is "reg != 0" which can
2513      be done in one instruction on v9 (so we do it).  */
2514   if (code == EQ)
2515     {
2516       if (GET_MODE (x) == SImode)
2517         {
2518           rtx pat = gen_seqsi_special (operands[0], x, y);
2519           emit_insn (pat);
2520           return true;
2521         }
2522       else if (GET_MODE (x) == DImode)
2523         {
2524           rtx pat = gen_seqdi_special (operands[0], x, y);
2525           emit_insn (pat);
2526           return true;
2527         }
2528     }
2529
2530   if (code == NE)
2531     {
2532       if (GET_MODE (x) == SImode)
2533         {
2534           rtx pat = gen_snesi_special (operands[0], x, y);
2535           emit_insn (pat);
2536           return true;
2537         }
2538       else if (GET_MODE (x) == DImode)
2539         {
2540           rtx pat = gen_snedi_special (operands[0], x, y);
2541           emit_insn (pat);
2542           return true;
2543         }
2544     }
2545
2546   /* For the rest, on v9 we can use conditional moves.  */
2547
2548   if (TARGET_V9)
2549     {
2550       if (gen_v9_scc (operands[0], code, x, y))
2551         return true;
2552     }
2553
2554   /* We can do LTU and GEU using the addx/subx instructions too.  And
2555      for GTU/LEU, if both operands are registers swap them and fall
2556      back to the easy case.  */
2557   if (code == GTU || code == LEU)
2558     {
2559       if ((GET_CODE (x) == REG || GET_CODE (x) == SUBREG)
2560           && (GET_CODE (y) == REG || GET_CODE (y) == SUBREG))
2561         {
2562           tem = x;
2563           x = y;
2564           y = tem;
2565           code = swap_condition (code);
2566         }
2567     }
2568
2569   if (code == LTU || code == GEU)
2570     {
2571       emit_insn (gen_rtx_SET (VOIDmode, operands[0],
2572                               gen_rtx_fmt_ee (code, SImode,
2573                                               gen_compare_reg_1 (code, x, y),
2574                                               const0_rtx)));
2575       return true;
2576     }
2577
2578   /* Nope, do branches.  */
2579   return false;
2580 }
2581
2582 /* Emit a conditional jump insn for the v9 architecture using comparison code
2583    CODE and jump target LABEL.
2584    This function exists to take advantage of the v9 brxx insns.  */
2585
2586 static void
2587 emit_v9_brxx_insn (enum rtx_code code, rtx op0, rtx label)
2588 {
2589   emit_jump_insn (gen_rtx_SET (VOIDmode,
2590                            pc_rtx,
2591                            gen_rtx_IF_THEN_ELSE (VOIDmode,
2592                                     gen_rtx_fmt_ee (code, GET_MODE (op0),
2593                                                     op0, const0_rtx),
2594                                     gen_rtx_LABEL_REF (VOIDmode, label),
2595                                     pc_rtx)));
2596 }
2597
2598 void
2599 emit_conditional_branch_insn (rtx operands[])
2600 {
2601   /* The quad-word fp compare library routines all return nonzero to indicate
2602      true, which is different from the equivalent libgcc routines, so we must
2603      handle them specially here.  */
2604   if (GET_MODE (operands[1]) == TFmode && ! TARGET_HARD_QUAD)
2605     {
2606       operands[0] = sparc_emit_float_lib_cmp (operands[1], operands[2],
2607                                               GET_CODE (operands[0]));
2608       operands[1] = XEXP (operands[0], 0);
2609       operands[2] = XEXP (operands[0], 1);
2610     }
2611
2612   if (TARGET_ARCH64 && operands[2] == const0_rtx
2613       && GET_CODE (operands[1]) == REG
2614       && GET_MODE (operands[1]) == DImode)
2615     {
2616       emit_v9_brxx_insn (GET_CODE (operands[0]), operands[1], operands[3]);
2617       return;
2618     }
2619
2620   operands[1] = gen_compare_reg (operands[0]);
2621   operands[2] = const0_rtx;
2622   operands[0] = gen_rtx_fmt_ee (GET_CODE (operands[0]), VOIDmode,
2623                                 operands[1], operands[2]);
2624   emit_jump_insn (gen_cbranchcc4 (operands[0], operands[1], operands[2],
2625                                   operands[3]));
2626 }
2627
2628
2629 /* Generate a DFmode part of a hard TFmode register.
2630    REG is the TFmode hard register, LOW is 1 for the
2631    low 64bit of the register and 0 otherwise.
2632  */
2633 rtx
2634 gen_df_reg (rtx reg, int low)
2635 {
2636   int regno = REGNO (reg);
2637
2638   if ((WORDS_BIG_ENDIAN == 0) ^ (low != 0))
2639     regno += (TARGET_ARCH64 && SPARC_INT_REG_P (regno)) ? 1 : 2;
2640   return gen_rtx_REG (DFmode, regno);
2641 }
2642 \f
2643 /* Generate a call to FUNC with OPERANDS.  Operand 0 is the return value.
2644    Unlike normal calls, TFmode operands are passed by reference.  It is
2645    assumed that no more than 3 operands are required.  */
2646
2647 static void
2648 emit_soft_tfmode_libcall (const char *func_name, int nargs, rtx *operands)
2649 {
2650   rtx ret_slot = NULL, arg[3], func_sym;
2651   int i;
2652
2653   /* We only expect to be called for conversions, unary, and binary ops.  */
2654   gcc_assert (nargs == 2 || nargs == 3);
2655
2656   for (i = 0; i < nargs; ++i)
2657     {
2658       rtx this_arg = operands[i];
2659       rtx this_slot;
2660
2661       /* TFmode arguments and return values are passed by reference.  */
2662       if (GET_MODE (this_arg) == TFmode)
2663         {
2664           int force_stack_temp;
2665
2666           force_stack_temp = 0;
2667           if (TARGET_BUGGY_QP_LIB && i == 0)
2668             force_stack_temp = 1;
2669
2670           if (GET_CODE (this_arg) == MEM
2671               && ! force_stack_temp)
2672             this_arg = XEXP (this_arg, 0);
2673           else if (CONSTANT_P (this_arg)
2674                    && ! force_stack_temp)
2675             {
2676               this_slot = force_const_mem (TFmode, this_arg);
2677               this_arg = XEXP (this_slot, 0);
2678             }
2679           else
2680             {
2681               this_slot = assign_stack_temp (TFmode, GET_MODE_SIZE (TFmode), 0);
2682
2683               /* Operand 0 is the return value.  We'll copy it out later.  */
2684               if (i > 0)
2685                 emit_move_insn (this_slot, this_arg);
2686               else
2687                 ret_slot = this_slot;
2688
2689               this_arg = XEXP (this_slot, 0);
2690             }
2691         }
2692
2693       arg[i] = this_arg;
2694     }
2695
2696   func_sym = gen_rtx_SYMBOL_REF (Pmode, func_name);
2697
2698   if (GET_MODE (operands[0]) == TFmode)
2699     {
2700       if (nargs == 2)
2701         emit_library_call (func_sym, LCT_NORMAL, VOIDmode, 2,
2702                            arg[0], GET_MODE (arg[0]),
2703                            arg[1], GET_MODE (arg[1]));
2704       else
2705         emit_library_call (func_sym, LCT_NORMAL, VOIDmode, 3,
2706                            arg[0], GET_MODE (arg[0]),
2707                            arg[1], GET_MODE (arg[1]),
2708                            arg[2], GET_MODE (arg[2]));
2709
2710       if (ret_slot)
2711         emit_move_insn (operands[0], ret_slot);
2712     }
2713   else
2714     {
2715       rtx ret;
2716
2717       gcc_assert (nargs == 2);
2718
2719       ret = emit_library_call_value (func_sym, operands[0], LCT_NORMAL,
2720                                      GET_MODE (operands[0]), 1,
2721                                      arg[1], GET_MODE (arg[1]));
2722
2723       if (ret != operands[0])
2724         emit_move_insn (operands[0], ret);
2725     }
2726 }
2727
2728 /* Expand soft-float TFmode calls to sparc abi routines.  */
2729
2730 static void
2731 emit_soft_tfmode_binop (enum rtx_code code, rtx *operands)
2732 {
2733   const char *func;
2734
2735   switch (code)
2736     {
2737     case PLUS:
2738       func = "_Qp_add";
2739       break;
2740     case MINUS:
2741       func = "_Qp_sub";
2742       break;
2743     case MULT:
2744       func = "_Qp_mul";
2745       break;
2746     case DIV:
2747       func = "_Qp_div";
2748       break;
2749     default:
2750       gcc_unreachable ();
2751     }
2752
2753   emit_soft_tfmode_libcall (func, 3, operands);
2754 }
2755
2756 static void
2757 emit_soft_tfmode_unop (enum rtx_code code, rtx *operands)
2758 {
2759   const char *func;
2760
2761   gcc_assert (code == SQRT);
2762   func = "_Qp_sqrt";
2763
2764   emit_soft_tfmode_libcall (func, 2, operands);
2765 }
2766
2767 static void
2768 emit_soft_tfmode_cvt (enum rtx_code code, rtx *operands)
2769 {
2770   const char *func;
2771
2772   switch (code)
2773     {
2774     case FLOAT_EXTEND:
2775       switch (GET_MODE (operands[1]))
2776         {
2777         case SFmode:
2778           func = "_Qp_stoq";
2779           break;
2780         case DFmode:
2781           func = "_Qp_dtoq";
2782           break;
2783         default:
2784           gcc_unreachable ();
2785         }
2786       break;
2787
2788     case FLOAT_TRUNCATE:
2789       switch (GET_MODE (operands[0]))
2790         {
2791         case SFmode:
2792           func = "_Qp_qtos";
2793           break;
2794         case DFmode:
2795           func = "_Qp_qtod";
2796           break;
2797         default:
2798           gcc_unreachable ();
2799         }
2800       break;
2801
2802     case FLOAT:
2803       switch (GET_MODE (operands[1]))
2804         {
2805         case SImode:
2806           func = "_Qp_itoq";
2807           if (TARGET_ARCH64)
2808             operands[1] = gen_rtx_SIGN_EXTEND (DImode, operands[1]);
2809           break;
2810         case DImode:
2811           func = "_Qp_xtoq";
2812           break;
2813         default:
2814           gcc_unreachable ();
2815         }
2816       break;
2817
2818     case UNSIGNED_FLOAT:
2819       switch (GET_MODE (operands[1]))
2820         {
2821         case SImode:
2822           func = "_Qp_uitoq";
2823           if (TARGET_ARCH64)
2824             operands[1] = gen_rtx_ZERO_EXTEND (DImode, operands[1]);
2825           break;
2826         case DImode:
2827           func = "_Qp_uxtoq";
2828           break;
2829         default:
2830           gcc_unreachable ();
2831         }
2832       break;
2833
2834     case FIX:
2835       switch (GET_MODE (operands[0]))
2836         {
2837         case SImode:
2838           func = "_Qp_qtoi";
2839           break;
2840         case DImode:
2841           func = "_Qp_qtox";
2842           break;
2843         default:
2844           gcc_unreachable ();
2845         }
2846       break;
2847
2848     case UNSIGNED_FIX:
2849       switch (GET_MODE (operands[0]))
2850         {
2851         case SImode:
2852           func = "_Qp_qtoui";
2853           break;
2854         case DImode:
2855           func = "_Qp_qtoux";
2856           break;
2857         default:
2858           gcc_unreachable ();
2859         }
2860       break;
2861
2862     default:
2863       gcc_unreachable ();
2864     }
2865
2866   emit_soft_tfmode_libcall (func, 2, operands);
2867 }
2868
2869 /* Expand a hard-float tfmode operation.  All arguments must be in
2870    registers.  */
2871
2872 static void
2873 emit_hard_tfmode_operation (enum rtx_code code, rtx *operands)
2874 {
2875   rtx op, dest;
2876
2877   if (GET_RTX_CLASS (code) == RTX_UNARY)
2878     {
2879       operands[1] = force_reg (GET_MODE (operands[1]), operands[1]);
2880       op = gen_rtx_fmt_e (code, GET_MODE (operands[0]), operands[1]);
2881     }
2882   else
2883     {
2884       operands[1] = force_reg (GET_MODE (operands[1]), operands[1]);
2885       operands[2] = force_reg (GET_MODE (operands[2]), operands[2]);
2886       op = gen_rtx_fmt_ee (code, GET_MODE (operands[0]),
2887                            operands[1], operands[2]);
2888     }
2889
2890   if (register_operand (operands[0], VOIDmode))
2891     dest = operands[0];
2892   else
2893     dest = gen_reg_rtx (GET_MODE (operands[0]));
2894
2895   emit_insn (gen_rtx_SET (VOIDmode, dest, op));
2896
2897   if (dest != operands[0])
2898     emit_move_insn (operands[0], dest);
2899 }
2900
2901 void
2902 emit_tfmode_binop (enum rtx_code code, rtx *operands)
2903 {
2904   if (TARGET_HARD_QUAD)
2905     emit_hard_tfmode_operation (code, operands);
2906   else
2907     emit_soft_tfmode_binop (code, operands);
2908 }
2909
2910 void
2911 emit_tfmode_unop (enum rtx_code code, rtx *operands)
2912 {
2913   if (TARGET_HARD_QUAD)
2914     emit_hard_tfmode_operation (code, operands);
2915   else
2916     emit_soft_tfmode_unop (code, operands);
2917 }
2918
2919 void
2920 emit_tfmode_cvt (enum rtx_code code, rtx *operands)
2921 {
2922   if (TARGET_HARD_QUAD)
2923     emit_hard_tfmode_operation (code, operands);
2924   else
2925     emit_soft_tfmode_cvt (code, operands);
2926 }
2927 \f
2928 /* Return nonzero if a branch/jump/call instruction will be emitting
2929    nop into its delay slot.  */
2930
2931 int
2932 empty_delay_slot (rtx insn)
2933 {
2934   rtx seq;
2935
2936   /* If no previous instruction (should not happen), return true.  */
2937   if (PREV_INSN (insn) == NULL)
2938     return 1;
2939
2940   seq = NEXT_INSN (PREV_INSN (insn));
2941   if (GET_CODE (PATTERN (seq)) == SEQUENCE)
2942     return 0;
2943
2944   return 1;
2945 }
2946
2947 /* Return nonzero if TRIAL can go into the call delay slot.  */
2948
2949 int
2950 tls_call_delay (rtx trial)
2951 {
2952   rtx pat;
2953
2954   /* Binutils allows
2955        call __tls_get_addr, %tgd_call (foo)
2956         add %l7, %o0, %o0, %tgd_add (foo)
2957      while Sun as/ld does not.  */
2958   if (TARGET_GNU_TLS || !TARGET_TLS)
2959     return 1;
2960
2961   pat = PATTERN (trial);
2962
2963   /* We must reject tgd_add{32|64}, i.e.
2964        (set (reg) (plus (reg) (unspec [(reg) (symbol_ref)] UNSPEC_TLSGD)))
2965      and tldm_add{32|64}, i.e.
2966        (set (reg) (plus (reg) (unspec [(reg) (symbol_ref)] UNSPEC_TLSLDM)))
2967      for Sun as/ld.  */
2968   if (GET_CODE (pat) == SET
2969       && GET_CODE (SET_SRC (pat)) == PLUS)
2970     {
2971       rtx unspec = XEXP (SET_SRC (pat), 1);
2972
2973       if (GET_CODE (unspec) == UNSPEC
2974           && (XINT (unspec, 1) == UNSPEC_TLSGD
2975               || XINT (unspec, 1) == UNSPEC_TLSLDM))
2976         return 0;
2977     }
2978
2979   return 1;
2980 }
2981
2982 /* Return nonzero if TRIAL, an insn, can be combined with a 'restore'
2983    instruction.  RETURN_P is true if the v9 variant 'return' is to be
2984    considered in the test too.
2985
2986    TRIAL must be a SET whose destination is a REG appropriate for the
2987    'restore' instruction or, if RETURN_P is true, for the 'return'
2988    instruction.  */
2989
2990 static int
2991 eligible_for_restore_insn (rtx trial, bool return_p)
2992 {
2993   rtx pat = PATTERN (trial);
2994   rtx src = SET_SRC (pat);
2995   bool src_is_freg = false;
2996   rtx src_reg;
2997
2998   /* Since we now can do moves between float and integer registers when
2999      VIS3 is enabled, we have to catch this case.  We can allow such
3000      moves when doing a 'return' however.  */
3001   src_reg = src;
3002   if (GET_CODE (src_reg) == SUBREG)
3003     src_reg = SUBREG_REG (src_reg);
3004   if (GET_CODE (src_reg) == REG
3005       && SPARC_FP_REG_P (REGNO (src_reg)))
3006     src_is_freg = true;
3007
3008   /* The 'restore src,%g0,dest' pattern for word mode and below.  */
3009   if (GET_MODE_CLASS (GET_MODE (src)) != MODE_FLOAT
3010       && arith_operand (src, GET_MODE (src))
3011       && ! src_is_freg)
3012     {
3013       if (TARGET_ARCH64)
3014         return GET_MODE_SIZE (GET_MODE (src)) <= GET_MODE_SIZE (DImode);
3015       else
3016         return GET_MODE_SIZE (GET_MODE (src)) <= GET_MODE_SIZE (SImode);
3017     }
3018
3019   /* The 'restore src,%g0,dest' pattern for double-word mode.  */
3020   else if (GET_MODE_CLASS (GET_MODE (src)) != MODE_FLOAT
3021            && arith_double_operand (src, GET_MODE (src))
3022            && ! src_is_freg)
3023     return GET_MODE_SIZE (GET_MODE (src)) <= GET_MODE_SIZE (DImode);
3024
3025   /* The 'restore src,%g0,dest' pattern for float if no FPU.  */
3026   else if (! TARGET_FPU && register_operand (src, SFmode))
3027     return 1;
3028
3029   /* The 'restore src,%g0,dest' pattern for double if no FPU.  */
3030   else if (! TARGET_FPU && TARGET_ARCH64 && register_operand (src, DFmode))
3031     return 1;
3032
3033   /* If we have the 'return' instruction, anything that does not use
3034      local or output registers and can go into a delay slot wins.  */
3035   else if (return_p
3036            && TARGET_V9
3037            && !epilogue_renumber (&pat, 1)
3038            && get_attr_in_uncond_branch_delay (trial)
3039                == IN_UNCOND_BRANCH_DELAY_TRUE)
3040     return 1;
3041
3042   /* The 'restore src1,src2,dest' pattern for SImode.  */
3043   else if (GET_CODE (src) == PLUS
3044            && register_operand (XEXP (src, 0), SImode)
3045            && arith_operand (XEXP (src, 1), SImode))
3046     return 1;
3047
3048   /* The 'restore src1,src2,dest' pattern for DImode.  */
3049   else if (GET_CODE (src) == PLUS
3050            && register_operand (XEXP (src, 0), DImode)
3051            && arith_double_operand (XEXP (src, 1), DImode))
3052     return 1;
3053
3054   /* The 'restore src1,%lo(src2),dest' pattern.  */
3055   else if (GET_CODE (src) == LO_SUM
3056            && ! TARGET_CM_MEDMID
3057            && ((register_operand (XEXP (src, 0), SImode)
3058                 && immediate_operand (XEXP (src, 1), SImode))
3059                || (TARGET_ARCH64
3060                    && register_operand (XEXP (src, 0), DImode)
3061                    && immediate_operand (XEXP (src, 1), DImode))))
3062     return 1;
3063
3064   /* The 'restore src,src,dest' pattern.  */
3065   else if (GET_CODE (src) == ASHIFT
3066            && (register_operand (XEXP (src, 0), SImode)
3067                || register_operand (XEXP (src, 0), DImode))
3068            && XEXP (src, 1) == const1_rtx)
3069     return 1;
3070
3071   return 0;
3072 }
3073
3074 /* Return nonzero if TRIAL can go into the function return's delay slot.  */
3075
3076 int
3077 eligible_for_return_delay (rtx trial)
3078 {
3079   int regno;
3080   rtx pat;
3081
3082   if (GET_CODE (trial) != INSN)
3083     return 0;
3084
3085   if (get_attr_length (trial) != 1)
3086     return 0;
3087
3088   /* If the function uses __builtin_eh_return, the eh_return machinery
3089      occupies the delay slot.  */
3090   if (crtl->calls_eh_return)
3091     return 0;
3092
3093   /* In the case of a leaf or flat function, anything can go into the slot.  */
3094   if (sparc_leaf_function_p || TARGET_FLAT)
3095     return
3096       get_attr_in_uncond_branch_delay (trial) == IN_UNCOND_BRANCH_DELAY_TRUE;
3097
3098   pat = PATTERN (trial);
3099   if (GET_CODE (pat) == PARALLEL)
3100     {
3101       int i;
3102
3103       if (! TARGET_V9)
3104         return 0;
3105       for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)
3106         {
3107           rtx expr = XVECEXP (pat, 0, i);
3108           if (GET_CODE (expr) != SET)
3109             return 0;
3110           if (GET_CODE (SET_DEST (expr)) != REG)
3111             return 0;
3112           regno = REGNO (SET_DEST (expr));
3113           if (regno >= 8 && regno < 24)
3114             return 0;
3115         }
3116       return !epilogue_renumber (&pat, 1)
3117         && (get_attr_in_uncond_branch_delay (trial)
3118             == IN_UNCOND_BRANCH_DELAY_TRUE);
3119     }
3120
3121   if (GET_CODE (pat) != SET)
3122     return 0;
3123
3124   if (GET_CODE (SET_DEST (pat)) != REG)
3125     return 0;
3126
3127   regno = REGNO (SET_DEST (pat));
3128
3129   /* Otherwise, only operations which can be done in tandem with
3130      a `restore' or `return' insn can go into the delay slot.  */
3131   if (regno >= 8 && regno < 24)
3132     return 0;
3133
3134   /* If this instruction sets up floating point register and we have a return
3135      instruction, it can probably go in.  But restore will not work
3136      with FP_REGS.  */
3137   if (! SPARC_INT_REG_P (regno))
3138     return (TARGET_V9
3139             && !epilogue_renumber (&pat, 1)
3140             && get_attr_in_uncond_branch_delay (trial)
3141                == IN_UNCOND_BRANCH_DELAY_TRUE);
3142
3143   return eligible_for_restore_insn (trial, true);
3144 }
3145
3146 /* Return nonzero if TRIAL can go into the sibling call's delay slot.  */
3147
3148 int
3149 eligible_for_sibcall_delay (rtx trial)
3150 {
3151   rtx pat;
3152
3153   if (GET_CODE (trial) != INSN || GET_CODE (PATTERN (trial)) != SET)
3154     return 0;
3155
3156   if (get_attr_length (trial) != 1)
3157     return 0;
3158
3159   pat = PATTERN (trial);
3160
3161   if (sparc_leaf_function_p || TARGET_FLAT)
3162     {
3163       /* If the tail call is done using the call instruction,
3164          we have to restore %o7 in the delay slot.  */
3165       if (LEAF_SIBCALL_SLOT_RESERVED_P)
3166         return 0;
3167
3168       /* %g1 is used to build the function address */
3169       if (reg_mentioned_p (gen_rtx_REG (Pmode, 1), pat))
3170         return 0;
3171
3172       return 1;
3173     }
3174
3175   /* Otherwise, only operations which can be done in tandem with
3176      a `restore' insn can go into the delay slot.  */
3177   if (GET_CODE (SET_DEST (pat)) != REG
3178       || (REGNO (SET_DEST (pat)) >= 8 && REGNO (SET_DEST (pat)) < 24)
3179       || ! SPARC_INT_REG_P (REGNO (SET_DEST (pat))))
3180     return 0;
3181
3182   /* If it mentions %o7, it can't go in, because sibcall will clobber it
3183      in most cases.  */
3184   if (reg_mentioned_p (gen_rtx_REG (Pmode, 15), pat))
3185     return 0;
3186
3187   return eligible_for_restore_insn (trial, false);
3188 }
3189 \f
3190 /* Determine if it's legal to put X into the constant pool.  This
3191    is not possible if X contains the address of a symbol that is
3192    not constant (TLS) or not known at final link time (PIC).  */
3193
3194 static bool
3195 sparc_cannot_force_const_mem (enum machine_mode mode, rtx x)
3196 {
3197   switch (GET_CODE (x))
3198     {
3199     case CONST_INT:
3200     case CONST_DOUBLE:
3201     case CONST_VECTOR:
3202       /* Accept all non-symbolic constants.  */
3203       return false;
3204
3205     case LABEL_REF:
3206       /* Labels are OK iff we are non-PIC.  */
3207       return flag_pic != 0;
3208
3209     case SYMBOL_REF:
3210       /* 'Naked' TLS symbol references are never OK,
3211          non-TLS symbols are OK iff we are non-PIC.  */
3212       if (SYMBOL_REF_TLS_MODEL (x))
3213         return true;
3214       else
3215         return flag_pic != 0;
3216
3217     case CONST:
3218       return sparc_cannot_force_const_mem (mode, XEXP (x, 0));
3219     case PLUS:
3220     case MINUS:
3221       return sparc_cannot_force_const_mem (mode, XEXP (x, 0))
3222          || sparc_cannot_force_const_mem (mode, XEXP (x, 1));
3223     case UNSPEC:
3224       return true;
3225     default:
3226       gcc_unreachable ();
3227     }
3228 }
3229 \f
3230 /* Global Offset Table support.  */
3231 static GTY(()) rtx got_helper_rtx = NULL_RTX;
3232 static GTY(()) rtx global_offset_table_rtx = NULL_RTX;
3233
3234 /* Return the SYMBOL_REF for the Global Offset Table.  */
3235
3236 static GTY(()) rtx sparc_got_symbol = NULL_RTX;
3237
3238 static rtx
3239 sparc_got (void)
3240 {
3241   if (!sparc_got_symbol)
3242     sparc_got_symbol = gen_rtx_SYMBOL_REF (Pmode, "_GLOBAL_OFFSET_TABLE_");
3243
3244   return sparc_got_symbol;
3245 }
3246
3247 /* Ensure that we are not using patterns that are not OK with PIC.  */
3248
3249 int
3250 check_pic (int i)
3251 {
3252   rtx op;
3253
3254   switch (flag_pic)
3255     {
3256     case 1:
3257       op = recog_data.operand[i];
3258       gcc_assert (GET_CODE (op) != SYMBOL_REF
3259                   && (GET_CODE (op) != CONST
3260                       || (GET_CODE (XEXP (op, 0)) == MINUS
3261                           && XEXP (XEXP (op, 0), 0) == sparc_got ()
3262                           && GET_CODE (XEXP (XEXP (op, 0), 1)) == CONST)));
3263     case 2:
3264     default:
3265       return 1;
3266     }
3267 }
3268
3269 /* Return true if X is an address which needs a temporary register when
3270    reloaded while generating PIC code.  */
3271
3272 int
3273 pic_address_needs_scratch (rtx x)
3274 {
3275   /* An address which is a symbolic plus a non SMALL_INT needs a temp reg.  */
3276   if (GET_CODE (x) == CONST && GET_CODE (XEXP (x, 0)) == PLUS
3277       && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
3278       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
3279       && ! SMALL_INT (XEXP (XEXP (x, 0), 1)))
3280     return 1;
3281
3282   return 0;
3283 }
3284
3285 /* Determine if a given RTX is a valid constant.  We already know this
3286    satisfies CONSTANT_P.  */
3287
3288 static bool
3289 sparc_legitimate_constant_p (enum machine_mode mode, rtx x)
3290 {
3291   switch (GET_CODE (x))
3292     {
3293     case CONST:
3294     case SYMBOL_REF:
3295       if (sparc_tls_referenced_p (x))
3296         return false;
3297       break;
3298
3299     case CONST_DOUBLE:
3300       if (GET_MODE (x) == VOIDmode)
3301         return true;
3302
3303       /* Floating point constants are generally not ok.
3304          The only exception is 0.0 and all-ones in VIS.  */
3305       if (TARGET_VIS
3306           && SCALAR_FLOAT_MODE_P (mode)
3307           && (const_zero_operand (x, mode)
3308               || const_all_ones_operand (x, mode)))
3309         return true;
3310
3311       return false;
3312
3313     case CONST_VECTOR:
3314       /* Vector constants are generally not ok.
3315          The only exception is 0 or -1 in VIS.  */
3316       if (TARGET_VIS
3317           && (const_zero_operand (x, mode)
3318               || const_all_ones_operand (x, mode)))
3319         return true;
3320
3321       return false;
3322
3323     default:
3324       break;
3325     }
3326
3327   return true;
3328 }
3329
3330 /* Determine if a given RTX is a valid constant address.  */
3331
3332 bool
3333 constant_address_p (rtx x)
3334 {
3335   switch (GET_CODE (x))
3336     {
3337     case LABEL_REF:
3338     case CONST_INT:
3339     case HIGH:
3340       return true;
3341
3342     case CONST:
3343       if (flag_pic && pic_address_needs_scratch (x))
3344         return false;
3345       return sparc_legitimate_constant_p (Pmode, x);
3346
3347     case SYMBOL_REF:
3348       return !flag_pic && sparc_legitimate_constant_p (Pmode, x);
3349
3350     default:
3351       return false;
3352     }
3353 }
3354
3355 /* Nonzero if the constant value X is a legitimate general operand
3356    when generating PIC code.  It is given that flag_pic is on and
3357    that X satisfies CONSTANT_P or is a CONST_DOUBLE.  */
3358
3359 bool
3360 legitimate_pic_operand_p (rtx x)
3361 {
3362   if (pic_address_needs_scratch (x))
3363     return false;
3364   if (sparc_tls_referenced_p (x))
3365     return false;
3366   return true;
3367 }
3368
3369 #define RTX_OK_FOR_OFFSET_P(X, MODE)                    \
3370   (CONST_INT_P (X)                                      \
3371    && INTVAL (X) >= -0x1000                             \
3372    && INTVAL (X) < (0x1000 - GET_MODE_SIZE (MODE)))
3373
3374 #define RTX_OK_FOR_OLO10_P(X, MODE)                     \
3375   (CONST_INT_P (X)                                      \
3376    && INTVAL (X) >= -0x1000                             \
3377    && INTVAL (X) < (0xc00 - GET_MODE_SIZE (MODE)))
3378
3379 /* Handle the TARGET_LEGITIMATE_ADDRESS_P target hook.
3380
3381    On SPARC, the actual legitimate addresses must be REG+REG or REG+SMALLINT
3382    ordinarily.  This changes a bit when generating PIC.  */
3383
3384 static bool
3385 sparc_legitimate_address_p (enum machine_mode mode, rtx addr, bool strict)
3386 {
3387   rtx rs1 = NULL, rs2 = NULL, imm1 = NULL;
3388
3389   if (REG_P (addr) || GET_CODE (addr) == SUBREG)
3390     rs1 = addr;
3391   else if (GET_CODE (addr) == PLUS)
3392     {
3393       rs1 = XEXP (addr, 0);
3394       rs2 = XEXP (addr, 1);
3395
3396       /* Canonicalize.  REG comes first, if there are no regs,
3397          LO_SUM comes first.  */
3398       if (!REG_P (rs1)
3399           && GET_CODE (rs1) != SUBREG
3400           && (REG_P (rs2)
3401               || GET_CODE (rs2) == SUBREG
3402               || (GET_CODE (rs2) == LO_SUM && GET_CODE (rs1) != LO_SUM)))
3403         {
3404           rs1 = XEXP (addr, 1);
3405           rs2 = XEXP (addr, 0);
3406         }
3407
3408       if ((flag_pic == 1
3409            && rs1 == pic_offset_table_rtx
3410            && !REG_P (rs2)
3411            && GET_CODE (rs2) != SUBREG
3412            && GET_CODE (rs2) != LO_SUM
3413            && GET_CODE (rs2) != MEM
3414            && !(GET_CODE (rs2) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (rs2))
3415            && (! symbolic_operand (rs2, VOIDmode) || mode == Pmode)
3416            && (GET_CODE (rs2) != CONST_INT || SMALL_INT (rs2)))
3417           || ((REG_P (rs1)
3418                || GET_CODE (rs1) == SUBREG)
3419               && RTX_OK_FOR_OFFSET_P (rs2, mode)))
3420         {
3421           imm1 = rs2;
3422           rs2 = NULL;
3423         }
3424       else if ((REG_P (rs1) || GET_CODE (rs1) == SUBREG)
3425                && (REG_P (rs2) || GET_CODE (rs2) == SUBREG))
3426         {
3427           /* We prohibit REG + REG for TFmode when there are no quad move insns
3428              and we consequently need to split.  We do this because REG+REG
3429              is not an offsettable address.  If we get the situation in reload
3430              where source and destination of a movtf pattern are both MEMs with
3431              REG+REG address, then only one of them gets converted to an
3432              offsettable address.  */
3433           if (mode == TFmode
3434               && ! (TARGET_FPU && TARGET_ARCH64 && TARGET_HARD_QUAD))
3435             return 0;
3436
3437           /* We prohibit REG + REG on ARCH32 if not optimizing for
3438              DFmode/DImode because then mem_min_alignment is likely to be zero
3439              after reload and the  forced split would lack a matching splitter
3440              pattern.  */
3441           if (TARGET_ARCH32 && !optimize
3442               && (mode == DFmode || mode == DImode))
3443             return 0;
3444         }
3445       else if (USE_AS_OFFSETABLE_LO10
3446                && GET_CODE (rs1) == LO_SUM
3447                && TARGET_ARCH64
3448                && ! TARGET_CM_MEDMID
3449                && RTX_OK_FOR_OLO10_P (rs2, mode))
3450         {
3451           rs2 = NULL;
3452           imm1 = XEXP (rs1, 1);
3453           rs1 = XEXP (rs1, 0);
3454           if (!CONSTANT_P (imm1)
3455               || (GET_CODE (rs1) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (rs1)))
3456             return 0;
3457         }
3458     }
3459   else if (GET_CODE (addr) == LO_SUM)
3460     {
3461       rs1 = XEXP (addr, 0);
3462       imm1 = XEXP (addr, 1);
3463
3464       if (!CONSTANT_P (imm1)
3465           || (GET_CODE (rs1) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (rs1)))
3466   &nbs