OSDN Git Service

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