OSDN Git Service

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