OSDN Git Service

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