OSDN Git Service

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