OSDN Git Service

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