OSDN Git Service

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