OSDN Git Service

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