1 /* Subroutines for insn-output.c for SPARC.
2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005 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,
8 This file is part of GCC.
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)
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.
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. */
27 #include "coretypes.h"
32 #include "hard-reg-set.h"
34 #include "insn-config.h"
35 #include "insn-codes.h"
36 #include "conditions.h"
38 #include "insn-attr.h"
49 #include "target-def.h"
50 #include "cfglayout.h"
51 #include "tree-gimple.h"
52 #include "langhooks.h"
56 struct processor_costs cypress_costs = {
57 COSTS_N_INSNS (2), /* int load */
58 COSTS_N_INSNS (2), /* int signed load */
59 COSTS_N_INSNS (2), /* int zeroed load */
60 COSTS_N_INSNS (2), /* float load */
61 COSTS_N_INSNS (5), /* fmov, fneg, fabs */
62 COSTS_N_INSNS (5), /* fadd, fsub */
63 COSTS_N_INSNS (1), /* fcmp */
64 COSTS_N_INSNS (1), /* fmov, fmovr */
65 COSTS_N_INSNS (7), /* fmul */
66 COSTS_N_INSNS (37), /* fdivs */
67 COSTS_N_INSNS (37), /* fdivd */
68 COSTS_N_INSNS (63), /* fsqrts */
69 COSTS_N_INSNS (63), /* fsqrtd */
70 COSTS_N_INSNS (1), /* imul */
71 COSTS_N_INSNS (1), /* imulX */
72 0, /* imul bit factor */
73 COSTS_N_INSNS (1), /* idiv */
74 COSTS_N_INSNS (1), /* idivX */
75 COSTS_N_INSNS (1), /* movcc/movr */
76 0, /* shift penalty */
80 struct processor_costs supersparc_costs = {
81 COSTS_N_INSNS (1), /* int load */
82 COSTS_N_INSNS (1), /* int signed load */
83 COSTS_N_INSNS (1), /* int zeroed load */
84 COSTS_N_INSNS (0), /* float load */
85 COSTS_N_INSNS (3), /* fmov, fneg, fabs */
86 COSTS_N_INSNS (3), /* fadd, fsub */
87 COSTS_N_INSNS (3), /* fcmp */
88 COSTS_N_INSNS (1), /* fmov, fmovr */
89 COSTS_N_INSNS (3), /* fmul */
90 COSTS_N_INSNS (6), /* fdivs */
91 COSTS_N_INSNS (9), /* fdivd */
92 COSTS_N_INSNS (12), /* fsqrts */
93 COSTS_N_INSNS (12), /* fsqrtd */
94 COSTS_N_INSNS (4), /* imul */
95 COSTS_N_INSNS (4), /* imulX */
96 0, /* imul bit factor */
97 COSTS_N_INSNS (4), /* idiv */
98 COSTS_N_INSNS (4), /* idivX */
99 COSTS_N_INSNS (1), /* movcc/movr */
100 1, /* shift penalty */
104 struct processor_costs hypersparc_costs = {
105 COSTS_N_INSNS (1), /* int load */
106 COSTS_N_INSNS (1), /* int signed load */
107 COSTS_N_INSNS (1), /* int zeroed load */
108 COSTS_N_INSNS (1), /* float load */
109 COSTS_N_INSNS (1), /* fmov, fneg, fabs */
110 COSTS_N_INSNS (1), /* fadd, fsub */
111 COSTS_N_INSNS (1), /* fcmp */
112 COSTS_N_INSNS (1), /* fmov, fmovr */
113 COSTS_N_INSNS (1), /* fmul */
114 COSTS_N_INSNS (8), /* fdivs */
115 COSTS_N_INSNS (12), /* fdivd */
116 COSTS_N_INSNS (17), /* fsqrts */
117 COSTS_N_INSNS (17), /* fsqrtd */
118 COSTS_N_INSNS (17), /* imul */
119 COSTS_N_INSNS (17), /* imulX */
120 0, /* imul bit factor */
121 COSTS_N_INSNS (17), /* idiv */
122 COSTS_N_INSNS (17), /* idivX */
123 COSTS_N_INSNS (1), /* movcc/movr */
124 0, /* shift penalty */
128 struct processor_costs sparclet_costs = {
129 COSTS_N_INSNS (3), /* int load */
130 COSTS_N_INSNS (3), /* int signed load */
131 COSTS_N_INSNS (1), /* int zeroed load */
132 COSTS_N_INSNS (1), /* float load */
133 COSTS_N_INSNS (1), /* fmov, fneg, fabs */
134 COSTS_N_INSNS (1), /* fadd, fsub */
135 COSTS_N_INSNS (1), /* fcmp */
136 COSTS_N_INSNS (1), /* fmov, fmovr */
137 COSTS_N_INSNS (1), /* fmul */
138 COSTS_N_INSNS (1), /* fdivs */
139 COSTS_N_INSNS (1), /* fdivd */
140 COSTS_N_INSNS (1), /* fsqrts */
141 COSTS_N_INSNS (1), /* fsqrtd */
142 COSTS_N_INSNS (5), /* imul */
143 COSTS_N_INSNS (5), /* imulX */
144 0, /* imul bit factor */
145 COSTS_N_INSNS (5), /* idiv */
146 COSTS_N_INSNS (5), /* idivX */
147 COSTS_N_INSNS (1), /* movcc/movr */
148 0, /* shift penalty */
152 struct processor_costs ultrasparc_costs = {
153 COSTS_N_INSNS (2), /* int load */
154 COSTS_N_INSNS (3), /* int signed load */
155 COSTS_N_INSNS (2), /* int zeroed load */
156 COSTS_N_INSNS (2), /* float load */
157 COSTS_N_INSNS (1), /* fmov, fneg, fabs */
158 COSTS_N_INSNS (4), /* fadd, fsub */
159 COSTS_N_INSNS (1), /* fcmp */
160 COSTS_N_INSNS (2), /* fmov, fmovr */
161 COSTS_N_INSNS (4), /* fmul */
162 COSTS_N_INSNS (13), /* fdivs */
163 COSTS_N_INSNS (23), /* fdivd */
164 COSTS_N_INSNS (13), /* fsqrts */
165 COSTS_N_INSNS (23), /* fsqrtd */
166 COSTS_N_INSNS (4), /* imul */
167 COSTS_N_INSNS (4), /* imulX */
168 2, /* imul bit factor */
169 COSTS_N_INSNS (37), /* idiv */
170 COSTS_N_INSNS (68), /* idivX */
171 COSTS_N_INSNS (2), /* movcc/movr */
172 2, /* shift penalty */
176 struct processor_costs ultrasparc3_costs = {
177 COSTS_N_INSNS (2), /* int load */
178 COSTS_N_INSNS (3), /* int signed load */
179 COSTS_N_INSNS (3), /* int zeroed load */
180 COSTS_N_INSNS (2), /* float load */
181 COSTS_N_INSNS (3), /* fmov, fneg, fabs */
182 COSTS_N_INSNS (4), /* fadd, fsub */
183 COSTS_N_INSNS (5), /* fcmp */
184 COSTS_N_INSNS (3), /* fmov, fmovr */
185 COSTS_N_INSNS (4), /* fmul */
186 COSTS_N_INSNS (17), /* fdivs */
187 COSTS_N_INSNS (20), /* fdivd */
188 COSTS_N_INSNS (20), /* fsqrts */
189 COSTS_N_INSNS (29), /* fsqrtd */
190 COSTS_N_INSNS (6), /* imul */
191 COSTS_N_INSNS (6), /* imulX */
192 0, /* imul bit factor */
193 COSTS_N_INSNS (40), /* idiv */
194 COSTS_N_INSNS (71), /* idivX */
195 COSTS_N_INSNS (2), /* movcc/movr */
196 0, /* shift penalty */
199 const struct processor_costs *sparc_costs = &cypress_costs;
201 #ifdef HAVE_AS_RELAX_OPTION
202 /* If 'as' and 'ld' are relaxing tail call insns into branch always, use
203 "or %o7,%g0,X; call Y; or X,%g0,%o7" always, so that it can be optimized.
204 With sethi/jmp, neither 'as' nor 'ld' has an easy way how to find out if
205 somebody does not branch between the sethi and jmp. */
206 #define LEAF_SIBCALL_SLOT_RESERVED_P 1
208 #define LEAF_SIBCALL_SLOT_RESERVED_P \
209 ((TARGET_ARCH64 && !TARGET_CM_MEDLOW) || flag_pic)
212 /* Global variables for machine-dependent things. */
214 /* Size of frame. Need to know this to emit return insns from leaf procedures.
215 ACTUAL_FSIZE is set by sparc_compute_frame_size() which is called during the
216 reload pass. This is important as the value is later used for scheduling
217 (to see what can go in a delay slot).
218 APPARENT_FSIZE is the size of the stack less the register save area and less
219 the outgoing argument area. It is used when saving call preserved regs. */
220 static HOST_WIDE_INT apparent_fsize;
221 static HOST_WIDE_INT actual_fsize;
223 /* Number of live general or floating point registers needed to be
224 saved (as 4-byte quantities). */
225 static int num_gfregs;
227 /* The alias set for prologue/epilogue register save/restore. */
228 static GTY(()) int sparc_sr_alias_set;
230 /* The alias set for the structure return value. */
231 static GTY(()) int struct_value_alias_set;
233 /* Save the operands last given to a compare for use when we
234 generate a scc or bcc insn. */
235 rtx sparc_compare_op0, sparc_compare_op1;
237 /* Vector to say how input registers are mapped to output registers.
238 HARD_FRAME_POINTER_REGNUM cannot be remapped by this function to
239 eliminate it. You must use -fomit-frame-pointer to get that. */
240 char leaf_reg_remap[] =
241 { 0, 1, 2, 3, 4, 5, 6, 7,
242 -1, -1, -1, -1, -1, -1, 14, -1,
243 -1, -1, -1, -1, -1, -1, -1, -1,
244 8, 9, 10, 11, 12, 13, -1, 15,
246 32, 33, 34, 35, 36, 37, 38, 39,
247 40, 41, 42, 43, 44, 45, 46, 47,
248 48, 49, 50, 51, 52, 53, 54, 55,
249 56, 57, 58, 59, 60, 61, 62, 63,
250 64, 65, 66, 67, 68, 69, 70, 71,
251 72, 73, 74, 75, 76, 77, 78, 79,
252 80, 81, 82, 83, 84, 85, 86, 87,
253 88, 89, 90, 91, 92, 93, 94, 95,
254 96, 97, 98, 99, 100};
256 /* Vector, indexed by hard register number, which contains 1
257 for a register that is allowable in a candidate for leaf
258 function treatment. */
259 char sparc_leaf_regs[] =
260 { 1, 1, 1, 1, 1, 1, 1, 1,
261 0, 0, 0, 0, 0, 0, 1, 0,
262 0, 0, 0, 0, 0, 0, 0, 0,
263 1, 1, 1, 1, 1, 1, 0, 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, 1, 1, 1,
268 1, 1, 1, 1, 1, 1, 1, 1,
269 1, 1, 1, 1, 1, 1, 1, 1,
270 1, 1, 1, 1, 1, 1, 1, 1,
271 1, 1, 1, 1, 1, 1, 1, 1,
274 struct machine_function GTY(())
276 /* Some local-dynamic TLS symbol name. */
277 const char *some_ld_name;
279 /* True if the current function is leaf and uses only leaf regs,
280 so that the SPARC leaf function optimization can be applied.
281 Private version of current_function_uses_only_leaf_regs, see
282 sparc_expand_prologue for the rationale. */
285 /* True if the data calculated by sparc_expand_prologue are valid. */
286 bool prologue_data_valid_p;
289 #define sparc_leaf_function_p cfun->machine->leaf_function_p
290 #define sparc_prologue_data_valid_p cfun->machine->prologue_data_valid_p
292 /* Register we pretend to think the frame pointer is allocated to.
293 Normally, this is %fp, but if we are in a leaf procedure, this
294 is %sp+"something". We record "something" separately as it may
295 be too big for reg+constant addressing. */
296 static rtx frame_base_reg;
297 static HOST_WIDE_INT frame_base_offset;
299 /* 1 if the next opcode is to be specially indented. */
300 int sparc_indent_opcode = 0;
302 static void sparc_init_modes (void);
303 static void scan_record_type (tree, int *, int *, int *);
304 static int function_arg_slotno (const CUMULATIVE_ARGS *, enum machine_mode,
305 tree, int, int, int *, int *);
307 static int supersparc_adjust_cost (rtx, rtx, rtx, int);
308 static int hypersparc_adjust_cost (rtx, rtx, rtx, int);
310 static void sparc_output_addr_vec (rtx);
311 static void sparc_output_addr_diff_vec (rtx);
312 static void sparc_output_deferred_case_vectors (void);
313 static rtx sparc_builtin_saveregs (void);
314 static int epilogue_renumber (rtx *, int);
315 static bool sparc_assemble_integer (rtx, unsigned int, int);
316 static int set_extends (rtx);
317 static void emit_pic_helper (void);
318 static void load_pic_register (bool);
319 static int save_or_restore_regs (int, int, rtx, int, int);
320 static void emit_save_regs (void);
321 static void emit_restore_regs (void);
322 static void sparc_asm_function_prologue (FILE *, HOST_WIDE_INT);
323 static void sparc_asm_function_epilogue (FILE *, HOST_WIDE_INT);
324 #ifdef OBJECT_FORMAT_ELF
325 static void sparc_elf_asm_named_section (const char *, unsigned int, tree);
328 static int sparc_adjust_cost (rtx, rtx, rtx, int);
329 static int sparc_issue_rate (void);
330 static void sparc_sched_init (FILE *, int, int);
331 static int sparc_use_sched_lookahead (void);
333 static void emit_soft_tfmode_libcall (const char *, int, rtx *);
334 static void emit_soft_tfmode_binop (enum rtx_code, rtx *);
335 static void emit_soft_tfmode_unop (enum rtx_code, rtx *);
336 static void emit_soft_tfmode_cvt (enum rtx_code, rtx *);
337 static void emit_hard_tfmode_operation (enum rtx_code, rtx *);
339 static bool sparc_function_ok_for_sibcall (tree, tree);
340 static void sparc_init_libfuncs (void);
341 static void sparc_init_builtins (void);
342 static void sparc_vis_init_builtins (void);
343 static rtx sparc_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
344 static void sparc_output_mi_thunk (FILE *, tree, HOST_WIDE_INT,
345 HOST_WIDE_INT, tree);
346 static bool sparc_can_output_mi_thunk (tree, HOST_WIDE_INT,
347 HOST_WIDE_INT, tree);
348 static struct machine_function * sparc_init_machine_status (void);
349 static bool sparc_cannot_force_const_mem (rtx);
350 static rtx sparc_tls_get_addr (void);
351 static rtx sparc_tls_got (void);
352 static const char *get_some_local_dynamic_name (void);
353 static int get_some_local_dynamic_name_1 (rtx *, void *);
354 static bool sparc_rtx_costs (rtx, int, int, int *);
355 static bool sparc_promote_prototypes (tree);
356 static rtx sparc_struct_value_rtx (tree, int);
357 static bool sparc_return_in_memory (tree, tree);
358 static bool sparc_strict_argument_naming (CUMULATIVE_ARGS *);
359 static tree sparc_gimplify_va_arg (tree, tree, tree *, tree *);
360 static bool sparc_vector_mode_supported_p (enum machine_mode);
361 static bool sparc_pass_by_reference (CUMULATIVE_ARGS *,
362 enum machine_mode, tree, bool);
363 static int sparc_arg_partial_bytes (CUMULATIVE_ARGS *,
364 enum machine_mode, tree, bool);
365 static void sparc_dwarf_handle_frame_unspec (const char *, rtx, int);
366 static void sparc_file_end (void);
367 #ifdef SUBTARGET_ATTRIBUTE_TABLE
368 const struct attribute_spec sparc_attribute_table[];
371 /* Option handling. */
373 /* Code model option as passed by user. */
374 const char *sparc_cmodel_string;
376 enum cmodel sparc_cmodel;
378 char sparc_hard_reg_printed[8];
380 struct sparc_cpu_select sparc_select[] =
382 /* switch name, tune arch */
383 { (char *)0, "default", 1, 1 },
384 { (char *)0, "-mcpu=", 1, 1 },
385 { (char *)0, "-mtune=", 1, 0 },
389 /* CPU type. This is set from TARGET_CPU_DEFAULT and -m{cpu,tune}=xxx. */
390 enum processor_type sparc_cpu;
392 /* Initialize the GCC target structure. */
394 /* The sparc default is to use .half rather than .short for aligned
395 HI objects. Use .word instead of .long on non-ELF systems. */
396 #undef TARGET_ASM_ALIGNED_HI_OP
397 #define TARGET_ASM_ALIGNED_HI_OP "\t.half\t"
398 #ifndef OBJECT_FORMAT_ELF
399 #undef TARGET_ASM_ALIGNED_SI_OP
400 #define TARGET_ASM_ALIGNED_SI_OP "\t.word\t"
403 #undef TARGET_ASM_UNALIGNED_HI_OP
404 #define TARGET_ASM_UNALIGNED_HI_OP "\t.uahalf\t"
405 #undef TARGET_ASM_UNALIGNED_SI_OP
406 #define TARGET_ASM_UNALIGNED_SI_OP "\t.uaword\t"
407 #undef TARGET_ASM_UNALIGNED_DI_OP
408 #define TARGET_ASM_UNALIGNED_DI_OP "\t.uaxword\t"
410 /* The target hook has to handle DI-mode values. */
411 #undef TARGET_ASM_INTEGER
412 #define TARGET_ASM_INTEGER sparc_assemble_integer
414 #undef TARGET_ASM_FUNCTION_PROLOGUE
415 #define TARGET_ASM_FUNCTION_PROLOGUE sparc_asm_function_prologue
416 #undef TARGET_ASM_FUNCTION_EPILOGUE
417 #define TARGET_ASM_FUNCTION_EPILOGUE sparc_asm_function_epilogue
419 #undef TARGET_SCHED_ADJUST_COST
420 #define TARGET_SCHED_ADJUST_COST sparc_adjust_cost
421 #undef TARGET_SCHED_ISSUE_RATE
422 #define TARGET_SCHED_ISSUE_RATE sparc_issue_rate
423 #undef TARGET_SCHED_INIT
424 #define TARGET_SCHED_INIT sparc_sched_init
425 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
426 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD sparc_use_sched_lookahead
428 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
429 #define TARGET_FUNCTION_OK_FOR_SIBCALL sparc_function_ok_for_sibcall
431 #undef TARGET_INIT_LIBFUNCS
432 #define TARGET_INIT_LIBFUNCS sparc_init_libfuncs
433 #undef TARGET_INIT_BUILTINS
434 #define TARGET_INIT_BUILTINS sparc_init_builtins
436 #undef TARGET_EXPAND_BUILTIN
437 #define TARGET_EXPAND_BUILTIN sparc_expand_builtin
440 #undef TARGET_HAVE_TLS
441 #define TARGET_HAVE_TLS true
443 #undef TARGET_CANNOT_FORCE_CONST_MEM
444 #define TARGET_CANNOT_FORCE_CONST_MEM sparc_cannot_force_const_mem
446 #undef TARGET_ASM_OUTPUT_MI_THUNK
447 #define TARGET_ASM_OUTPUT_MI_THUNK sparc_output_mi_thunk
448 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
449 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK sparc_can_output_mi_thunk
451 #undef TARGET_RTX_COSTS
452 #define TARGET_RTX_COSTS sparc_rtx_costs
453 #undef TARGET_ADDRESS_COST
454 #define TARGET_ADDRESS_COST hook_int_rtx_0
456 /* This is only needed for TARGET_ARCH64, but since PROMOTE_FUNCTION_MODE is a
457 no-op for TARGET_ARCH32 this is ok. Otherwise we'd need to add a runtime
458 test for this value. */
459 #undef TARGET_PROMOTE_FUNCTION_ARGS
460 #define TARGET_PROMOTE_FUNCTION_ARGS hook_bool_tree_true
462 /* This is only needed for TARGET_ARCH64, but since PROMOTE_FUNCTION_MODE is a
463 no-op for TARGET_ARCH32 this is ok. Otherwise we'd need to add a runtime
464 test for this value. */
465 #undef TARGET_PROMOTE_FUNCTION_RETURN
466 #define TARGET_PROMOTE_FUNCTION_RETURN hook_bool_tree_true
468 #undef TARGET_PROMOTE_PROTOTYPES
469 #define TARGET_PROMOTE_PROTOTYPES sparc_promote_prototypes
471 #undef TARGET_STRUCT_VALUE_RTX
472 #define TARGET_STRUCT_VALUE_RTX sparc_struct_value_rtx
473 #undef TARGET_RETURN_IN_MEMORY
474 #define TARGET_RETURN_IN_MEMORY sparc_return_in_memory
475 #undef TARGET_MUST_PASS_IN_STACK
476 #define TARGET_MUST_PASS_IN_STACK must_pass_in_stack_var_size
477 #undef TARGET_PASS_BY_REFERENCE
478 #define TARGET_PASS_BY_REFERENCE sparc_pass_by_reference
479 #undef TARGET_ARG_PARTIAL_BYTES
480 #define TARGET_ARG_PARTIAL_BYTES sparc_arg_partial_bytes
482 #undef TARGET_EXPAND_BUILTIN_SAVEREGS
483 #define TARGET_EXPAND_BUILTIN_SAVEREGS sparc_builtin_saveregs
484 #undef TARGET_STRICT_ARGUMENT_NAMING
485 #define TARGET_STRICT_ARGUMENT_NAMING sparc_strict_argument_naming
487 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
488 #define TARGET_GIMPLIFY_VA_ARG_EXPR sparc_gimplify_va_arg
490 #undef TARGET_VECTOR_MODE_SUPPORTED_P
491 #define TARGET_VECTOR_MODE_SUPPORTED_P sparc_vector_mode_supported_p
493 #undef TARGET_DWARF_HANDLE_FRAME_UNSPEC
494 #define TARGET_DWARF_HANDLE_FRAME_UNSPEC sparc_dwarf_handle_frame_unspec
496 #ifdef SUBTARGET_INSERT_ATTRIBUTES
497 #undef TARGET_INSERT_ATTRIBUTES
498 #define TARGET_INSERT_ATTRIBUTES SUBTARGET_INSERT_ATTRIBUTES
501 #ifdef SUBTARGET_ATTRIBUTE_TABLE
502 #undef TARGET_ATTRIBUTE_TABLE
503 #define TARGET_ATTRIBUTE_TABLE sparc_attribute_table
506 #undef TARGET_RELAXED_ORDERING
507 #define TARGET_RELAXED_ORDERING SPARC_RELAXED_ORDERING
509 #undef TARGET_ASM_FILE_END
510 #define TARGET_ASM_FILE_END sparc_file_end
512 struct gcc_target targetm = TARGET_INITIALIZER;
514 /* Validate and override various options, and do some machine dependent
518 sparc_override_options (void)
520 static struct code_model {
521 const char *const name;
523 } const cmodels[] = {
525 { "medlow", CM_MEDLOW },
526 { "medmid", CM_MEDMID },
527 { "medany", CM_MEDANY },
528 { "embmedany", CM_EMBMEDANY },
531 const struct code_model *cmodel;
532 /* Map TARGET_CPU_DEFAULT to value for -m{arch,tune}=. */
533 static struct cpu_default {
535 const char *const name;
536 } const cpu_default[] = {
537 /* There must be one entry here for each TARGET_CPU value. */
538 { TARGET_CPU_sparc, "cypress" },
539 { TARGET_CPU_sparclet, "tsc701" },
540 { TARGET_CPU_sparclite, "f930" },
541 { TARGET_CPU_v8, "v8" },
542 { TARGET_CPU_hypersparc, "hypersparc" },
543 { TARGET_CPU_sparclite86x, "sparclite86x" },
544 { TARGET_CPU_supersparc, "supersparc" },
545 { TARGET_CPU_v9, "v9" },
546 { TARGET_CPU_ultrasparc, "ultrasparc" },
547 { TARGET_CPU_ultrasparc3, "ultrasparc3" },
550 const struct cpu_default *def;
551 /* Table of values for -m{cpu,tune}=. */
552 static struct cpu_table {
553 const char *const name;
554 const enum processor_type processor;
557 } const cpu_table[] = {
558 { "v7", PROCESSOR_V7, MASK_ISA, 0 },
559 { "cypress", PROCESSOR_CYPRESS, MASK_ISA, 0 },
560 { "v8", PROCESSOR_V8, MASK_ISA, MASK_V8 },
561 /* TI TMS390Z55 supersparc */
562 { "supersparc", PROCESSOR_SUPERSPARC, MASK_ISA, MASK_V8 },
563 { "sparclite", PROCESSOR_SPARCLITE, MASK_ISA, MASK_SPARCLITE },
564 /* The Fujitsu MB86930 is the original sparclite chip, with no fpu.
565 The Fujitsu MB86934 is the recent sparclite chip, with an fpu. */
566 { "f930", PROCESSOR_F930, MASK_ISA|MASK_FPU, MASK_SPARCLITE },
567 { "f934", PROCESSOR_F934, MASK_ISA, MASK_SPARCLITE|MASK_FPU },
568 { "hypersparc", PROCESSOR_HYPERSPARC, MASK_ISA, MASK_V8|MASK_FPU },
569 { "sparclite86x", PROCESSOR_SPARCLITE86X, MASK_ISA|MASK_FPU,
571 { "sparclet", PROCESSOR_SPARCLET, MASK_ISA, MASK_SPARCLET },
573 { "tsc701", PROCESSOR_TSC701, MASK_ISA, MASK_SPARCLET },
574 { "v9", PROCESSOR_V9, MASK_ISA, MASK_V9 },
575 /* TI ultrasparc I, II, IIi */
576 { "ultrasparc", PROCESSOR_ULTRASPARC, MASK_ISA, MASK_V9
577 /* Although insns using %y are deprecated, it is a clear win on current
579 |MASK_DEPRECATED_V8_INSNS},
580 /* TI ultrasparc III */
581 /* ??? Check if %y issue still holds true in ultra3. */
582 { "ultrasparc3", PROCESSOR_ULTRASPARC3, MASK_ISA, MASK_V9|MASK_DEPRECATED_V8_INSNS},
585 const struct cpu_table *cpu;
586 const struct sparc_cpu_select *sel;
589 #ifndef SPARC_BI_ARCH
590 /* Check for unsupported architecture size. */
591 if (! TARGET_64BIT != DEFAULT_ARCH32_P)
592 error ("%s is not supported by this configuration",
593 DEFAULT_ARCH32_P ? "-m64" : "-m32");
596 /* We force all 64bit archs to use 128 bit long double */
597 if (TARGET_64BIT && ! TARGET_LONG_DOUBLE_128)
599 error ("-mlong-double-64 not allowed with -m64");
600 target_flags |= MASK_LONG_DOUBLE_128;
603 /* Code model selection. */
604 sparc_cmodel = SPARC_DEFAULT_CMODEL;
608 sparc_cmodel = CM_32;
611 if (sparc_cmodel_string != NULL)
615 for (cmodel = &cmodels[0]; cmodel->name; cmodel++)
616 if (strcmp (sparc_cmodel_string, cmodel->name) == 0)
618 if (cmodel->name == NULL)
619 error ("bad value (%s) for -mcmodel= switch", sparc_cmodel_string);
621 sparc_cmodel = cmodel->value;
624 error ("-mcmodel= is not supported on 32 bit systems");
627 fpu = TARGET_FPU; /* save current -mfpu status */
629 /* Set the default CPU. */
630 for (def = &cpu_default[0]; def->name; ++def)
631 if (def->cpu == TARGET_CPU_DEFAULT)
633 gcc_assert (def->name);
634 sparc_select[0].string = def->name;
636 for (sel = &sparc_select[0]; sel->name; ++sel)
640 for (cpu = &cpu_table[0]; cpu->name; ++cpu)
641 if (! strcmp (sel->string, cpu->name))
644 sparc_cpu = cpu->processor;
648 target_flags &= ~cpu->disable;
649 target_flags |= cpu->enable;
655 error ("bad value (%s) for %s switch", sel->string, sel->name);
659 /* If -mfpu or -mno-fpu was explicitly used, don't override with
660 the processor default. Clear MASK_FPU_SET to avoid confusing
661 the reverse mapping from switch values to names. */
664 target_flags = (target_flags & ~MASK_FPU) | fpu;
665 target_flags &= ~MASK_FPU_SET;
668 /* Don't allow -mvis if FPU is disabled. */
670 target_flags &= ~MASK_VIS;
672 /* -mvis assumes UltraSPARC+, so we are sure v9 instructions
674 -m64 also implies v9. */
675 if (TARGET_VIS || TARGET_ARCH64)
677 target_flags |= MASK_V9;
678 target_flags &= ~(MASK_V8 | MASK_SPARCLET | MASK_SPARCLITE);
681 /* Use the deprecated v8 insns for sparc64 in 32 bit mode. */
682 if (TARGET_V9 && TARGET_ARCH32)
683 target_flags |= MASK_DEPRECATED_V8_INSNS;
685 /* V8PLUS requires V9, makes no sense in 64 bit mode. */
686 if (! TARGET_V9 || TARGET_ARCH64)
687 target_flags &= ~MASK_V8PLUS;
689 /* Don't use stack biasing in 32 bit mode. */
691 target_flags &= ~MASK_STACK_BIAS;
693 /* Supply a default value for align_functions. */
694 if (align_functions == 0
695 && (sparc_cpu == PROCESSOR_ULTRASPARC
696 || sparc_cpu == PROCESSOR_ULTRASPARC3))
697 align_functions = 32;
699 /* Validate PCC_STRUCT_RETURN. */
700 if (flag_pcc_struct_return == DEFAULT_PCC_STRUCT_RETURN)
701 flag_pcc_struct_return = (TARGET_ARCH64 ? 0 : 1);
703 /* Only use .uaxword when compiling for a 64-bit target. */
705 targetm.asm_out.unaligned_op.di = NULL;
707 /* Do various machine dependent initializations. */
710 /* Acquire unique alias sets for our private stuff. */
711 sparc_sr_alias_set = new_alias_set ();
712 struct_value_alias_set = new_alias_set ();
714 /* Set up function hooks. */
715 init_machine_status = sparc_init_machine_status;
720 case PROCESSOR_CYPRESS:
721 sparc_costs = &cypress_costs;
724 case PROCESSOR_SPARCLITE:
725 case PROCESSOR_SUPERSPARC:
726 sparc_costs = &supersparc_costs;
730 case PROCESSOR_HYPERSPARC:
731 case PROCESSOR_SPARCLITE86X:
732 sparc_costs = &hypersparc_costs;
734 case PROCESSOR_SPARCLET:
735 case PROCESSOR_TSC701:
736 sparc_costs = &sparclet_costs;
739 case PROCESSOR_ULTRASPARC:
740 sparc_costs = &ultrasparc_costs;
742 case PROCESSOR_ULTRASPARC3:
743 sparc_costs = &ultrasparc3_costs;
748 #ifdef SUBTARGET_ATTRIBUTE_TABLE
749 /* Table of valid machine attributes. */
750 const struct attribute_spec sparc_attribute_table[] =
752 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
753 SUBTARGET_ATTRIBUTE_TABLE,
754 { NULL, 0, 0, false, false, false, NULL }
758 /* Miscellaneous utilities. */
760 /* Nonzero if CODE, a comparison, is suitable for use in v9 conditional move
761 or branch on register contents instructions. */
764 v9_regcmp_p (enum rtx_code code)
766 return (code == EQ || code == NE || code == GE || code == LT
767 || code == LE || code == GT);
771 /* Operand constraints. */
773 /* Return nonzero only if OP is a register of mode MODE,
777 reg_or_0_operand (rtx op, enum machine_mode mode)
779 if (register_operand (op, mode))
781 if (op == const0_rtx)
783 if (GET_MODE (op) == VOIDmode && GET_CODE (op) == CONST_DOUBLE
784 && CONST_DOUBLE_HIGH (op) == 0
785 && CONST_DOUBLE_LOW (op) == 0)
787 if (fp_zero_operand (op, mode))
792 /* Return nonzero only if OP is const1_rtx. */
795 const1_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
797 return op == const1_rtx;
800 /* Nonzero if OP is a floating point value with value 0.0. */
803 fp_zero_operand (rtx op, enum machine_mode mode)
805 enum mode_class mclass = GET_MODE_CLASS (GET_MODE (op));
806 if (mclass != MODE_FLOAT && mclass != MODE_VECTOR_INT)
808 return op == CONST0_RTX (mode);
811 /* Nonzero if OP is a register operand in floating point register. */
814 fp_register_operand (rtx op, enum machine_mode mode)
816 if (! register_operand (op, mode))
818 if (GET_CODE (op) == SUBREG)
819 op = SUBREG_REG (op);
820 return GET_CODE (op) == REG && SPARC_FP_REG_P (REGNO (op));
823 /* Nonzero if OP is a floating point constant which can
824 be loaded into an integer register using a single
825 sethi instruction. */
830 if (GET_CODE (op) == CONST_DOUBLE)
835 REAL_VALUE_FROM_CONST_DOUBLE (r, op);
836 if (REAL_VALUES_EQUAL (r, dconst0) &&
837 ! REAL_VALUE_MINUS_ZERO (r))
839 REAL_VALUE_TO_TARGET_SINGLE (r, i);
840 if (SPARC_SETHI_P (i))
847 /* Nonzero if OP is a floating point constant which can
848 be loaded into an integer register using a single
854 if (GET_CODE (op) == CONST_DOUBLE)
859 REAL_VALUE_FROM_CONST_DOUBLE (r, op);
860 if (REAL_VALUES_EQUAL (r, dconst0) &&
861 ! REAL_VALUE_MINUS_ZERO (r))
863 REAL_VALUE_TO_TARGET_SINGLE (r, i);
864 if (SPARC_SIMM13_P (i))
871 /* Nonzero if OP is a floating point constant which can
872 be loaded into an integer register using a high/losum
873 instruction sequence. */
876 fp_high_losum_p (rtx op)
878 /* The constraints calling this should only be in
879 SFmode move insns, so any constant which cannot
880 be moved using a single insn will do. */
881 if (GET_CODE (op) == CONST_DOUBLE)
886 REAL_VALUE_FROM_CONST_DOUBLE (r, op);
887 if (REAL_VALUES_EQUAL (r, dconst0) &&
888 ! REAL_VALUE_MINUS_ZERO (r))
890 REAL_VALUE_TO_TARGET_SINGLE (r, i);
891 if (! SPARC_SETHI_P (i)
892 && ! SPARC_SIMM13_P (i))
899 /* Nonzero if OP is an integer register. */
902 intreg_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
904 return (register_operand (op, SImode)
905 || (TARGET_ARCH64 && register_operand (op, DImode)));
908 /* Nonzero if OP is a floating point condition code register. */
911 fcc_reg_operand (rtx op, enum machine_mode mode)
913 /* This can happen when recog is called from combine. Op may be a MEM.
914 Fail instead of calling abort in this case. */
915 if (GET_CODE (op) != REG)
918 if (mode != VOIDmode && mode != GET_MODE (op))
921 && (GET_MODE (op) != CCFPmode && GET_MODE (op) != CCFPEmode))
924 #if 0 /* ??? ==> 1 when %fcc0-3 are pseudos first. See gen_compare_reg(). */
925 if (reg_renumber == 0)
926 return REGNO (op) >= FIRST_PSEUDO_REGISTER;
927 return REGNO_OK_FOR_CCFP_P (REGNO (op));
929 return (unsigned) REGNO (op) - SPARC_FIRST_V9_FCC_REG < 4;
933 /* Nonzero if OP is a floating point condition code fcc0 register. */
936 fcc0_reg_operand (rtx op, enum machine_mode mode)
938 /* This can happen when recog is called from combine. Op may be a MEM.
939 Fail instead of calling abort in this case. */
940 if (GET_CODE (op) != REG)
943 if (mode != VOIDmode && mode != GET_MODE (op))
946 && (GET_MODE (op) != CCFPmode && GET_MODE (op) != CCFPEmode))
949 return REGNO (op) == SPARC_FCC_REG;
952 /* Nonzero if OP is an integer or floating point condition code register. */
955 icc_or_fcc_reg_operand (rtx op, enum machine_mode mode)
957 if (GET_CODE (op) == REG && REGNO (op) == SPARC_ICC_REG)
959 if (mode != VOIDmode && mode != GET_MODE (op))
962 && GET_MODE (op) != CCmode && GET_MODE (op) != CCXmode)
967 return fcc_reg_operand (op, mode);
970 /* Call insn on SPARC can take a PC-relative constant address, or any regular
974 call_operand (rtx op, enum machine_mode mode)
976 gcc_assert (GET_CODE (op) == MEM);
978 return (symbolic_operand (op, mode) || memory_address_p (Pmode, op));
982 call_operand_address (rtx op, enum machine_mode mode)
984 return (symbolic_operand (op, mode) || memory_address_p (Pmode, op));
987 /* If OP is a SYMBOL_REF of a thread-local symbol, return its TLS mode,
988 otherwise return 0. */
991 tls_symbolic_operand (rtx op)
993 if (GET_CODE (op) != SYMBOL_REF)
995 return SYMBOL_REF_TLS_MODEL (op);
999 tgd_symbolic_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1001 return tls_symbolic_operand (op) == TLS_MODEL_GLOBAL_DYNAMIC;
1005 tld_symbolic_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1007 return tls_symbolic_operand (op) == TLS_MODEL_LOCAL_DYNAMIC;
1011 tie_symbolic_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1013 return tls_symbolic_operand (op) == TLS_MODEL_INITIAL_EXEC;
1017 tle_symbolic_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1019 return tls_symbolic_operand (op) == TLS_MODEL_LOCAL_EXEC;
1022 /* Returns 1 if OP is either a symbol reference or a sum of a symbol
1023 reference and a constant. */
1026 symbolic_operand (register rtx op, enum machine_mode mode)
1028 enum machine_mode omode = GET_MODE (op);
1030 if (omode != mode && omode != VOIDmode && mode != VOIDmode)
1033 switch (GET_CODE (op))
1036 return !SYMBOL_REF_TLS_MODEL (op);
1043 return (((GET_CODE (XEXP (op, 0)) == SYMBOL_REF
1044 && !SYMBOL_REF_TLS_MODEL (XEXP (op, 0)))
1045 || GET_CODE (XEXP (op, 0)) == LABEL_REF)
1046 && GET_CODE (XEXP (op, 1)) == CONST_INT);
1053 /* Return truth value of statement that OP is a symbolic memory
1054 operand of mode MODE. */
1057 symbolic_memory_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1059 if (GET_CODE (op) == SUBREG)
1060 op = SUBREG_REG (op);
1061 if (GET_CODE (op) != MEM)
1064 return ((GET_CODE (op) == SYMBOL_REF && !SYMBOL_REF_TLS_MODEL (op))
1065 || GET_CODE (op) == CONST || GET_CODE (op) == HIGH
1066 || GET_CODE (op) == LABEL_REF);
1069 /* Return truth value of statement that OP is a LABEL_REF of mode MODE. */
1072 label_ref_operand (rtx op, enum machine_mode mode)
1074 if (GET_CODE (op) != LABEL_REF)
1076 if (GET_MODE (op) != mode)
1081 /* Return 1 if the operand is an argument used in generating pic references
1082 in either the medium/low or medium/anywhere code models of sparc64. */
1085 sp64_medium_pic_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1087 /* Check for (const (minus (symbol_ref:GOT)
1088 (const (minus (label) (pc))))). */
1089 if (GET_CODE (op) != CONST)
1092 if (GET_CODE (op) != MINUS)
1094 if (GET_CODE (XEXP (op, 0)) != SYMBOL_REF)
1096 /* ??? Ensure symbol is GOT. */
1097 if (GET_CODE (XEXP (op, 1)) != CONST)
1099 if (GET_CODE (XEXP (XEXP (op, 1), 0)) != MINUS)
1104 /* Return 1 if the operand is a data segment reference. This includes
1105 the readonly data segment, or in other words anything but the text segment.
1106 This is needed in the medium/anywhere code model on v9. These values
1107 are accessed with EMBMEDANY_BASE_REG. */
1110 data_segment_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1112 switch (GET_CODE (op))
1115 return ! SYMBOL_REF_FUNCTION_P (op);
1117 /* Assume canonical format of symbol + constant.
1120 return data_segment_operand (XEXP (op, 0), VOIDmode);
1126 /* Return 1 if the operand is a text segment reference.
1127 This is needed in the medium/anywhere code model on v9. */
1130 text_segment_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1132 switch (GET_CODE (op))
1137 return SYMBOL_REF_FUNCTION_P (op);
1139 /* Assume canonical format of symbol + constant.
1142 return text_segment_operand (XEXP (op, 0), VOIDmode);
1148 /* Return 1 if the operand is either a register or a memory operand that is
1152 reg_or_nonsymb_mem_operand (register rtx op, enum machine_mode mode)
1154 if (register_operand (op, mode))
1157 if (memory_operand (op, mode) && ! symbolic_memory_operand (op, mode))
1164 splittable_symbolic_memory_operand (rtx op,
1165 enum machine_mode mode ATTRIBUTE_UNUSED)
1167 if (GET_CODE (op) != MEM)
1169 if (! symbolic_operand (XEXP (op, 0), Pmode))
1175 splittable_immediate_memory_operand (rtx op,
1176 enum machine_mode mode ATTRIBUTE_UNUSED)
1178 if (GET_CODE (op) != MEM)
1180 if (! immediate_operand (XEXP (op, 0), Pmode))
1185 /* Return truth value of whether OP is EQ or NE. */
1188 eq_or_neq (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1190 return (GET_CODE (op) == EQ || GET_CODE (op) == NE);
1193 /* Return 1 if this is a comparison operator, but not an EQ, NE, GEU,
1194 or LTU for non-floating-point. We handle those specially. */
1197 normal_comp_operator (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1201 if (!COMPARISON_P (op))
1204 if (GET_MODE (XEXP (op, 0)) == CCFPmode
1205 || GET_MODE (XEXP (op, 0)) == CCFPEmode)
1208 code = GET_CODE (op);
1209 return (code != NE && code != EQ && code != GEU && code != LTU);
1212 /* Return 1 if this is a comparison operator. This allows the use of
1213 MATCH_OPERATOR to recognize all the branch insns. */
1216 noov_compare_op (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1220 if (!COMPARISON_P (op))
1223 code = GET_CODE (op);
1224 if (GET_MODE (XEXP (op, 0)) == CC_NOOVmode
1225 || GET_MODE (XEXP (op, 0)) == CCX_NOOVmode)
1226 /* These are the only branches which work with CC_NOOVmode. */
1227 return (code == EQ || code == NE || code == GE || code == LT);
1231 /* Return 1 if this is a 64-bit comparison operator. This allows the use of
1232 MATCH_OPERATOR to recognize all the branch insns. */
1235 noov_compare64_op (register rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1242 if (!COMPARISON_P (op))
1245 code = GET_CODE (op);
1246 if (GET_MODE (XEXP (op, 0)) == CCX_NOOVmode)
1247 /* These are the only branches which work with CCX_NOOVmode. */
1248 return (code == EQ || code == NE || code == GE || code == LT);
1249 return (GET_MODE (XEXP (op, 0)) == CCXmode);
1252 /* Nonzero if OP is a comparison operator suitable for use in v9
1253 conditional move or branch on register contents instructions. */
1256 v9_regcmp_op (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1260 if (!COMPARISON_P (op))
1263 code = GET_CODE (op);
1264 return v9_regcmp_p (code);
1267 /* Return 1 if this is a SIGN_EXTEND or ZERO_EXTEND operation. */
1270 extend_op (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1272 return GET_CODE (op) == SIGN_EXTEND || GET_CODE (op) == ZERO_EXTEND;
1275 /* Return nonzero if OP is an operator of mode MODE which can set
1276 the condition codes explicitly. We do not include PLUS and MINUS
1277 because these require CC_NOOVmode, which we handle explicitly. */
1280 cc_arithop (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1282 if (GET_CODE (op) == AND
1283 || GET_CODE (op) == IOR
1284 || GET_CODE (op) == XOR)
1290 /* Return nonzero if OP is an operator of mode MODE which can bitwise
1291 complement its second operand and set the condition codes explicitly. */
1294 cc_arithopn (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1296 /* XOR is not here because combine canonicalizes (xor (not ...) ...)
1297 and (xor ... (not ...)) to (not (xor ...)). */
1298 return (GET_CODE (op) == AND
1299 || GET_CODE (op) == IOR);
1302 /* Return true if OP is a register, or is a CONST_INT that can fit in a
1303 signed 13 bit immediate field. This is an acceptable SImode operand for
1304 most 3 address instructions. */
1307 arith_operand (rtx op, enum machine_mode mode)
1309 if (register_operand (op, mode))
1311 if (GET_CODE (op) != CONST_INT)
1313 return SMALL_INT32 (op);
1316 /* Return true if OP is a constant 4096 */
1319 arith_4096_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1321 if (GET_CODE (op) != CONST_INT)
1324 return INTVAL (op) == 4096;
1327 /* Return true if OP is suitable as second operand for add/sub */
1330 arith_add_operand (rtx op, enum machine_mode mode)
1332 return arith_operand (op, mode) || arith_4096_operand (op, mode);
1335 /* Return true if OP is a CONST_INT or a CONST_DOUBLE which can fit in the
1336 immediate field of OR and XOR instructions. Used for 64-bit
1337 constant formation patterns. */
1339 const64_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1341 return ((GET_CODE (op) == CONST_INT
1342 && SPARC_SIMM13_P (INTVAL (op)))
1343 #if HOST_BITS_PER_WIDE_INT != 64
1344 || (GET_CODE (op) == CONST_DOUBLE
1345 && SPARC_SIMM13_P (CONST_DOUBLE_LOW (op))
1346 && (CONST_DOUBLE_HIGH (op) ==
1347 ((CONST_DOUBLE_LOW (op) & 0x80000000) != 0 ?
1348 (HOST_WIDE_INT)-1 : 0)))
1353 /* The same, but only for sethi instructions. */
1355 const64_high_operand (rtx op, enum machine_mode mode)
1357 return ((GET_CODE (op) == CONST_INT
1358 && (INTVAL (op) & ~(HOST_WIDE_INT)0x3ff) != 0
1359 && SPARC_SETHI_P (INTVAL (op) & GET_MODE_MASK (mode))
1361 || (GET_CODE (op) == CONST_DOUBLE
1362 && CONST_DOUBLE_HIGH (op) == 0
1363 && (CONST_DOUBLE_LOW (op) & ~(HOST_WIDE_INT)0x3ff) != 0
1364 && SPARC_SETHI_P (CONST_DOUBLE_LOW (op))));
1367 /* Return true if OP is a register, or is a CONST_INT that can fit in a
1368 signed 11 bit immediate field. This is an acceptable SImode operand for
1369 the movcc instructions. */
1372 arith11_operand (rtx op, enum machine_mode mode)
1374 return (register_operand (op, mode)
1375 || (GET_CODE (op) == CONST_INT && SPARC_SIMM11_P (INTVAL (op))));
1378 /* Return true if OP is a register, or is a CONST_INT that can fit in a
1379 signed 10 bit immediate field. This is an acceptable SImode operand for
1380 the movrcc instructions. */
1383 arith10_operand (rtx op, enum machine_mode mode)
1385 return (register_operand (op, mode)
1386 || (GET_CODE (op) == CONST_INT && SPARC_SIMM10_P (INTVAL (op))));
1389 /* Return true if OP is a register, is a CONST_INT that fits in a 13 bit
1390 immediate field, or is a CONST_DOUBLE whose both parts fit in a 13 bit
1392 ARCH64: Return true if OP is a register, or is a CONST_INT or CONST_DOUBLE that
1393 can fit in a 13 bit immediate field. This is an acceptable DImode operand
1394 for most 3 address instructions. */
1397 arith_double_operand (rtx op, enum machine_mode mode)
1399 return (register_operand (op, mode)
1400 || (GET_CODE (op) == CONST_INT && SMALL_INT (op))
1402 && GET_CODE (op) == CONST_DOUBLE
1403 && (unsigned HOST_WIDE_INT) (CONST_DOUBLE_LOW (op) + 0x1000) < 0x2000
1404 && (unsigned HOST_WIDE_INT) (CONST_DOUBLE_HIGH (op) + 0x1000) < 0x2000)
1406 && GET_CODE (op) == CONST_DOUBLE
1407 && (unsigned HOST_WIDE_INT) (CONST_DOUBLE_LOW (op) + 0x1000) < 0x2000
1408 && ((CONST_DOUBLE_HIGH (op) == -1
1409 && (CONST_DOUBLE_LOW (op) & 0x1000) == 0x1000)
1410 || (CONST_DOUBLE_HIGH (op) == 0
1411 && (CONST_DOUBLE_LOW (op) & 0x1000) == 0))));
1414 /* Return true if OP is a constant 4096 for DImode on ARCH64 */
1417 arith_double_4096_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1419 return (TARGET_ARCH64 &&
1420 ((GET_CODE (op) == CONST_INT && INTVAL (op) == 4096) ||
1421 (GET_CODE (op) == CONST_DOUBLE &&
1422 CONST_DOUBLE_LOW (op) == 4096 &&
1423 CONST_DOUBLE_HIGH (op) == 0)));
1426 /* Return true if OP is suitable as second operand for add/sub in DImode */
1429 arith_double_add_operand (rtx op, enum machine_mode mode)
1431 return arith_double_operand (op, mode) || arith_double_4096_operand (op, mode);
1434 /* Return true if OP is a register, or is a CONST_INT or CONST_DOUBLE that
1435 can fit in an 11 bit immediate field. This is an acceptable DImode
1436 operand for the movcc instructions. */
1437 /* ??? Replace with arith11_operand? */
1440 arith11_double_operand (rtx op, enum machine_mode mode)
1442 return (register_operand (op, mode)
1443 || (GET_CODE (op) == CONST_DOUBLE
1444 && (GET_MODE (op) == mode || GET_MODE (op) == VOIDmode)
1445 && (unsigned HOST_WIDE_INT) (CONST_DOUBLE_LOW (op) + 0x400) < 0x800
1446 && ((CONST_DOUBLE_HIGH (op) == -1
1447 && (CONST_DOUBLE_LOW (op) & 0x400) == 0x400)
1448 || (CONST_DOUBLE_HIGH (op) == 0
1449 && (CONST_DOUBLE_LOW (op) & 0x400) == 0)))
1450 || (GET_CODE (op) == CONST_INT
1451 && (GET_MODE (op) == mode || GET_MODE (op) == VOIDmode)
1452 && (unsigned HOST_WIDE_INT) (INTVAL (op) + 0x400) < 0x800));
1455 /* Return true if OP is a register, or is a CONST_INT or CONST_DOUBLE that
1456 can fit in an 10 bit immediate field. This is an acceptable DImode
1457 operand for the movrcc instructions. */
1458 /* ??? Replace with arith10_operand? */
1461 arith10_double_operand (rtx op, enum machine_mode mode)
1463 return (register_operand (op, mode)
1464 || (GET_CODE (op) == CONST_DOUBLE
1465 && (GET_MODE (op) == mode || GET_MODE (op) == VOIDmode)
1466 && (unsigned) (CONST_DOUBLE_LOW (op) + 0x200) < 0x400
1467 && ((CONST_DOUBLE_HIGH (op) == -1
1468 && (CONST_DOUBLE_LOW (op) & 0x200) == 0x200)
1469 || (CONST_DOUBLE_HIGH (op) == 0
1470 && (CONST_DOUBLE_LOW (op) & 0x200) == 0)))
1471 || (GET_CODE (op) == CONST_INT
1472 && (GET_MODE (op) == mode || GET_MODE (op) == VOIDmode)
1473 && (unsigned HOST_WIDE_INT) (INTVAL (op) + 0x200) < 0x400));
1476 /* Return truth value of whether OP is an integer which fits the
1477 range constraining immediate operands in most three-address insns,
1478 which have a 13 bit immediate field. */
1481 small_int (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1483 return (GET_CODE (op) == CONST_INT && SMALL_INT (op));
1487 small_int_or_double (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1489 return ((GET_CODE (op) == CONST_INT && SMALL_INT (op))
1490 || (GET_CODE (op) == CONST_DOUBLE
1491 && CONST_DOUBLE_HIGH (op) == 0
1492 && SPARC_SIMM13_P (CONST_DOUBLE_LOW (op))));
1495 /* Recognize operand values for the umul instruction. That instruction sign
1496 extends immediate values just like all other sparc instructions, but
1497 interprets the extended result as an unsigned number. */
1500 uns_small_int (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1502 #if HOST_BITS_PER_WIDE_INT > 32
1503 /* All allowed constants will fit a CONST_INT. */
1504 return (GET_CODE (op) == CONST_INT
1505 && ((INTVAL (op) >= 0 && INTVAL (op) < 0x1000)
1506 || (INTVAL (op) >= 0xFFFFF000
1507 && INTVAL (op) <= 0xFFFFFFFF)));
1509 return ((GET_CODE (op) == CONST_INT && (unsigned) INTVAL (op) < 0x1000)
1510 || (GET_CODE (op) == CONST_DOUBLE
1511 && CONST_DOUBLE_HIGH (op) == 0
1512 && (unsigned) CONST_DOUBLE_LOW (op) - 0xFFFFF000 < 0x1000));
1517 uns_arith_operand (rtx op, enum machine_mode mode)
1519 return register_operand (op, mode) || uns_small_int (op, mode);
1522 /* Return truth value of statement that OP is a call-clobbered register. */
1524 clobbered_register (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1526 return (GET_CODE (op) == REG && call_used_regs[REGNO (op)]);
1529 /* Return 1 if OP is a valid operand for the source of a move insn. */
1532 input_operand (rtx op, enum machine_mode mode)
1534 enum mode_class mclass;
1536 /* If both modes are non-void they must be the same. */
1537 if (mode != VOIDmode && GET_MODE (op) != VOIDmode && mode != GET_MODE (op))
1540 /* Allow any one instruction integer constant, and all CONST_INT
1541 variants when we are working in DImode and !arch64. */
1542 if (GET_MODE_CLASS (mode) == MODE_INT
1543 && ((GET_CODE (op) == CONST_INT
1544 && (SPARC_SETHI_P (INTVAL (op) & GET_MODE_MASK (mode))
1545 || SPARC_SIMM13_P (INTVAL (op))
1547 && ! TARGET_ARCH64)))
1549 && GET_CODE (op) == CONST_DOUBLE
1550 && ((CONST_DOUBLE_HIGH (op) == 0
1551 && SPARC_SETHI_P (CONST_DOUBLE_LOW (op)))
1553 #if HOST_BITS_PER_WIDE_INT == 64
1554 (CONST_DOUBLE_HIGH (op) == 0
1555 && SPARC_SIMM13_P (CONST_DOUBLE_LOW (op)))
1557 (SPARC_SIMM13_P (CONST_DOUBLE_LOW (op))
1558 && (((CONST_DOUBLE_LOW (op) & 0x80000000) == 0
1559 && CONST_DOUBLE_HIGH (op) == 0)
1560 || (CONST_DOUBLE_HIGH (op) == -1
1561 && CONST_DOUBLE_LOW (op) & 0x80000000) != 0))
1566 /* If !arch64 and this is a DImode const, allow it so that
1567 the splits can be generated. */
1570 && GET_CODE (op) == CONST_DOUBLE)
1573 if (register_operand (op, mode))
1576 mclass = GET_MODE_CLASS (mode);
1577 if ((mclass == MODE_FLOAT && GET_CODE (op) == CONST_DOUBLE)
1578 || (mclass == MODE_VECTOR_INT && GET_CODE (op) == CONST_VECTOR))
1581 /* If this is a SUBREG, look inside so that we handle
1582 paradoxical ones. */
1583 if (GET_CODE (op) == SUBREG)
1584 op = SUBREG_REG (op);
1586 /* Check for valid MEM forms. */
1587 if (GET_CODE (op) == MEM)
1588 return memory_address_p (mode, XEXP (op, 0));
1593 /* Return 1 if OP is valid for the lhs of a compare insn. */
1596 compare_operand (rtx op, enum machine_mode mode)
1598 if (GET_CODE (op) == ZERO_EXTRACT)
1599 return (register_operand (XEXP (op, 0), mode)
1600 && small_int_or_double (XEXP (op, 1), mode)
1601 && small_int_or_double (XEXP (op, 2), mode)
1602 /* This matches cmp_zero_extract. */
1604 && ((GET_CODE (XEXP (op, 2)) == CONST_INT
1605 && INTVAL (XEXP (op, 2)) > 19)
1606 || (GET_CODE (XEXP (op, 2)) == CONST_DOUBLE
1607 && CONST_DOUBLE_LOW (XEXP (op, 2)) > 19)))
1608 /* This matches cmp_zero_extract_sp64. */
1611 && ((GET_CODE (XEXP (op, 2)) == CONST_INT
1612 && INTVAL (XEXP (op, 2)) > 51)
1613 || (GET_CODE (XEXP (op, 2)) == CONST_DOUBLE
1614 && CONST_DOUBLE_LOW (XEXP (op, 2)) > 51)))));
1616 return register_operand (op, mode);
1620 /* We know it can't be done in one insn when we get here,
1621 the movsi expander guarantees this. */
1623 sparc_emit_set_const32 (rtx op0, rtx op1)
1625 enum machine_mode mode = GET_MODE (op0);
1628 if (GET_CODE (op1) == CONST_INT)
1630 HOST_WIDE_INT value = INTVAL (op1);
1632 gcc_assert (! SPARC_SETHI_P (value & GET_MODE_MASK (mode))
1633 && ! SPARC_SIMM13_P (value));
1636 /* Full 2-insn decomposition is needed. */
1637 if (reload_in_progress || reload_completed)
1640 temp = gen_reg_rtx (mode);
1642 if (GET_CODE (op1) == CONST_INT)
1644 /* Emit them as real moves instead of a HIGH/LO_SUM,
1645 this way CSE can see everything and reuse intermediate
1646 values if it wants. */
1648 && HOST_BITS_PER_WIDE_INT != 64
1649 && (INTVAL (op1) & 0x80000000) != 0)
1650 emit_insn (gen_rtx_SET
1652 immed_double_const (INTVAL (op1) & ~(HOST_WIDE_INT)0x3ff,
1655 emit_insn (gen_rtx_SET (VOIDmode, temp,
1656 GEN_INT (INTVAL (op1)
1657 & ~(HOST_WIDE_INT)0x3ff)));
1659 emit_insn (gen_rtx_SET (VOIDmode,
1661 gen_rtx_IOR (mode, temp,
1662 GEN_INT (INTVAL (op1) & 0x3ff))));
1666 /* A symbol, emit in the traditional way. */
1667 emit_insn (gen_rtx_SET (VOIDmode, temp,
1668 gen_rtx_HIGH (mode, op1)));
1669 emit_insn (gen_rtx_SET (VOIDmode,
1670 op0, gen_rtx_LO_SUM (mode, temp, op1)));
1676 /* Load OP1, a symbolic 64-bit constant, into OP0, a DImode register.
1677 If TEMP is nonzero, we are forbidden to use any other scratch
1678 registers. Otherwise, we are allowed to generate them as needed.
1680 Note that TEMP may have TImode if the code model is TARGET_CM_MEDANY
1681 or TARGET_CM_EMBMEDANY (see the reload_indi and reload_outdi patterns). */
1683 sparc_emit_set_symbolic_const64 (rtx op0, rtx op1, rtx temp)
1685 rtx temp1, temp2, temp3, temp4, temp5;
1688 if (temp && GET_MODE (temp) == TImode)
1691 temp = gen_rtx_REG (DImode, REGNO (temp));
1694 /* SPARC-V9 code-model support. */
1695 switch (sparc_cmodel)
1698 /* The range spanned by all instructions in the object is less
1699 than 2^31 bytes (2GB) and the distance from any instruction
1700 to the location of the label _GLOBAL_OFFSET_TABLE_ is less
1701 than 2^31 bytes (2GB).
1703 The executable must be in the low 4TB of the virtual address
1706 sethi %hi(symbol), %temp1
1707 or %temp1, %lo(symbol), %reg */
1709 temp1 = temp; /* op0 is allowed. */
1711 temp1 = gen_reg_rtx (DImode);
1713 emit_insn (gen_rtx_SET (VOIDmode, temp1, gen_rtx_HIGH (DImode, op1)));
1714 emit_insn (gen_rtx_SET (VOIDmode, op0, gen_rtx_LO_SUM (DImode, temp1, op1)));
1718 /* The range spanned by all instructions in the object is less
1719 than 2^31 bytes (2GB) and the distance from any instruction
1720 to the location of the label _GLOBAL_OFFSET_TABLE_ is less
1721 than 2^31 bytes (2GB).
1723 The executable must be in the low 16TB of the virtual address
1726 sethi %h44(symbol), %temp1
1727 or %temp1, %m44(symbol), %temp2
1728 sllx %temp2, 12, %temp3
1729 or %temp3, %l44(symbol), %reg */
1734 temp3 = temp; /* op0 is allowed. */
1738 temp1 = gen_reg_rtx (DImode);
1739 temp2 = gen_reg_rtx (DImode);
1740 temp3 = gen_reg_rtx (DImode);
1743 emit_insn (gen_seth44 (temp1, op1));
1744 emit_insn (gen_setm44 (temp2, temp1, op1));
1745 emit_insn (gen_rtx_SET (VOIDmode, temp3,
1746 gen_rtx_ASHIFT (DImode, temp2, GEN_INT (12))));
1747 emit_insn (gen_setl44 (op0, temp3, op1));
1751 /* The range spanned by all instructions in the object is less
1752 than 2^31 bytes (2GB) and the distance from any instruction
1753 to the location of the label _GLOBAL_OFFSET_TABLE_ is less
1754 than 2^31 bytes (2GB).
1756 The executable can be placed anywhere in the virtual address
1759 sethi %hh(symbol), %temp1
1760 sethi %lm(symbol), %temp2
1761 or %temp1, %hm(symbol), %temp3
1762 sllx %temp3, 32, %temp4
1763 or %temp4, %temp2, %temp5
1764 or %temp5, %lo(symbol), %reg */
1767 /* It is possible that one of the registers we got for operands[2]
1768 might coincide with that of operands[0] (which is why we made
1769 it TImode). Pick the other one to use as our scratch. */
1770 if (rtx_equal_p (temp, op0))
1772 gcc_assert (ti_temp);
1773 temp = gen_rtx_REG (DImode, REGNO (temp) + 1);
1776 temp2 = temp; /* op0 is _not_ allowed, see above. */
1783 temp1 = gen_reg_rtx (DImode);
1784 temp2 = gen_reg_rtx (DImode);
1785 temp3 = gen_reg_rtx (DImode);
1786 temp4 = gen_reg_rtx (DImode);
1787 temp5 = gen_reg_rtx (DImode);
1790 emit_insn (gen_sethh (temp1, op1));
1791 emit_insn (gen_setlm (temp2, op1));
1792 emit_insn (gen_sethm (temp3, temp1, op1));
1793 emit_insn (gen_rtx_SET (VOIDmode, temp4,
1794 gen_rtx_ASHIFT (DImode, temp3, GEN_INT (32))));
1795 emit_insn (gen_rtx_SET (VOIDmode, temp5,
1796 gen_rtx_PLUS (DImode, temp4, temp2)));
1797 emit_insn (gen_setlo (op0, temp5, op1));
1801 /* Old old old backwards compatibility kruft here.
1802 Essentially it is MEDLOW with a fixed 64-bit
1803 virtual base added to all data segment addresses.
1804 Text-segment stuff is computed like MEDANY, we can't
1805 reuse the code above because the relocation knobs
1808 Data segment: sethi %hi(symbol), %temp1
1809 add %temp1, EMBMEDANY_BASE_REG, %temp2
1810 or %temp2, %lo(symbol), %reg */
1811 if (data_segment_operand (op1, GET_MODE (op1)))
1815 temp1 = temp; /* op0 is allowed. */
1820 temp1 = gen_reg_rtx (DImode);
1821 temp2 = gen_reg_rtx (DImode);
1824 emit_insn (gen_embmedany_sethi (temp1, op1));
1825 emit_insn (gen_embmedany_brsum (temp2, temp1));
1826 emit_insn (gen_embmedany_losum (op0, temp2, op1));
1829 /* Text segment: sethi %uhi(symbol), %temp1
1830 sethi %hi(symbol), %temp2
1831 or %temp1, %ulo(symbol), %temp3
1832 sllx %temp3, 32, %temp4
1833 or %temp4, %temp2, %temp5
1834 or %temp5, %lo(symbol), %reg */
1839 /* It is possible that one of the registers we got for operands[2]
1840 might coincide with that of operands[0] (which is why we made
1841 it TImode). Pick the other one to use as our scratch. */
1842 if (rtx_equal_p (temp, op0))
1844 gcc_assert (ti_temp);
1845 temp = gen_rtx_REG (DImode, REGNO (temp) + 1);
1848 temp2 = temp; /* op0 is _not_ allowed, see above. */
1855 temp1 = gen_reg_rtx (DImode);
1856 temp2 = gen_reg_rtx (DImode);
1857 temp3 = gen_reg_rtx (DImode);
1858 temp4 = gen_reg_rtx (DImode);
1859 temp5 = gen_reg_rtx (DImode);
1862 emit_insn (gen_embmedany_textuhi (temp1, op1));
1863 emit_insn (gen_embmedany_texthi (temp2, op1));
1864 emit_insn (gen_embmedany_textulo (temp3, temp1, op1));
1865 emit_insn (gen_rtx_SET (VOIDmode, temp4,
1866 gen_rtx_ASHIFT (DImode, temp3, GEN_INT (32))));
1867 emit_insn (gen_rtx_SET (VOIDmode, temp5,
1868 gen_rtx_PLUS (DImode, temp4, temp2)));
1869 emit_insn (gen_embmedany_textlo (op0, temp5, op1));
1878 /* These avoid problems when cross compiling. If we do not
1879 go through all this hair then the optimizer will see
1880 invalid REG_EQUAL notes or in some cases none at all. */
1881 static void sparc_emit_set_safe_HIGH64 (rtx, HOST_WIDE_INT);
1882 static rtx gen_safe_SET64 (rtx, HOST_WIDE_INT);
1883 static rtx gen_safe_OR64 (rtx, HOST_WIDE_INT);
1884 static rtx gen_safe_XOR64 (rtx, HOST_WIDE_INT);
1886 #if HOST_BITS_PER_WIDE_INT == 64
1887 #define GEN_HIGHINT64(__x) GEN_INT ((__x) & ~(HOST_WIDE_INT)0x3ff)
1888 #define GEN_INT64(__x) GEN_INT (__x)
1890 #define GEN_HIGHINT64(__x) \
1891 immed_double_const ((__x) & ~(HOST_WIDE_INT)0x3ff, 0, DImode)
1892 #define GEN_INT64(__x) \
1893 immed_double_const ((__x) & 0xffffffff, \
1894 ((__x) & 0x80000000 ? -1 : 0), DImode)
1897 /* The optimizer is not to assume anything about exactly
1898 which bits are set for a HIGH, they are unspecified.
1899 Unfortunately this leads to many missed optimizations
1900 during CSE. We mask out the non-HIGH bits, and matches
1901 a plain movdi, to alleviate this problem. */
1903 sparc_emit_set_safe_HIGH64 (rtx dest, HOST_WIDE_INT val)
1905 emit_insn (gen_rtx_SET (VOIDmode, dest, GEN_HIGHINT64 (val)));
1909 gen_safe_SET64 (rtx dest, HOST_WIDE_INT val)
1911 return gen_rtx_SET (VOIDmode, dest, GEN_INT64 (val));
1915 gen_safe_OR64 (rtx src, HOST_WIDE_INT val)
1917 return gen_rtx_IOR (DImode, src, GEN_INT64 (val));
1921 gen_safe_XOR64 (rtx src, HOST_WIDE_INT val)
1923 return gen_rtx_XOR (DImode, src, GEN_INT64 (val));
1926 /* Worker routines for 64-bit constant formation on arch64.
1927 One of the key things to be doing in these emissions is
1928 to create as many temp REGs as possible. This makes it
1929 possible for half-built constants to be used later when
1930 such values are similar to something required later on.
1931 Without doing this, the optimizer cannot see such
1934 static void sparc_emit_set_const64_quick1 (rtx, rtx,
1935 unsigned HOST_WIDE_INT, int);
1938 sparc_emit_set_const64_quick1 (rtx op0, rtx temp,
1939 unsigned HOST_WIDE_INT low_bits, int is_neg)
1941 unsigned HOST_WIDE_INT high_bits;
1944 high_bits = (~low_bits) & 0xffffffff;
1946 high_bits = low_bits;
1948 sparc_emit_set_safe_HIGH64 (temp, high_bits);
1951 emit_insn (gen_rtx_SET (VOIDmode, op0,
1952 gen_safe_OR64 (temp, (high_bits & 0x3ff))));
1956 /* If we are XOR'ing with -1, then we should emit a one's complement
1957 instead. This way the combiner will notice logical operations
1958 such as ANDN later on and substitute. */
1959 if ((low_bits & 0x3ff) == 0x3ff)
1961 emit_insn (gen_rtx_SET (VOIDmode, op0,
1962 gen_rtx_NOT (DImode, temp)));
1966 emit_insn (gen_rtx_SET (VOIDmode, op0,
1967 gen_safe_XOR64 (temp,
1968 (-(HOST_WIDE_INT)0x400
1969 | (low_bits & 0x3ff)))));
1974 static void sparc_emit_set_const64_quick2 (rtx, rtx, unsigned HOST_WIDE_INT,
1975 unsigned HOST_WIDE_INT, int);
1978 sparc_emit_set_const64_quick2 (rtx op0, rtx temp,
1979 unsigned HOST_WIDE_INT high_bits,
1980 unsigned HOST_WIDE_INT low_immediate,
1985 if ((high_bits & 0xfffffc00) != 0)
1987 sparc_emit_set_safe_HIGH64 (temp, high_bits);
1988 if ((high_bits & ~0xfffffc00) != 0)
1989 emit_insn (gen_rtx_SET (VOIDmode, op0,
1990 gen_safe_OR64 (temp, (high_bits & 0x3ff))));
1996 emit_insn (gen_safe_SET64 (temp, high_bits));
2000 /* Now shift it up into place. */
2001 emit_insn (gen_rtx_SET (VOIDmode, op0,
2002 gen_rtx_ASHIFT (DImode, temp2,
2003 GEN_INT (shift_count))));
2005 /* If there is a low immediate part piece, finish up by
2006 putting that in as well. */
2007 if (low_immediate != 0)
2008 emit_insn (gen_rtx_SET (VOIDmode, op0,
2009 gen_safe_OR64 (op0, low_immediate)));
2012 static void sparc_emit_set_const64_longway (rtx, rtx, unsigned HOST_WIDE_INT,
2013 unsigned HOST_WIDE_INT);
2015 /* Full 64-bit constant decomposition. Even though this is the
2016 'worst' case, we still optimize a few things away. */
2018 sparc_emit_set_const64_longway (rtx op0, rtx temp,
2019 unsigned HOST_WIDE_INT high_bits,
2020 unsigned HOST_WIDE_INT low_bits)
2024 if (reload_in_progress || reload_completed)
2027 sub_temp = gen_reg_rtx (DImode);
2029 if ((high_bits & 0xfffffc00) != 0)
2031 sparc_emit_set_safe_HIGH64 (temp, high_bits);
2032 if ((high_bits & ~0xfffffc00) != 0)
2033 emit_insn (gen_rtx_SET (VOIDmode,
2035 gen_safe_OR64 (temp, (high_bits & 0x3ff))));
2041 emit_insn (gen_safe_SET64 (temp, high_bits));
2045 if (!reload_in_progress && !reload_completed)
2047 rtx temp2 = gen_reg_rtx (DImode);
2048 rtx temp3 = gen_reg_rtx (DImode);
2049 rtx temp4 = gen_reg_rtx (DImode);
2051 emit_insn (gen_rtx_SET (VOIDmode, temp4,
2052 gen_rtx_ASHIFT (DImode, sub_temp,
2055 sparc_emit_set_safe_HIGH64 (temp2, low_bits);
2056 if ((low_bits & ~0xfffffc00) != 0)
2058 emit_insn (gen_rtx_SET (VOIDmode, temp3,
2059 gen_safe_OR64 (temp2, (low_bits & 0x3ff))));
2060 emit_insn (gen_rtx_SET (VOIDmode, op0,
2061 gen_rtx_PLUS (DImode, temp4, temp3)));
2065 emit_insn (gen_rtx_SET (VOIDmode, op0,
2066 gen_rtx_PLUS (DImode, temp4, temp2)));
2071 rtx low1 = GEN_INT ((low_bits >> (32 - 12)) & 0xfff);
2072 rtx low2 = GEN_INT ((low_bits >> (32 - 12 - 12)) & 0xfff);
2073 rtx low3 = GEN_INT ((low_bits >> (32 - 12 - 12 - 8)) & 0x0ff);
2076 /* We are in the middle of reload, so this is really
2077 painful. However we do still make an attempt to
2078 avoid emitting truly stupid code. */
2079 if (low1 != const0_rtx)
2081 emit_insn (gen_rtx_SET (VOIDmode, op0,
2082 gen_rtx_ASHIFT (DImode, sub_temp,
2083 GEN_INT (to_shift))));
2084 emit_insn (gen_rtx_SET (VOIDmode, op0,
2085 gen_rtx_IOR (DImode, op0, low1)));
2093 if (low2 != const0_rtx)
2095 emit_insn (gen_rtx_SET (VOIDmode, op0,
2096 gen_rtx_ASHIFT (DImode, sub_temp,
2097 GEN_INT (to_shift))));
2098 emit_insn (gen_rtx_SET (VOIDmode, op0,
2099 gen_rtx_IOR (DImode, op0, low2)));
2107 emit_insn (gen_rtx_SET (VOIDmode, op0,
2108 gen_rtx_ASHIFT (DImode, sub_temp,
2109 GEN_INT (to_shift))));
2110 if (low3 != const0_rtx)
2111 emit_insn (gen_rtx_SET (VOIDmode, op0,
2112 gen_rtx_IOR (DImode, op0, low3)));
2117 /* Analyze a 64-bit constant for certain properties. */
2118 static void analyze_64bit_constant (unsigned HOST_WIDE_INT,
2119 unsigned HOST_WIDE_INT,
2120 int *, int *, int *);
2123 analyze_64bit_constant (unsigned HOST_WIDE_INT high_bits,
2124 unsigned HOST_WIDE_INT low_bits,
2125 int *hbsp, int *lbsp, int *abbasp)
2127 int lowest_bit_set, highest_bit_set, all_bits_between_are_set;
2130 lowest_bit_set = highest_bit_set = -1;
2134 if ((lowest_bit_set == -1)
2135 && ((low_bits >> i) & 1))
2137 if ((highest_bit_set == -1)
2138 && ((high_bits >> (32 - i - 1)) & 1))
2139 highest_bit_set = (64 - i - 1);
2142 && ((highest_bit_set == -1)
2143 || (lowest_bit_set == -1)));
2149 if ((lowest_bit_set == -1)
2150 && ((high_bits >> i) & 1))
2151 lowest_bit_set = i + 32;
2152 if ((highest_bit_set == -1)
2153 && ((low_bits >> (32 - i - 1)) & 1))
2154 highest_bit_set = 32 - i - 1;
2157 && ((highest_bit_set == -1)
2158 || (lowest_bit_set == -1)));
2160 /* If there are no bits set this should have gone out
2161 as one instruction! */
2162 gcc_assert (lowest_bit_set != -1 && highest_bit_set != -1);
2163 all_bits_between_are_set = 1;
2164 for (i = lowest_bit_set; i <= highest_bit_set; i++)
2168 if ((low_bits & (1 << i)) != 0)
2173 if ((high_bits & (1 << (i - 32))) != 0)
2176 all_bits_between_are_set = 0;
2179 *hbsp = highest_bit_set;
2180 *lbsp = lowest_bit_set;
2181 *abbasp = all_bits_between_are_set;
2184 static int const64_is_2insns (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
2187 const64_is_2insns (unsigned HOST_WIDE_INT high_bits,
2188 unsigned HOST_WIDE_INT low_bits)
2190 int highest_bit_set, lowest_bit_set, all_bits_between_are_set;
2193 || high_bits == 0xffffffff)
2196 analyze_64bit_constant (high_bits, low_bits,
2197 &highest_bit_set, &lowest_bit_set,
2198 &all_bits_between_are_set);
2200 if ((highest_bit_set == 63
2201 || lowest_bit_set == 0)
2202 && all_bits_between_are_set != 0)
2205 if ((highest_bit_set - lowest_bit_set) < 21)
2211 static unsigned HOST_WIDE_INT create_simple_focus_bits (unsigned HOST_WIDE_INT,
2212 unsigned HOST_WIDE_INT,
2215 static unsigned HOST_WIDE_INT
2216 create_simple_focus_bits (unsigned HOST_WIDE_INT high_bits,
2217 unsigned HOST_WIDE_INT low_bits,
2218 int lowest_bit_set, int shift)
2220 HOST_WIDE_INT hi, lo;
2222 if (lowest_bit_set < 32)
2224 lo = (low_bits >> lowest_bit_set) << shift;
2225 hi = ((high_bits << (32 - lowest_bit_set)) << shift);
2230 hi = ((high_bits >> (lowest_bit_set - 32)) << shift);
2232 gcc_assert (! (hi & lo));
2236 /* Here we are sure to be arch64 and this is an integer constant
2237 being loaded into a register. Emit the most efficient
2238 insn sequence possible. Detection of all the 1-insn cases
2239 has been done already. */
2241 sparc_emit_set_const64 (rtx op0, rtx op1)
2243 unsigned HOST_WIDE_INT high_bits, low_bits;
2244 int lowest_bit_set, highest_bit_set;
2245 int all_bits_between_are_set;
2248 /* Sanity check that we know what we are working with. */
2249 gcc_assert (TARGET_ARCH64);
2251 if (GET_CODE (op0) != SUBREG)
2253 gcc_assert (GET_CODE (op0) == REG
2254 && (REGNO (op0) < SPARC_FIRST_FP_REG
2255 || REGNO (op0) > SPARC_LAST_V9_FP_REG));
2258 if (reload_in_progress || reload_completed)
2261 if (GET_CODE (op1) != CONST_DOUBLE
2262 && GET_CODE (op1) != CONST_INT)
2264 sparc_emit_set_symbolic_const64 (op0, op1, temp);
2269 temp = gen_reg_rtx (DImode);
2271 if (GET_CODE (op1) == CONST_DOUBLE)
2273 #if HOST_BITS_PER_WIDE_INT == 64
2274 high_bits = (CONST_DOUBLE_LOW (op1) >> 32) & 0xffffffff;
2275 low_bits = CONST_DOUBLE_LOW (op1) & 0xffffffff;
2277 high_bits = CONST_DOUBLE_HIGH (op1);
2278 low_bits = CONST_DOUBLE_LOW (op1);
2283 #if HOST_BITS_PER_WIDE_INT == 64
2284 high_bits = ((INTVAL (op1) >> 32) & 0xffffffff);
2285 low_bits = (INTVAL (op1) & 0xffffffff);
2287 high_bits = ((INTVAL (op1) < 0) ?
2290 low_bits = INTVAL (op1);
2294 /* low_bits bits 0 --> 31
2295 high_bits bits 32 --> 63 */
2297 analyze_64bit_constant (high_bits, low_bits,
2298 &highest_bit_set, &lowest_bit_set,
2299 &all_bits_between_are_set);
2301 /* First try for a 2-insn sequence. */
2303 /* These situations are preferred because the optimizer can
2304 * do more things with them:
2306 * sllx %reg, shift, %reg
2308 * srlx %reg, shift, %reg
2309 * 3) mov some_small_const, %reg
2310 * sllx %reg, shift, %reg
2312 if (((highest_bit_set == 63
2313 || lowest_bit_set == 0)
2314 && all_bits_between_are_set != 0)
2315 || ((highest_bit_set - lowest_bit_set) < 12))
2317 HOST_WIDE_INT the_const = -1;
2318 int shift = lowest_bit_set;
2320 if ((highest_bit_set != 63
2321 && lowest_bit_set != 0)
2322 || all_bits_between_are_set == 0)
2325 create_simple_focus_bits (high_bits, low_bits,
2328 else if (lowest_bit_set == 0)
2329 shift = -(63 - highest_bit_set);
2331 gcc_assert (SPARC_SIMM13_P (the_const));
2332 gcc_assert (shift != 0);
2334 emit_insn (gen_safe_SET64 (temp, the_const));
2336 emit_insn (gen_rtx_SET (VOIDmode,
2338 gen_rtx_ASHIFT (DImode,
2342 emit_insn (gen_rtx_SET (VOIDmode,
2344 gen_rtx_LSHIFTRT (DImode,
2346 GEN_INT (-shift))));
2350 /* Now a range of 22 or less bits set somewhere.
2351 * 1) sethi %hi(focus_bits), %reg
2352 * sllx %reg, shift, %reg
2353 * 2) sethi %hi(focus_bits), %reg
2354 * srlx %reg, shift, %reg
2356 if ((highest_bit_set - lowest_bit_set) < 21)
2358 unsigned HOST_WIDE_INT focus_bits =
2359 create_simple_focus_bits (high_bits, low_bits,
2360 lowest_bit_set, 10);
2362 gcc_assert (SPARC_SETHI_P (focus_bits));
2363 gcc_assert (lowest_bit_set != 10);
2365 sparc_emit_set_safe_HIGH64 (temp, focus_bits);
2367 /* If lowest_bit_set == 10 then a sethi alone could have done it. */
2368 if (lowest_bit_set < 10)
2369 emit_insn (gen_rtx_SET (VOIDmode,
2371 gen_rtx_LSHIFTRT (DImode, temp,
2372 GEN_INT (10 - lowest_bit_set))));
2373 else if (lowest_bit_set > 10)
2374 emit_insn (gen_rtx_SET (VOIDmode,
2376 gen_rtx_ASHIFT (DImode, temp,
2377 GEN_INT (lowest_bit_set - 10))));
2381 /* 1) sethi %hi(low_bits), %reg
2382 * or %reg, %lo(low_bits), %reg
2383 * 2) sethi %hi(~low_bits), %reg
2384 * xor %reg, %lo(-0x400 | (low_bits & 0x3ff)), %reg
2387 || high_bits == 0xffffffff)
2389 sparc_emit_set_const64_quick1 (op0, temp, low_bits,
2390 (high_bits == 0xffffffff));
2394 /* Now, try 3-insn sequences. */
2396 /* 1) sethi %hi(high_bits), %reg
2397 * or %reg, %lo(high_bits), %reg
2398 * sllx %reg, 32, %reg
2402 sparc_emit_set_const64_quick2 (op0, temp, high_bits, 0, 32);
2406 /* We may be able to do something quick
2407 when the constant is negated, so try that. */
2408 if (const64_is_2insns ((~high_bits) & 0xffffffff,
2409 (~low_bits) & 0xfffffc00))
2411 /* NOTE: The trailing bits get XOR'd so we need the
2412 non-negated bits, not the negated ones. */
2413 unsigned HOST_WIDE_INT trailing_bits = low_bits & 0x3ff;
2415 if ((((~high_bits) & 0xffffffff) == 0
2416 && ((~low_bits) & 0x80000000) == 0)
2417 || (((~high_bits) & 0xffffffff) == 0xffffffff
2418 && ((~low_bits) & 0x80000000) != 0))
2420 int fast_int = (~low_bits & 0xffffffff);
2422 if ((SPARC_SETHI_P (fast_int)
2423 && (~high_bits & 0xffffffff) == 0)
2424 || SPARC_SIMM13_P (fast_int))
2425 emit_insn (gen_safe_SET64 (temp, fast_int));
2427 sparc_emit_set_const64 (temp, GEN_INT64 (fast_int));
2432 #if HOST_BITS_PER_WIDE_INT == 64
2433 negated_const = GEN_INT (((~low_bits) & 0xfffffc00) |
2434 (((HOST_WIDE_INT)((~high_bits) & 0xffffffff))<<32));
2436 negated_const = immed_double_const ((~low_bits) & 0xfffffc00,
2437 (~high_bits) & 0xffffffff,
2440 sparc_emit_set_const64 (temp, negated_const);
2443 /* If we are XOR'ing with -1, then we should emit a one's complement
2444 instead. This way the combiner will notice logical operations
2445 such as ANDN later on and substitute. */
2446 if (trailing_bits == 0x3ff)
2448 emit_insn (gen_rtx_SET (VOIDmode, op0,
2449 gen_rtx_NOT (DImode, temp)));
2453 emit_insn (gen_rtx_SET (VOIDmode,
2455 gen_safe_XOR64 (temp,
2456 (-0x400 | trailing_bits))));
2461 /* 1) sethi %hi(xxx), %reg
2462 * or %reg, %lo(xxx), %reg
2463 * sllx %reg, yyy, %reg
2465 * ??? This is just a generalized version of the low_bits==0
2466 * thing above, FIXME...
2468 if ((highest_bit_set - lowest_bit_set) < 32)
2470 unsigned HOST_WIDE_INT focus_bits =
2471 create_simple_focus_bits (high_bits, low_bits,
2474 /* We can't get here in this state. */
2475 gcc_assert (highest_bit_set >= 32 && lowest_bit_set < 32);
2477 /* So what we know is that the set bits straddle the
2478 middle of the 64-bit word. */
2479 sparc_emit_set_const64_quick2 (op0, temp,
2485 /* 1) sethi %hi(high_bits), %reg
2486 * or %reg, %lo(high_bits), %reg
2487 * sllx %reg, 32, %reg
2488 * or %reg, low_bits, %reg
2490 if (SPARC_SIMM13_P(low_bits)
2491 && ((int)low_bits > 0))
2493 sparc_emit_set_const64_quick2 (op0, temp, high_bits, low_bits, 32);
2497 /* The easiest way when all else fails, is full decomposition. */
2499 printf ("sparc_emit_set_const64: Hard constant [%08lx%08lx] neg[%08lx%08lx]\n",
2500 high_bits, low_bits, ~high_bits, ~low_bits);
2502 sparc_emit_set_const64_longway (op0, temp, high_bits, low_bits);
2505 /* Given a comparison code (EQ, NE, etc.) and the first operand of a COMPARE,
2506 return the mode to be used for the comparison. For floating-point,
2507 CCFP[E]mode is used. CC_NOOVmode should be used when the first operand
2508 is a PLUS, MINUS, NEG, or ASHIFT. CCmode should be used when no special
2509 processing is needed. */
2512 select_cc_mode (enum rtx_code op, rtx x, rtx y ATTRIBUTE_UNUSED)
2514 if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2540 else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
2541 || GET_CODE (x) == NEG || GET_CODE (x) == ASHIFT)
2543 if (TARGET_ARCH64 && GET_MODE (x) == DImode)
2544 return CCX_NOOVmode;
2550 if (TARGET_ARCH64 && GET_MODE (x) == DImode)
2557 /* X and Y are two things to compare using CODE. Emit the compare insn and
2558 return the rtx for the cc reg in the proper mode. */
2561 gen_compare_reg (enum rtx_code code, rtx x, rtx y)
2563 enum machine_mode mode = SELECT_CC_MODE (code, x, y);
2566 /* ??? We don't have movcc patterns so we cannot generate pseudo regs for the
2567 fcc regs (cse can't tell they're really call clobbered regs and will
2568 remove a duplicate comparison even if there is an intervening function
2569 call - it will then try to reload the cc reg via an int reg which is why
2570 we need the movcc patterns). It is possible to provide the movcc
2571 patterns by using the ldxfsr/stxfsr v9 insns. I tried it: you need two
2572 registers (say %g1,%g5) and it takes about 6 insns. A better fix would be
2573 to tell cse that CCFPE mode registers (even pseudos) are call
2576 /* ??? This is an experiment. Rather than making changes to cse which may
2577 or may not be easy/clean, we do our own cse. This is possible because
2578 we will generate hard registers. Cse knows they're call clobbered (it
2579 doesn't know the same thing about pseudos). If we guess wrong, no big
2580 deal, but if we win, great! */
2582 if (TARGET_V9 && GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2583 #if 1 /* experiment */
2586 /* We cycle through the registers to ensure they're all exercised. */
2587 static int next_fcc_reg = 0;
2588 /* Previous x,y for each fcc reg. */
2589 static rtx prev_args[4][2];
2591 /* Scan prev_args for x,y. */
2592 for (reg = 0; reg < 4; reg++)
2593 if (prev_args[reg][0] == x && prev_args[reg][1] == y)
2598 prev_args[reg][0] = x;
2599 prev_args[reg][1] = y;
2600 next_fcc_reg = (next_fcc_reg + 1) & 3;
2602 cc_reg = gen_rtx_REG (mode, reg + SPARC_FIRST_V9_FCC_REG);
2605 cc_reg = gen_reg_rtx (mode);
2606 #endif /* ! experiment */
2607 else if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2608 cc_reg = gen_rtx_REG (mode, SPARC_FCC_REG);
2610 cc_reg = gen_rtx_REG (mode, SPARC_ICC_REG);
2612 emit_insn (gen_rtx_SET (VOIDmode, cc_reg,
2613 gen_rtx_COMPARE (mode, x, y)));
2618 /* This function is used for v9 only.
2619 CODE is the code for an Scc's comparison.
2620 OPERANDS[0] is the target of the Scc insn.
2621 OPERANDS[1] is the value we compare against const0_rtx (which hasn't
2622 been generated yet).
2624 This function is needed to turn
2627 (gt (reg:CCX 100 %icc)
2631 (gt:DI (reg:CCX 100 %icc)
2634 IE: The instruction recognizer needs to see the mode of the comparison to
2635 find the right instruction. We could use "gt:DI" right in the
2636 define_expand, but leaving it out allows us to handle DI, SI, etc.
2638 We refer to the global sparc compare operands sparc_compare_op0 and
2639 sparc_compare_op1. */
2642 gen_v9_scc (enum rtx_code compare_code, register rtx *operands)
2647 && (GET_MODE (sparc_compare_op0) == DImode
2648 || GET_MODE (operands[0]) == DImode))
2651 op0 = sparc_compare_op0;
2652 op1 = sparc_compare_op1;
2654 /* Try to use the movrCC insns. */
2656 && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
2657 && op1 == const0_rtx
2658 && v9_regcmp_p (compare_code))
2660 /* Special case for op0 != 0. This can be done with one instruction if
2661 operands[0] == sparc_compare_op0. */
2663 if (compare_code == NE
2664 && GET_MODE (operands[0]) == DImode
2665 && rtx_equal_p (op0, operands[0]))
2667 emit_insn (gen_rtx_SET (VOIDmode, operands[0],
2668 gen_rtx_IF_THEN_ELSE (DImode,
2669 gen_rtx_fmt_ee (compare_code, DImode,
2676 if (reg_overlap_mentioned_p (operands[0], op0))
2678 /* Handle the case where operands[0] == sparc_compare_op0.
2679 We "early clobber" the result. */
2680 op0 = gen_reg_rtx (GET_MODE (sparc_compare_op0));
2681 emit_move_insn (op0, sparc_compare_op0);
2684 emit_insn (gen_rtx_SET (VOIDmode, operands[0], const0_rtx));
2685 if (GET_MODE (op0) != DImode)
2687 temp = gen_reg_rtx (DImode);
2688 convert_move (temp, op0, 0);
2692 emit_insn (gen_rtx_SET (VOIDmode, operands[0],
2693 gen_rtx_IF_THEN_ELSE (GET_MODE (operands[0]),
2694 gen_rtx_fmt_ee (compare_code, DImode,
2702 operands[1] = gen_compare_reg (compare_code, op0, op1);
2704 switch (GET_MODE (operands[1]))
2714 emit_insn (gen_rtx_SET (VOIDmode, operands[0], const0_rtx));
2715 emit_insn (gen_rtx_SET (VOIDmode, operands[0],
2716 gen_rtx_IF_THEN_ELSE (GET_MODE (operands[0]),
2717 gen_rtx_fmt_ee (compare_code,
2718 GET_MODE (operands[1]),
2719 operands[1], const0_rtx),
2720 const1_rtx, operands[0])));
2725 /* Emit a conditional jump insn for the v9 architecture using comparison code
2726 CODE and jump target LABEL.
2727 This function exists to take advantage of the v9 brxx insns. */
2730 emit_v9_brxx_insn (enum rtx_code code, rtx op0, rtx label)
2732 emit_jump_insn (gen_rtx_SET (VOIDmode,
2734 gen_rtx_IF_THEN_ELSE (VOIDmode,
2735 gen_rtx_fmt_ee (code, GET_MODE (op0),
2737 gen_rtx_LABEL_REF (VOIDmode, label),
2741 /* Generate a DFmode part of a hard TFmode register.
2742 REG is the TFmode hard register, LOW is 1 for the
2743 low 64bit of the register and 0 otherwise.
2746 gen_df_reg (rtx reg, int low)
2748 int regno = REGNO (reg);
2750 if ((WORDS_BIG_ENDIAN == 0) ^ (low != 0))
2751 regno += (TARGET_ARCH64 && regno < 32) ? 1 : 2;
2752 return gen_rtx_REG (DFmode, regno);
2755 /* Generate a call to FUNC with OPERANDS. Operand 0 is the return value.
2756 Unlike normal calls, TFmode operands are passed by reference. It is
2757 assumed that no more than 3 operands are required. */
2760 emit_soft_tfmode_libcall (const char *func_name, int nargs, rtx *operands)
2762 rtx ret_slot = NULL, arg[3], func_sym;
2765 /* We only expect to be called for conversions, unary, and binary ops. */
2766 gcc_assert (nargs == 2 || nargs == 3);
2768 for (i = 0; i < nargs; ++i)
2770 rtx this_arg = operands[i];
2773 /* TFmode arguments and return values are passed by reference. */
2774 if (GET_MODE (this_arg) == TFmode)
2776 int force_stack_temp;
2778 force_stack_temp = 0;
2779 if (TARGET_BUGGY_QP_LIB && i == 0)
2780 force_stack_temp = 1;
2782 if (GET_CODE (this_arg) == MEM
2783 && ! force_stack_temp)
2784 this_arg = XEXP (this_arg, 0);
2785 else if (CONSTANT_P (this_arg)
2786 && ! force_stack_temp)
2788 this_slot = force_const_mem (TFmode, this_arg);
2789 this_arg = XEXP (this_slot, 0);
2793 this_slot = assign_stack_temp (TFmode, GET_MODE_SIZE (TFmode), 0);
2795 /* Operand 0 is the return value. We'll copy it out later. */
2797 emit_move_insn (this_slot, this_arg);
2799 ret_slot = this_slot;
2801 this_arg = XEXP (this_slot, 0);
2808 func_sym = gen_rtx_SYMBOL_REF (Pmode, func_name);
2810 if (GET_MODE (operands[0]) == TFmode)
2813 emit_library_call (func_sym, LCT_NORMAL, VOIDmode, 2,
2814 arg[0], GET_MODE (arg[0]),
2815 arg[1], GET_MODE (arg[1]));
2817 emit_library_call (func_sym, LCT_NORMAL, VOIDmode, 3,
2818 arg[0], GET_MODE (arg[0]),
2819 arg[1], GET_MODE (arg[1]),
2820 arg[2], GET_MODE (arg[2]));
2823 emit_move_insn (operands[0], ret_slot);
2829 gcc_assert (nargs == 2);
2831 ret = emit_library_call_value (func_sym, operands[0], LCT_NORMAL,
2832 GET_MODE (operands[0]), 1,
2833 arg[1], GET_MODE (arg[1]));
2835 if (ret != operands[0])
2836 emit_move_insn (operands[0], ret);
2840 /* Expand soft-float TFmode calls to sparc abi routines. */
2843 emit_soft_tfmode_binop (enum rtx_code code, rtx *operands)
2865 emit_soft_tfmode_libcall (func, 3, operands);
2869 emit_soft_tfmode_unop (enum rtx_code code, rtx *operands)
2873 gcc_assert (code == SQRT);
2876 emit_soft_tfmode_libcall (func, 2, operands);
2880 emit_soft_tfmode_cvt (enum rtx_code code, rtx *operands)
2887 switch (GET_MODE (operands[1]))
2900 case FLOAT_TRUNCATE:
2901 switch (GET_MODE (operands[0]))
2915 switch (GET_MODE (operands[1]))
2928 case UNSIGNED_FLOAT:
2929 switch (GET_MODE (operands[1]))
2943 switch (GET_MODE (operands[0]))
2957 switch (GET_MODE (operands[0]))
2974 emit_soft_tfmode_libcall (func, 2, operands);
2977 /* Expand a hard-float tfmode operation. All arguments must be in
2981 emit_hard_tfmode_operation (enum rtx_code code, rtx *operands)
2985 if (GET_RTX_CLASS (code) == RTX_UNARY)
2987 operands[1] = force_reg (GET_MODE (operands[1]), operands[1]);
2988 op = gen_rtx_fmt_e (code, GET_MODE (operands[0]), operands[1]);
2992 operands[1] = force_reg (GET_MODE (operands[1]), operands[1]);
2993 operands[2] = force_reg (GET_MODE (operands[2]), operands[2]);
2994 op = gen_rtx_fmt_ee (code, GET_MODE (operands[0]),
2995 operands[1], operands[2]);
2998 if (register_operand (operands[0], VOIDmode))
3001 dest = gen_reg_rtx (GET_MODE (operands[0]));
3003 emit_insn (gen_rtx_SET (VOIDmode, dest, op));
3005 if (dest != operands[0])
3006 emit_move_insn (operands[0], dest);
3010 emit_tfmode_binop (enum rtx_code code, rtx *operands)
3012 if (TARGET_HARD_QUAD)
3013 emit_hard_tfmode_operation (code, operands);
3015 emit_soft_tfmode_binop (code, operands);
3019 emit_tfmode_unop (enum rtx_code code, rtx *operands)
3021 if (TARGET_HARD_QUAD)
3022 emit_hard_tfmode_operation (code, operands);
3024 emit_soft_tfmode_unop (code, operands);
3028 emit_tfmode_cvt (enum rtx_code code, rtx *operands)
3030 if (TARGET_HARD_QUAD)
3031 emit_hard_tfmode_operation (code, operands);
3033 emit_soft_tfmode_cvt (code, operands);
3036 /* Return nonzero if a branch/jump/call instruction will be emitting
3037 nop into its delay slot. */
3040 empty_delay_slot (rtx insn)
3044 /* If no previous instruction (should not happen), return true. */
3045 if (PREV_INSN (insn) == NULL)
3048 seq = NEXT_INSN (PREV_INSN (insn));
3049 if (GET_CODE (PATTERN (seq)) == SEQUENCE)
3055 /* Return nonzero if TRIAL can go into the call delay slot. */
3058 tls_call_delay (rtx trial)
3063 call __tls_get_addr, %tgd_call (foo)
3064 add %l7, %o0, %o0, %tgd_add (foo)
3065 while Sun as/ld does not. */
3066 if (TARGET_GNU_TLS || !TARGET_TLS)
3069 pat = PATTERN (trial);
3070 if (GET_CODE (pat) != SET || GET_CODE (SET_DEST (pat)) != PLUS)
3073 unspec = XEXP (SET_DEST (pat), 1);
3074 if (GET_CODE (unspec) != UNSPEC
3075 || (XINT (unspec, 1) != UNSPEC_TLSGD
3076 && XINT (unspec, 1) != UNSPEC_TLSLDM))
3082 /* Return nonzero if TRIAL, an insn, can be combined with a 'restore'
3083 instruction. RETURN_P is true if the v9 variant 'return' is to be
3084 considered in the test too.
3086 TRIAL must be a SET whose destination is a REG appropriate for the
3087 'restore' instruction or, if RETURN_P is true, for the 'return'
3091 eligible_for_restore_insn (rtx trial, bool return_p)
3093 rtx pat = PATTERN (trial);
3094 rtx src = SET_SRC (pat);
3096 /* The 'restore src,%g0,dest' pattern for word mode and below. */
3097 if (GET_MODE_CLASS (GET_MODE (src)) != MODE_FLOAT
3098 && arith_operand (src, GET_MODE (src)))
3101 return GET_MODE_SIZE (GET_MODE (src)) <= GET_MODE_SIZE (DImode);
3103 return GET_MODE_SIZE (GET_MODE (src)) <= GET_MODE_SIZE (SImode);
3106 /* The 'restore src,%g0,dest' pattern for double-word mode. */
3107 else if (GET_MODE_CLASS (GET_MODE (src)) != MODE_FLOAT
3108 && arith_double_operand (src, GET_MODE (src)))
3109 return GET_MODE_SIZE (GET_MODE (src)) <= GET_MODE_SIZE (DImode);
3111 /* The 'restore src,%g0,dest' pattern for float if no FPU. */
3112 else if (! TARGET_FPU && register_operand (src, SFmode))
3115 /* The 'restore src,%g0,dest' pattern for double if no FPU. */
3116 else if (! TARGET_FPU && TARGET_ARCH64 && register_operand (src, DFmode))
3119 /* If we have the 'return' instruction, anything that does not use
3120 local or output registers and can go into a delay slot wins. */
3121 else if (return_p && TARGET_V9 && ! epilogue_renumber (&pat, 1)
3122 && (get_attr_in_uncond_branch_delay (trial)
3123 == IN_UNCOND_BRANCH_DELAY_TRUE))
3126 /* The 'restore src1,src2,dest' pattern for SImode. */
3127 else if (GET_CODE (src) == PLUS
3128 && register_operand (XEXP (src, 0), SImode)
3129 && arith_operand (XEXP (src, 1), SImode))
3132 /* The 'restore src1,src2,dest' pattern for DImode. */
3133 else if (GET_CODE (src) == PLUS
3134 && register_operand (XEXP (src, 0), DImode)
3135 && arith_double_operand (XEXP (src, 1), DImode))
3138 /* The 'restore src1,%lo(src2),dest' pattern. */
3139 else if (GET_CODE (src) == LO_SUM
3140 && ! TARGET_CM_MEDMID
3141 && ((register_operand (XEXP (src, 0), SImode)
3142 && immediate_operand (XEXP (src, 1), SImode))
3144 && register_operand (XEXP (src, 0), DImode)
3145 && immediate_operand (XEXP (src, 1), DImode))))
3148 /* The 'restore src,src,dest' pattern. */
3149 else if (GET_CODE (src) == ASHIFT
3150 && (register_operand (XEXP (src, 0), SImode)
3151 || register_operand (XEXP (src, 0), DImode))
3152 && XEXP (src, 1) == const1_rtx)
3158 /* Return nonzero if TRIAL can go into the function return's
3162 eligible_for_return_delay (rtx trial)
3166 if (GET_CODE (trial) != INSN || GET_CODE (PATTERN (trial)) != SET)
3169 if (get_attr_length (trial) != 1)
3172 /* If there are any call-saved registers, we should scan TRIAL if it
3173 does not reference them. For now just make it easy. */
3177 /* If the function uses __builtin_eh_return, the eh_return machinery
3178 occupies the delay slot. */
3179 if (current_function_calls_eh_return)
3182 /* In the case of a true leaf function, anything can go into the slot. */
3183 if (sparc_leaf_function_p)
3184 return get_attr_in_uncond_branch_delay (trial)
3185 == IN_UNCOND_BRANCH_DELAY_TRUE;
3187 pat = PATTERN (trial);
3189 /* Otherwise, only operations which can be done in tandem with
3190 a `restore' or `return' insn can go into the delay slot. */
3191 if (GET_CODE (SET_DEST (pat)) != REG
3192 || (REGNO (SET_DEST (pat)) >= 8 && REGNO (SET_DEST (pat)) < 24))
3195 /* If this instruction sets up floating point register and we have a return
3196 instruction, it can probably go in. But restore will not work
3198 if (REGNO (SET_DEST (pat)) >= 32)
3200 && ! epilogue_renumber (&pat, 1)
3201 && (get_attr_in_uncond_branch_delay (trial)
3202 == IN_UNCOND_BRANCH_DELAY_TRUE));
3204 return eligible_for_restore_insn (trial, true);
3207 /* Return nonzero if TRIAL can go into the sibling call's
3211 eligible_for_sibcall_delay (rtx trial)
3215 if (GET_CODE (trial) != INSN || GET_CODE (PATTERN (trial)) != SET)
3218 if (get_attr_length (trial) != 1)
3221 pat = PATTERN (trial);
3223 if (sparc_leaf_function_p)
3225 /* If the tail call is done using the call instruction,
3226 we have to restore %o7 in the delay slot. */
3227 if (LEAF_SIBCALL_SLOT_RESERVED_P)
3230 /* %g1 is used to build the function address */
3231 if (reg_mentioned_p (gen_rtx_REG (Pmode, 1), pat))
3237 /* Otherwise, only operations which can be done in tandem with
3238 a `restore' insn can go into the delay slot. */
3239 if (GET_CODE (SET_DEST (pat)) != REG
3240 || (REGNO (SET_DEST (pat)) >= 8 && REGNO (SET_DEST (pat)) < 24)
3241 || REGNO (SET_DEST (pat)) >= 32)
3244 /* If it mentions %o7, it can't go in, because sibcall will clobber it
3246 if (reg_mentioned_p (gen_rtx_REG (Pmode, 15), pat))
3249 return eligible_for_restore_insn (trial, false);
3253 short_branch (int uid1, int uid2)
3255 int delta = INSN_ADDRESSES (uid1) - INSN_ADDRESSES (uid2);
3257 /* Leave a few words of "slop". */
3258 if (delta >= -1023 && delta <= 1022)
3264 /* Return nonzero if REG is not used after INSN.
3265 We assume REG is a reload reg, and therefore does
3266 not live past labels or calls or jumps. */
3268 reg_unused_after (rtx reg, rtx insn)
3270 enum rtx_code code, prev_code = UNKNOWN;
3272 while ((insn = NEXT_INSN (insn)))
3274 if (prev_code == CALL_INSN && call_used_regs[REGNO (reg)])
3277 code = GET_CODE (insn);
3278 if (GET_CODE (insn) == CODE_LABEL)
3283 rtx set = single_set (insn);
3284 int in_src = set && reg_overlap_mentioned_p (reg, SET_SRC (set));
3287 if (set && reg_overlap_mentioned_p (reg, SET_DEST (set)))
3289 if (set == 0 && reg_overlap_mentioned_p (reg, PATTERN (insn)))
3297 /* Determine if it's legal to put X into the constant pool. This
3298 is not possible if X contains the address of a symbol that is
3299 not constant (TLS) or not known at final link time (PIC). */
3302 sparc_cannot_force_const_mem (rtx x)
3304 switch (GET_CODE (x))
3309 /* Accept all non-symbolic constants. */
3313 /* Labels are OK iff we are non-PIC. */
3314 return flag_pic != 0;
3317 /* 'Naked' TLS symbol references are never OK,
3318 non-TLS symbols are OK iff we are non-PIC. */
3319 if (SYMBOL_REF_TLS_MODEL (x))
3322 return flag_pic != 0;
3325 return sparc_cannot_force_const_mem (XEXP (x, 0));
3328 return sparc_cannot_force_const_mem (XEXP (x, 0))
3329 || sparc_cannot_force_const_mem (XEXP (x, 1));
3338 static GTY(()) char pic_helper_symbol_name[256];
3339 static GTY(()) rtx pic_helper_symbol;
3340 static GTY(()) bool pic_helper_emitted_p = false;
3341 static GTY(()) rtx global_offset_table;
3343 /* Ensure that we are not using patterns that are not OK with PIC. */
3351 gcc_assert (GET_CODE (recog_data.operand[i]) != SYMBOL_REF
3352 && (GET_CODE (recog_data.operand[i]) != CONST
3353 || (GET_CODE (XEXP (recog_data.operand[i], 0)) == MINUS
3354 && (XEXP (XEXP (recog_data.operand[i], 0), 0)
3355 == global_offset_table)
3356 && (GET_CODE (XEXP (XEXP (recog_data.operand[i], 0), 1))
3364 /* Return true if X is an address which needs a temporary register when
3365 reloaded while generating PIC code. */
3368 pic_address_needs_scratch (rtx x)
3370 /* An address which is a symbolic plus a non SMALL_INT needs a temp reg. */
3371 if (GET_CODE (x) == CONST && GET_CODE (XEXP (x, 0)) == PLUS
3372 && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
3373 && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
3374 && ! SMALL_INT (XEXP (XEXP (x, 0), 1)))
3380 /* Determine if a given RTX is a valid constant. We already know this
3381 satisfies CONSTANT_P. */
3384 legitimate_constant_p (rtx x)
3388 switch (GET_CODE (x))
3391 /* TLS symbols are not constant. */
3392 if (SYMBOL_REF_TLS_MODEL (x))
3397 inner = XEXP (x, 0);
3399 /* Offsets of TLS symbols are never valid.
3400 Discourage CSE from creating them. */
3401 if (GET_CODE (inner) == PLUS
3402 && tls_symbolic_operand (XEXP (inner, 0)))
3407 if (GET_MODE (x) == VOIDmode)
3410 /* Floating point constants are generally not ok.
3411 The only exception is 0.0 in VIS. */
3413 && (GET_MODE (x) == SFmode
3414 || GET_MODE (x) == DFmode
3415 || GET_MODE (x) == TFmode)
3416 && fp_zero_operand (x, GET_MODE (x)))
3428 /* Determine if a given RTX is a valid constant address. */
3431 constant_address_p (rtx x)
3433 switch (GET_CODE (x))
3441 if (flag_pic && pic_address_needs_scratch (x))
3443 return legitimate_constant_p (x);
3446 return !flag_pic && legitimate_constant_p (x);
3453 /* Nonzero if the constant value X is a legitimate general operand
3454 when generating PIC code. It is given that flag_pic is on and
3455 that X satisfies CONSTANT_P or is a CONST_DOUBLE. */
3458 legitimate_pic_operand_p (rtx x)
3460 if (pic_address_needs_scratch (x))
3462 if (tls_symbolic_operand (x)
3463 || (GET_CODE (x) == CONST
3464 && GET_CODE (XEXP (x, 0)) == PLUS
3465 && tls_symbolic_operand (XEXP (XEXP (x, 0), 0))))
3470 /* Return nonzero if ADDR is a valid memory address.
3471 STRICT specifies whether strict register checking applies. */
3474 legitimate_address_p (enum machine_mode mode, rtx addr, int strict)
3476 rtx rs1 = NULL, rs2 = NULL, imm1 = NULL;
3478 if (REG_P (addr) || GET_CODE (addr) == SUBREG)
3480 else if (GET_CODE (addr) == PLUS)
3482 rs1 = XEXP (addr, 0);
3483 rs2 = XEXP (addr, 1);
3485 /* Canonicalize. REG comes first, if there are no regs,
3486 LO_SUM comes first. */
3488 && GET_CODE (rs1) != SUBREG
3490 || GET_CODE (rs2) == SUBREG
3491 || (GET_CODE (rs2) == LO_SUM && GET_CODE (rs1) != LO_SUM)))
3493 rs1 = XEXP (addr, 1);
3494 rs2 = XEXP (addr, 0);
3498 && rs1 == pic_offset_table_rtx
3500 && GET_CODE (rs2) != SUBREG
3501 && GET_CODE (rs2) != LO_SUM
3502 && GET_CODE (rs2) != MEM
3503 && !tls_symbolic_operand (rs2)
3504 && (! symbolic_operand (rs2, VOIDmode) || mode == Pmode)
3505 && (GET_CODE (rs2) != CONST_INT || SMALL_INT (rs2)))
3507 || GET_CODE (rs1) == SUBREG)
3508 && RTX_OK_FOR_OFFSET_P (rs2)))
3513 else if ((REG_P (rs1) || GET_CODE (rs1) == SUBREG)
3514 && (REG_P (rs2) || GET_CODE (rs2) == SUBREG))
3516 /* We prohibit REG + REG for TFmode when there are no quad move insns
3517 and we consequently need to split. We do this because REG+REG
3518 is not an offsettable address. If we get the situation in reload
3519 where source and destination of a movtf pattern are both MEMs with
3520 REG+REG address, then only one of them gets converted to an
3521 offsettable address. */
3523 && ! (TARGET_FPU && TARGET_ARCH64 && TARGET_HARD_QUAD))
3526 /* We prohibit REG + REG on ARCH32 if not optimizing for
3527 DFmode/DImode because then mem_min_alignment is likely to be zero
3528 after reload and the forced split would lack a matching splitter
3530 if (TARGET_ARCH32 && !optimize
3531 && (mode == DFmode || mode == DImode))
3534 else if (USE_AS_OFFSETABLE_LO10
3535 && GET_CODE (rs1) == LO_SUM
3537 && ! TARGET_CM_MEDMID
3538 && RTX_OK_FOR_OLO10_P (rs2))
3541 imm1 = XEXP (rs1, 1);
3542 rs1 = XEXP (rs1, 0);
3543 if (! CONSTANT_P (imm1) || tls_symbolic_operand (rs1))
3547 else if (GET_CODE (addr) == LO_SUM)
3549 rs1 = XEXP (addr, 0);
3550 imm1 = XEXP (addr, 1);
3552 if (! CONSTANT_P (imm1) || tls_symbolic_operand (rs1))
3555 /* We can't allow TFmode in 32-bit mode, because an offset greater
3556 than the alignment (8) may cause the LO_SUM to overflow. */
3557 if (mode == TFmode && !TARGET_64BIT)
3560 else if (GET_CODE (addr) == CONST_INT && SMALL_INT (addr))
3565 if (GET_CODE (rs1) == SUBREG)
3566 rs1 = SUBREG_REG (rs1);
3572 if (GET_CODE (rs2) == SUBREG)
3573 rs2 = SUBREG_REG (rs2);
3580 if (!REGNO_OK_FOR_BASE_P (REGNO (rs1))
3581 || (rs2 && !REGNO_OK_FOR_BASE_P (REGNO (rs2))))
3586 if ((REGNO (rs1) >= 32
3587 && REGNO (rs1) != FRAME_POINTER_REGNUM
3588 && REGNO (rs1) < FIRST_PSEUDO_REGISTER)
3590 && (REGNO (rs2) >= 32
3591 && REGNO (rs2) != FRAME_POINTER_REGNUM
3592 && REGNO (rs2) < FIRST_PSEUDO_REGISTER)))
3598 /* Construct the SYMBOL_REF for the tls_get_offset function. */
3600 static GTY(()) rtx sparc_tls_symbol;
3602 sparc_tls_get_addr (void)
3604 if (!sparc_tls_symbol)
3605 sparc_tls_symbol = gen_rtx_SYMBOL_REF (Pmode, "__tls_get_addr");
3607 return sparc_tls_symbol;
3611 sparc_tls_got (void)
3616 current_function_uses_pic_offset_table = 1;
3617 return pic_offset_table_rtx;
3620 if (!global_offset_table)
3621 global_offset_table = gen_rtx_SYMBOL_REF (Pmode, "_GLOBAL_OFFSET_TABLE_");
3622 temp = gen_reg_rtx (Pmode);
3623 emit_move_insn (temp, global_offset_table);
3628 /* ADDR contains a thread-local SYMBOL_REF. Generate code to compute
3629 this (thread-local) address. */
3632 legitimize_tls_address (rtx addr)
3634 rtx temp1, temp2, temp3, ret, o0, got, insn;
3636 gcc_assert (! no_new_pseudos);
3638 if (GET_CODE (addr) == SYMBOL_REF)
3639 switch (SYMBOL_REF_TLS_MODEL (addr))
3641 case TLS_MODEL_GLOBAL_DYNAMIC:
3643 temp1 = gen_reg_rtx (SImode);
3644 temp2 = gen_reg_rtx (SImode);
3645 ret = gen_reg_rtx (Pmode);
3646 o0 = gen_rtx_REG (Pmode, 8);
3647 got = sparc_tls_got ();
3648 emit_insn (gen_tgd_hi22 (temp1, addr));
3649 emit_insn (gen_tgd_lo10 (temp2, temp1, addr));
3652 emit_insn (gen_tgd_add32 (o0, got, temp2, addr));
3653 insn = emit_call_insn (gen_tgd_call32 (o0, sparc_tls_get_addr (),
3658 emit_insn (gen_tgd_add64 (o0, got, temp2, addr));
3659 insn = emit_call_insn (gen_tgd_call64 (o0, sparc_tls_get_addr (),
3662 CALL_INSN_FUNCTION_USAGE (insn)
3663 = gen_rtx_EXPR_LIST (VOIDmode, gen_rtx_USE (VOIDmode, o0),
3664 CALL_INSN_FUNCTION_USAGE (insn));
3665 insn = get_insns ();
3667 emit_libcall_block (insn, ret, o0, addr);
3670 case TLS_MODEL_LOCAL_DYNAMIC:
3672 temp1 = gen_reg_rtx (SImode);
3673 temp2 = gen_reg_rtx (SImode);
3674 temp3 = gen_reg_rtx (Pmode);
3675 ret = gen_reg_rtx (Pmode);
3676 o0 = gen_rtx_REG (Pmode, 8);
3677 got = sparc_tls_got ();
3678 emit_insn (gen_tldm_hi22 (temp1));
3679 emit_insn (gen_tldm_lo10 (temp2, temp1));
3682 emit_insn (gen_tldm_add32 (o0, got, temp2));
3683 insn = emit_call_insn (gen_tldm_call32 (o0, sparc_tls_get_addr (),
3688 emit_insn (gen_tldm_add64 (o0, got, temp2));
3689 insn = emit_call_insn (gen_tldm_call64 (o0, sparc_tls_get_addr (),
3692 CALL_INSN_FUNCTION_USAGE (insn)
3693 = gen_rtx_EXPR_LIST (VOIDmode, gen_rtx_USE (VOIDmode, o0),
3694 CALL_INSN_FUNCTION_USAGE (insn));
3695 insn = get_insns ();
3697 emit_libcall_block (insn, temp3, o0,
3698 gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
3699 UNSPEC_TLSLD_BASE));
3700 temp1 = gen_reg_rtx (SImode);
3701 temp2 = gen_reg_rtx (SImode);
3702 emit_insn (gen_tldo_hix22 (temp1, addr));
3703 emit_insn (gen_tldo_lox10 (temp2, temp1, addr));
3705 emit_insn (gen_tldo_add32 (ret, temp3, temp2, addr));
3707 emit_insn (gen_tldo_add64 (ret, temp3, temp2, addr));
3710 case TLS_MODEL_INITIAL_EXEC:
3711 temp1 = gen_reg_rtx (SImode);
3712 temp2 = gen_reg_rtx (SImode);
3713 temp3 = gen_reg_rtx (Pmode);
3714 got = sparc_tls_got ();
3715 emit_insn (gen_tie_hi22 (temp1, addr));
3716 emit_insn (gen_tie_lo10 (temp2, temp1, addr));
3718 emit_insn (gen_tie_ld32 (temp3, got, temp2, addr));
3720 emit_insn (gen_tie_ld64 (temp3, got, temp2, addr));
3723 ret = gen_reg_rtx (Pmode);
3725 emit_insn (gen_tie_add32 (ret, gen_rtx_REG (Pmode, 7),
3728 emit_insn (gen_tie_add64 (ret, gen_rtx_REG (Pmode, 7),
3732 ret = gen_rtx_PLUS (Pmode, gen_rtx_REG (Pmode, 7), temp3);
3735 case TLS_MODEL_LOCAL_EXEC:
3736 temp1 = gen_reg_rtx (Pmode);
3737 temp2 = gen_reg_rtx (Pmode);
3740 emit_insn (gen_tle_hix22_sp32 (temp1, addr));
3741 emit_insn (gen_tle_lox10_sp32 (temp2, temp1, addr));
3745 emit_insn (gen_tle_hix22_sp64 (temp1, addr));
3746 emit_insn (gen_tle_lox10_sp64 (temp2, temp1, addr));
3748 ret = gen_rtx_PLUS (Pmode, gen_rtx_REG (Pmode, 7), temp2);
3756 gcc_unreachable (); /* for now ... */
3762 /* Legitimize PIC addresses. If the address is already position-independent,
3763 we return ORIG. Newly generated position-independent addresses go into a
3764 reg. This is REG if nonzero, otherwise we allocate register(s) as
3768 legitimize_pic_address (rtx orig, enum machine_mode mode ATTRIBUTE_UNUSED,
3771 if (GET_CODE (orig) == SYMBOL_REF)
3773 rtx pic_ref, address;
3778 gcc_assert (! reload_in_progress && ! reload_completed);
3779 reg = gen_reg_rtx (Pmode);
3784 /* If not during reload, allocate another temp reg here for loading
3785 in the address, so that these instructions can be optimized
3787 rtx temp_reg = ((reload_in_progress || reload_completed)
3788 ? reg : gen_reg_rtx (Pmode));
3790 /* Must put the SYMBOL_REF inside an UNSPEC here so that cse
3791 won't get confused into thinking that these two instructions
3792 are loading in the true address of the symbol. If in the
3793 future a PIC rtx exists, that should be used instead. */
3794 if (Pmode == SImode)
3796 emit_insn (gen_movsi_high_pic (temp_reg, orig));
3797 emit_insn (gen_movsi_lo_sum_pic (temp_reg, temp_reg, orig));
3801 emit_insn (gen_movdi_high_pic (temp_reg, orig));
3802 emit_insn (gen_movdi_lo_sum_pic (temp_reg, temp_reg, orig));
3809 pic_ref = gen_const_mem (Pmode,
3810 gen_rtx_PLUS (Pmode,
3811 pic_offset_table_rtx, address));
3812 current_function_uses_pic_offset_table = 1;
3813 insn = emit_move_insn (reg, pic_ref);
3814 /* Put a REG_EQUAL note on this insn, so that it can be optimized
3816 REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EQUAL, orig,
3820 else if (GET_CODE (orig) == CONST)
3824 if (GET_CODE (XEXP (orig, 0)) == PLUS
3825 && XEXP (XEXP (orig, 0), 0) == pic_offset_table_rtx)
3830 gcc_assert (! reload_in_progress && ! reload_completed);
3831 reg = gen_reg_rtx (Pmode);
3834 gcc_assert (GET_CODE (XEXP (orig, 0)) == PLUS);
3835 base = legitimize_pic_address (XEXP (XEXP (orig, 0), 0), Pmode, reg);
3836 offset = legitimize_pic_address (XEXP (XEXP (orig, 0), 1), Pmode,
3837 base == reg ? 0 : reg);
3839 if (GET_CODE (offset) == CONST_INT)
3841 if (SMALL_INT (offset))
3842 return plus_constant (base, INTVAL (offset));
3843 else if (! reload_in_progress && ! reload_completed)
3844 offset = force_reg (Pmode, offset);
3846 /* If we reach here, then something is seriously wrong. */
3849 return gen_rtx_PLUS (Pmode, base, offset);
3851 else if (GET_CODE (orig) == LABEL_REF)
3852 /* ??? Why do we do this? */
3853 /* Now movsi_pic_label_ref uses it, but we ought to be checking that
3854 the register is live instead, in case it is eliminated. */
3855 current_function_uses_pic_offset_table = 1;
3860 /* Try machine-dependent ways of modifying an illegitimate address X
3861 to be legitimate. If we find one, return the new, valid address.
3863 OLDX is the address as it was before break_out_memory_refs was called.
3864 In some cases it is useful to look at this to decide what needs to be done.
3866 MODE is the mode of the operand pointed to by X. */
3869 legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED, enum machine_mode mode)
3873 if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 0)) == MULT)
3874 x = gen_rtx_PLUS (Pmode, XEXP (x, 1),
3875 force_operand (XEXP (x, 0), NULL_RTX));
3876 if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == MULT)
3877 x = gen_rtx_PLUS (Pmode, XEXP (x, 0),
3878 force_operand (XEXP (x, 1), NULL_RTX));
3879 if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 0)) == PLUS)
3880 x = gen_rtx_PLUS (Pmode, force_operand (XEXP (x, 0), NULL_RTX),
3882 if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == PLUS)
3883 x = gen_rtx_PLUS (Pmode, XEXP (x, 0),
3884 force_operand (XEXP (x, 1), NULL_RTX));
3886 if (x != orig_x && legitimate_address_p (mode, x, FALSE))
3889 if (tls_symbolic_operand (x))
3890 x = legitimize_tls_address (x);
3892 x = legitimize_pic_address (x, mode, 0);
3893 else if (GET_CODE (x) == PLUS && CONSTANT_ADDRESS_P (XEXP (x, 1)))
3894 x = gen_rtx_PLUS (Pmode, XEXP (x, 0),
3895 copy_to_mode_reg (Pmode, XEXP (x, 1)));
3896 else if (GET_CODE (x) == PLUS && CONSTANT_ADDRESS_P (XEXP (x, 0)))
3897 x = gen_rtx_PLUS (Pmode, XEXP (x, 1),
3898 copy_to_mode_reg (Pmode, XEXP (x, 0)));
3899 else if (GET_CODE (x) == SYMBOL_REF
3900 || GET_CODE (x) == CONST
3901 || GET_CODE (x) == LABEL_REF)
3902 x = copy_to_suggested_reg (x, NULL_RTX, Pmode);
3906 /* Emit the special PIC helper function. */
3909 emit_pic_helper (void)
3911 const char *pic_name = reg_names[REGNO (pic_offset_table_rtx)];
3916 align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3918 ASM_OUTPUT_ALIGN (asm_out_file, align);
3919 ASM_OUTPUT_LABEL (asm_out_file, pic_helper_symbol_name);
3920 if (flag_delayed_branch)
3921 fprintf (asm_out_file, "\tjmp\t%%o7+8\n\t add\t%%o7, %s, %s\n",
3922 pic_name, pic_name);
3924 fprintf (asm_out_file, "\tadd\t%%o7, %s, %s\n\tjmp\t%%o7+8\n\t nop\n",
3925 pic_name, pic_name);
3927 pic_helper_emitted_p = true;
3930 /* Emit code to load the PIC register. */
3933 load_pic_register (bool delay_pic_helper)
3935 int orig_flag_pic = flag_pic;
3937 /* If we haven't initialized the special PIC symbols, do so now. */
3938 if (!pic_helper_symbol_name[0])
3940 ASM_GENERATE_INTERNAL_LABEL (pic_helper_symbol_name, "LADDPC", 0);
3941 pic_helper_symbol = gen_rtx_SYMBOL_REF (Pmode, pic_helper_symbol_name);
3942 global_offset_table = gen_rtx_SYMBOL_REF (Pmode, "_GLOBAL_OFFSET_TABLE_");
3945 /* If we haven't emitted the special PIC helper function, do so now unless
3946 we are requested to delay it. */
3947 if (!delay_pic_helper && !pic_helper_emitted_p)
3952 emit_insn (gen_load_pcrel_symdi (pic_offset_table_rtx, global_offset_table,
3953 pic_helper_symbol));
3955 emit_insn (gen_load_pcrel_symsi (pic_offset_table_rtx, global_offset_table,
3956 pic_helper_symbol));
3957 flag_pic = orig_flag_pic;
3959 /* Need to emit this whether or not we obey regdecls,
3960 since setjmp/longjmp can cause life info to screw up.
3961 ??? In the case where we don't obey regdecls, this is not sufficient
3962 since we may not fall out the bottom. */
3963 emit_insn (gen_rtx_USE (VOIDmode, pic_offset_table_rtx));
3966 /* Return 1 if RTX is a MEM which is known to be aligned to at
3967 least a DESIRED byte boundary. */
3970 mem_min_alignment (rtx mem, int desired)
3972 rtx addr, base, offset;
3974 /* If it's not a MEM we can't accept it. */
3975 if (GET_CODE (mem) != MEM)
3979 if (MEM_ALIGN (mem) / BITS_PER_UNIT >= (unsigned)desired)
3982 /* ??? The rest of the function predates MEM_ALIGN so
3983 there is probably a bit of redundancy. */
3984 addr = XEXP (mem, 0);
3985 base = offset = NULL_RTX;
3986 if (GET_CODE (addr) == PLUS)
3988 if (GET_CODE (XEXP (addr, 0)) == REG)
3990 base = XEXP (addr, 0);
3992 /* What we are saying here is that if the base
3993 REG is aligned properly, the compiler will make
3994 sure any REG based index upon it will be so
3996 if (GET_CODE (XEXP (addr, 1)) == CONST_INT)
3997 offset = XEXP (addr, 1);
3999 offset = const0_rtx;
4002 else if (GET_CODE (addr) == REG)
4005 offset = const0_rtx;
4008 if (base != NULL_RTX)
4010 int regno = REGNO (base);
4012 if (regno != HARD_FRAME_POINTER_REGNUM && regno != STACK_POINTER_REGNUM)
4014 /* Check if the compiler has recorded some information
4015 about the alignment of the base REG. If reload has
4016 completed, we already matched with proper alignments.
4017 If not running global_alloc, reload might give us
4018 unaligned pointer to local stack though. */
4020 && REGNO_POINTER_ALIGN (regno) >= desired * BITS_PER_UNIT)
4021 || (optimize && reload_completed))
4022 && (INTVAL (offset) & (desired - 1)) == 0)
4027 if (((INTVAL (offset) - SPARC_STACK_BIAS) & (desired - 1)) == 0)
4031 else if (! TARGET_UNALIGNED_DOUBLES
4032 || CONSTANT_P (addr)
4033 || GET_CODE (addr) == LO_SUM)
4035 /* Anything else we know is properly aligned unless TARGET_UNALIGNED_DOUBLES
4036 is true, in which case we can only assume that an access is aligned if
4037 it is to a constant address, or the address involves a LO_SUM. */
4041 /* An obviously unaligned address. */
4046 /* Vectors to keep interesting information about registers where it can easily
4047 be got. We used to use the actual mode value as the bit number, but there
4048 are more than 32 modes now. Instead we use two tables: one indexed by
4049 hard register number, and one indexed by mode. */
4051 /* The purpose of sparc_mode_class is to shrink the range of modes so that
4052 they all fit (as bit numbers) in a 32 bit word (again). Each real mode is
4053 mapped into one sparc_mode_class mode. */
4055 enum sparc_mode_class {
4056 S_MODE, D_MODE, T_MODE, O_MODE,
4057 SF_MODE, DF_MODE, TF_MODE, OF_MODE,
4061 /* Modes for single-word and smaller quantities. */
4062 #define S_MODES ((1 << (int) S_MODE) | (1 << (int) SF_MODE))
4064 /* Modes for double-word and smaller quantities. */
4065 #define D_MODES (S_MODES | (1 << (int) D_MODE) | (1 << DF_MODE))
4067 /* Modes for quad-word and smaller quantities. */
4068 #define T_MODES (D_MODES | (1 << (int) T_MODE) | (1 << (int) TF_MODE))
4070 /* Modes for 8-word and smaller quantities. */
4071 #define O_MODES (T_MODES | (1 << (int) O_MODE) | (1 << (int) OF_MODE))
4073 /* Modes for single-float quantities. We must allow any single word or
4074 smaller quantity. This is because the fix/float conversion instructions
4075 take integer inputs/outputs from the float registers. */
4076 #define SF_MODES (S_MODES)
4078 /* Modes for double-float and smaller quantities. */
4079 #define DF_MODES (S_MODES | D_MODES)
4081 /* Modes for double-float only quantities. */
4082 #define DF_MODES_NO_S ((1 << (int) D_MODE) | (1 << (int) DF_MODE))
4084 /* Modes for quad-float only quantities. */
4085 #define TF_ONLY_MODES (1 << (int) TF_MODE)
4087 /* Modes for quad-float and smaller quantities. */
4088 #define TF_MODES (DF_MODES | TF_ONLY_MODES)
4090 /* Modes for quad-float and double-float quantities. */
4091 #define TF_MODES_NO_S (DF_MODES_NO_S | TF_ONLY_MODES)
4093 /* Modes for quad-float pair only quantities. */
4094 #define OF_ONLY_MODES (1 << (int) OF_MODE)
4096 /* Modes for quad-float pairs and smaller quantities. */
4097 #define OF_MODES (TF_MODES | OF_ONLY_MODES)
4099 #define OF_MODES_NO_S (TF_MODES_NO_S | OF_ONLY_MODES)
4101 /* Modes for condition codes. */
4102 #define CC_MODES (1 << (int) CC_MODE)
4103 #define CCFP_MODES (1 << (int) CCFP_MODE)
4105 /* Value is 1 if register/mode pair is acceptable on sparc.
4106 The funny mixture of D and T modes is because integer operations
4107 do not specially operate on tetra quantities, so non-quad-aligned
4108 registers can hold quadword quantities (except %o4 and %i4 because
4109 they cross fixed registers). */
4111 /* This points to either the 32 bit or the 64 bit version. */
4112 const int *hard_regno_mode_classes;
4114 static const int hard_32bit_mode_classes[] = {
4115 S_MODES, S_MODES, T_MODES, S_MODES, T_MODES, S_MODES, D_MODES, S_MODES,
4116 T_MODES, S_MODES, T_MODES, S_MODES, D_MODES, S_MODES, D_MODES, S_MODES,
4117 T_MODES, S_MODES, T_MODES, S_MODES, T_MODES, S_MODES, D_MODES, S_MODES,
4118 T_MODES, S_MODES, T_MODES, S_MODES, D_MODES, S_MODES, D_MODES, S_MODES,
4120 OF_MODES, SF_MODES, DF_MODES, SF_MODES, OF_MODES, SF_MODES, DF_MODES, SF_MODES,
4121 OF_MODES, SF_MODES, DF_MODES, SF_MODES, OF_MODES, SF_MODES, DF_MODES, SF_MODES,
4122 OF_MODES, SF_MODES, DF_MODES, SF_MODES, OF_MODES, SF_MODES, DF_MODES, SF_MODES,
4123 OF_MODES, SF_MODES, DF_MODES, SF_MODES, TF_MODES, SF_MODES, DF_MODES, SF_MODES,
4125 /* FP regs f32 to f63. Only the even numbered registers actually exist,
4126 and none can hold SFmode/SImode values. */
4127 OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, OF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
4128 OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, OF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
4129 OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, OF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
4130 OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, TF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
4133 CCFP_MODES, CCFP_MODES, CCFP_MODES, CCFP_MODES,
4139 static const int hard_64bit_mode_classes[] = {
4140 D_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES,
4141 O_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES,
4142 T_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES,
4143 O_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES,
4145 OF_MODES, SF_MODES, DF_MODES, SF_MODES, OF_MODES, SF_MODES, DF_MODES, SF_MODES,
4146 OF_MODES, SF_MODES, DF_MODES, SF_MODES, OF_MODES, SF_MODES, DF_MODES, SF_MODES,
4147 OF_MODES, SF_MODES, DF_MODES, SF_MODES, OF_MODES, SF_MODES, DF_MODES, SF_MODES,
4148 OF_MODES, SF_MODES, DF_MODES, SF_MODES, TF_MODES, SF_MODES, DF_MODES, SF_MODES,
4150 /* FP regs f32 to f63. Only the even numbered registers actually exist,
4151 and none can hold SFmode/SImode values. */
4152 OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, OF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
4153 OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, OF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
4154 OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, OF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
4155 OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, TF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
4158 CCFP_MODES, CCFP_MODES, CCFP_MODES, CCFP_MODES,
4164 int sparc_mode_class [NUM_MACHINE_MODES];
4166 enum reg_class sparc_regno_reg_class[FIRST_PSEUDO_REGISTER];
4169 sparc_init_modes (void)
4173 for (i = 0; i < NUM_MACHINE_MODES; i++)
4175 switch (GET_MODE_CLASS (i))
4178 case MODE_PARTIAL_INT:
4179 case MODE_COMPLEX_INT:
4180 if (GET_MODE_SIZE (i) <= 4)
4181 sparc_mode_class[i] = 1 << (int) S_MODE;
4182 else if (GET_MODE_SIZE (i) == 8)
4183 sparc_mode_class[i] = 1 << (int) D_MODE;
4184 else if (GET_MODE_SIZE (i) == 16)
4185 sparc_mode_class[i] = 1 << (int) T_MODE;
4186 else if (GET_MODE_SIZE (i) == 32)
4187 sparc_mode_class[i] = 1 << (int) O_MODE;
4189 sparc_mode_class[i] = 0;
4191 case MODE_VECTOR_INT:
4192 if (GET_MODE_SIZE (i) <= 4)
4193 sparc_mode_class[i] = 1 << (int)SF_MODE;
4194 else if (GET_MODE_SIZE (i) == 8)
4195 sparc_mode_class[i] = 1 << (int)DF_MODE;
4198 case MODE_COMPLEX_FLOAT:
4199 if (GET_MODE_SIZE (i) <= 4)
4200 sparc_mode_class[i] = 1 << (int) SF_MODE;
4201 else if (GET_MODE_SIZE (i) == 8)
4202 sparc_mode_class[i] = 1 << (int) DF_MODE;
4203 else if (GET_MODE_SIZE (i) == 16)
4204 sparc_mode_class[i] = 1 << (int) TF_MODE;
4205 else if (GET_MODE_SIZE (i) == 32)
4206 sparc_mode_class[i] = 1 << (int) OF_MODE;
4208 sparc_mode_class[i] = 0;
4211 if (i == (int) CCFPmode || i == (int) CCFPEmode)
4212 sparc_mode_class[i] = 1 << (int) CCFP_MODE;
4214 sparc_mode_class[i] = 1 << (int) CC_MODE;
4217 sparc_mode_class[i] = 0;
4223 hard_regno_mode_classes = hard_64bit_mode_classes;
4225 hard_regno_mode_classes = hard_32bit_mode_classes;
4227 /* Initialize the array used by REGNO_REG_CLASS. */
4228 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
4230 if (i < 16 && TARGET_V8PLUS)
4231 sparc_regno_reg_class[i] = I64_REGS;
4232 else if (i < 32 || i == FRAME_POINTER_REGNUM)
4233 sparc_regno_reg_class[i] = GENERAL_REGS;
4235 sparc_regno_reg_class[i] = FP_REGS;
4237 sparc_regno_reg_class[i] = EXTRA_FP_REGS;
4239 sparc_regno_reg_class[i] = FPCC_REGS;
4241 sparc_regno_reg_class[i] = NO_REGS;
4245 /* Compute the frame size required by the function. This function is called
4246 during the reload pass and also by sparc_expand_prologue. */
4249 sparc_compute_frame_size (HOST_WIDE_INT size, int leaf_function_p)
4251 int outgoing_args_size = (current_function_outgoing_args_size
4252 + REG_PARM_STACK_SPACE (current_function_decl));
4253 int n_regs = 0; /* N_REGS is the number of 4-byte regs saved thus far. */
4258 for (i = 0; i < 8; i++)
4259 if (regs_ever_live[i] && ! call_used_regs[i])
4264 for (i = 0; i < 8; i += 2)
4265 if ((regs_ever_live[i] && ! call_used_regs[i])
4266 || (regs_ever_live[i+1] && ! call_used_regs[i+1]))
4270 for (i = 32; i < (TARGET_V9 ? 96 : 64); i += 2)
4271 if ((regs_ever_live[i] && ! call_used_regs[i])
4272 || (regs_ever_live[i+1] && ! call_used_regs[i+1]))
4275 /* Set up values for use in prologue and epilogue. */
4276 num_gfregs = n_regs;
4281 && current_function_outgoing_args_size == 0)
4282 actual_fsize = apparent_fsize = 0;
4285 /* We subtract STARTING_FRAME_OFFSET, remember it's negative. */
4286 apparent_fsize = (size - STARTING_FRAME_OFFSET + 7) & -8;
4287 apparent_fsize += n_regs * 4;
4288 actual_fsize = apparent_fsize + ((outgoing_args_size + 7) & -8);
4291 /* Make sure nothing can clobber our register windows.
4292 If a SAVE must be done, or there is a stack-local variable,
4293 the register window area must be allocated.
4294 ??? For v8 we apparently need an additional 8 bytes of reserved space. */
4295 if (! leaf_function_p || size > 0)
4296 actual_fsize += (16 * UNITS_PER_WORD) + (TARGET_ARCH64 ? 0 : 8);
4298 return SPARC_STACK_ALIGN (actual_fsize);
4301 /* Output any necessary .register pseudo-ops. */
4304 sparc_output_scratch_registers (FILE *file ATTRIBUTE_UNUSED)
4306 #ifdef HAVE_AS_REGISTER_PSEUDO_OP
4312 /* Check if %g[2367] were used without
4313 .register being printed for them already. */
4314 for (i = 2; i < 8; i++)
4316 if (regs_ever_live [i]
4317 && ! sparc_hard_reg_printed [i])
4319 sparc_hard_reg_printed [i] = 1;
4320 fprintf (file, "\t.register\t%%g%d, #scratch\n", i);
4327 /* Save/restore call-saved registers from LOW to HIGH at BASE+OFFSET
4328 as needed. LOW should be double-word aligned for 32-bit registers.
4329 Return the new OFFSET. */
4332 #define SORR_RESTORE 1
4335 save_or_restore_regs (int low, int high, rtx base, int offset, int action)
4340 if (TARGET_ARCH64 && high <= 32)
4342 for (i = low; i < high; i++)
4344 if (regs_ever_live[i] && ! call_used_regs[i])
4346 mem = gen_rtx_MEM (DImode, plus_constant (base, offset));
4347 set_mem_alias_set (mem, sparc_sr_alias_set);
4348 if (action == SORR_SAVE)
4350 insn = emit_move_insn (mem, gen_rtx_REG (DImode, i));
4351 RTX_FRAME_RELATED_P (insn) = 1;
4353 else /* action == SORR_RESTORE */
4354 emit_move_insn (gen_rtx_REG (DImode, i), mem);
4361 for (i = low; i < high; i += 2)
4363 bool reg0 = regs_ever_live[i] && ! call_used_regs[i];
4364 bool reg1 = regs_ever_live[i+1] && ! call_used_regs[i+1];
4365 enum machine_mode mode;
4370 mode = i < 32 ? DImode : DFmode;
4375 mode = i < 32 ? SImode : SFmode;
4380 mode = i < 32 ? SImode : SFmode;
4387 mem = gen_rtx_MEM (mode, plus_constant (base, offset));
4388 set_mem_alias_set (mem, sparc_sr_alias_set);
4389 if (action == SORR_SAVE)
4391 insn = emit_move_insn (mem, gen_rtx_REG (mode, regno));
4392 RTX_FRAME_RELATED_P (insn) = 1;
4394 else /* action == SORR_RESTORE */
4395 emit_move_insn (gen_rtx_REG (mode, regno), mem);
4397 /* Always preserve double-word alignment. */
4398 offset = (offset + 7) & -8;
4405 /* Emit code to save call-saved registers. */
4408 emit_save_regs (void)
4410 HOST_WIDE_INT offset;
4413 offset = frame_base_offset - apparent_fsize;
4415 if (offset < -4096 || offset + num_gfregs * 4 > 4096)
4417 /* ??? This might be optimized a little as %g1 might already have a
4418 value close enough that a single add insn will do. */
4419 /* ??? Although, all of this is probably only a temporary fix
4420 because if %g1 can hold a function result, then
4421 sparc_expand_epilogue will lose (the result will be
4423 base = gen_rtx_REG (Pmode, 1);
4424 emit_move_insn (base, GEN_INT (offset));
4425 emit_insn (gen_rtx_SET (VOIDmode,
4427 gen_rtx_PLUS (Pmode, frame_base_reg, base)));
4431 base = frame_base_reg;
4433 offset = save_or_restore_regs (0, 8, base, offset, SORR_SAVE);
4434 save_or_restore_regs (32, TARGET_V9 ? 96 : 64, base, offset, SORR_SAVE);
4437 /* Emit code to restore call-saved registers. */
4440 emit_restore_regs (void)
4442 HOST_WIDE_INT offset;
4445 offset = frame_base_offset - apparent_fsize;
4447 if (offset < -4096 || offset + num_gfregs * 4 > 4096 - 8 /*double*/)
4449 base = gen_rtx_REG (Pmode, 1);
4450 emit_move_insn (base, GEN_INT (offset));
4451 emit_insn (gen_rtx_SET (VOIDmode,
4453 gen_rtx_PLUS (Pmode, frame_base_reg, base)));
4457 base = frame_base_reg;
4459 offset = save_or_restore_regs (0, 8, base, offset, SORR_RESTORE);
4460 save_or_restore_regs (32, TARGET_V9 ? 96 : 64, base, offset, SORR_RESTORE);
4463 /* Generate a save_register_window insn. */
4466 gen_save_register_window (rtx increment)
4469 return gen_save_register_windowdi (increment);
4471 return gen_save_register_windowsi (increment);
4474 /* Generate an increment for the stack pointer. */
4477 gen_stack_pointer_inc (rtx increment)
4480 return gen_adddi3 (stack_pointer_rtx, stack_pointer_rtx, increment);
4482 return gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx, increment);
4485 /* Generate a decrement for the stack pointer. */
4488 gen_stack_pointer_dec (rtx decrement)
4491 return gen_subdi3 (stack_pointer_rtx, stack_pointer_rtx, decrement);
4493 return gen_subsi3 (stack_pointer_rtx, stack_pointer_rtx, decrement);
4496 /* Expand the function prologue. The prologue is responsible for reserving
4497 storage for the frame, saving the call-saved registers and loading the
4498 PIC register if needed. */
4501 sparc_expand_prologue (void)
4506 /* Compute a snapshot of current_function_uses_only_leaf_regs. Relying
4507 on the final value of the flag means deferring the prologue/epilogue
4508 expansion until just before the second scheduling pass, which is too
4509 late to emit multiple epilogues or return insns.
4511 Of course we are making the assumption that the value of the flag
4512 will not change between now and its final value. Of the three parts
4513 of the formula, only the last one can reasonably vary. Let's take a
4514 closer look, after assuming that the first two ones are set to true
4515 (otherwise the last value is effectively silenced).
4517 If only_leaf_regs_used returns false, the global predicate will also
4518 be false so the actual frame size calculated below will be positive.
4519 As a consequence, the save_register_window insn will be emitted in
4520 the instruction stream; now this insn explicitly references %fp
4521 which is not a leaf register so only_leaf_regs_used will always
4522 return false subsequently.
4524 If only_leaf_regs_used returns true, we hope that the subsequent
4525 optimization passes won't cause non-leaf registers to pop up. For
4526 example, the regrename pass has special provisions to not rename to
4527 non-leaf registers in a leaf function. */
4528 sparc_leaf_function_p
4529 = optimize > 0 && leaf_function_p () && only_leaf_regs_used ();
4531 /* Need to use actual_fsize, since we are also allocating
4532 space for our callee (and our own register save area). */
4534 = sparc_compute_frame_size (get_frame_size(), sparc_leaf_function_p);
4536 /* Advertise that the data calculated just above are now valid. */
4537 sparc_prologue_data_valid_p = true;
4539 if (sparc_leaf_function_p)
4541 frame_base_reg = stack_pointer_rtx;
4542 frame_base_offset = actual_fsize + SPARC_STACK_BIAS;
4546 frame_base_reg = hard_frame_pointer_rtx;
4547 frame_base_offset = SPARC_STACK_BIAS;
4550 if (actual_fsize == 0)
4552 else if (sparc_leaf_function_p)
4554 if (actual_fsize <= 4096)
4555 insn = emit_insn (gen_stack_pointer_inc (GEN_INT (-actual_fsize)));
4556 else if (actual_fsize <= 8192)
4558 insn = emit_insn (gen_stack_pointer_inc (GEN_INT (-4096)));
4559 /* %sp is still the CFA register. */
4560 RTX_FRAME_RELATED_P (insn) = 1;
4562 = emit_insn (gen_stack_pointer_inc (GEN_INT (4096-actual_fsize)));
4566 rtx reg = gen_rtx_REG (Pmode, 1);
4567 emit_move_insn (reg, GEN_INT (-actual_fsize));
4568 insn = emit_insn (gen_stack_pointer_inc (reg));
4570 gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
4571 PATTERN (gen_stack_pointer_inc (GEN_INT (-actual_fsize))),
4575 RTX_FRAME_RELATED_P (insn) = 1;
4579 if (actual_fsize <= 4096)
4580 insn = emit_insn (gen_save_register_window (GEN_INT (-actual_fsize)));
4581 else if (actual_fsize <= 8192)
4583 insn = emit_insn (gen_save_register_window (GEN_INT (-4096)));
4584 /* %sp is not the CFA register anymore. */
4585 emit_insn (gen_stack_pointer_inc (GEN_INT (4096-actual_fsize)));
4589 rtx reg = gen_rtx_REG (Pmode, 1);
4590 emit_move_insn (reg, GEN_INT (-actual_fsize));
4591 insn = emit_insn (gen_save_register_window (reg));
4594 RTX_FRAME_RELATED_P (insn) = 1;
4595 for (i=0; i < XVECLEN (PATTERN (insn), 0); i++)
4596 RTX_FRAME_RELATED_P (XVECEXP (PATTERN (insn), 0, i)) = 1;
4599 /* Call-saved registers are saved just above the outgoing argument area. */
4603 /* Load the PIC register if needed. */
4604 if (flag_pic && current_function_uses_pic_offset_table)
4605 load_pic_register (false);
4608 /* This function generates the assembly code for function entry, which boils
4609 down to emitting the necessary .register directives.
4611 ??? Historical cruft: "On SPARC, move-double insns between fpu and cpu need
4612 an 8-byte block of memory. If any fpu reg is used in the function, we
4613 allocate such a block here, at the bottom of the frame, just in case it's
4614 needed." Could this explain the -8 in emit_restore_regs? */
4617 sparc_asm_function_prologue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED)
4619 /* Check that the assumption we made in sparc_expand_prologue is valid. */
4620 gcc_assert (sparc_leaf_function_p == current_function_uses_only_leaf_regs);
4622 sparc_output_scratch_registers (file);
4625 /* Expand the function epilogue, either normal or part of a sibcall.
4626 We emit all the instructions except the return or the call. */
4629 sparc_expand_epilogue (void)
4632 emit_restore_regs ();
4634 if (actual_fsize == 0)
4636 else if (sparc_leaf_function_p)
4638 if (actual_fsize <= 4096)
4639 emit_insn (gen_stack_pointer_dec (GEN_INT (- actual_fsize)));
4640 else if (actual_fsize <= 8192)
4642 emit_insn (gen_stack_pointer_dec (GEN_INT (-4096)));
4643 emit_insn (gen_stack_pointer_dec (GEN_INT (4096 - actual_fsize)));
4647 rtx reg = gen_rtx_REG (Pmode, 1);
4648 emit_move_insn (reg, GEN_INT (-actual_fsize));
4649 emit_insn (gen_stack_pointer_dec (reg));
4654 /* Return true if it is appropriate to emit `return' instructions in the
4655 body of a function. */
4658 sparc_can_use_return_insn_p (void)
4660 return sparc_prologue_data_valid_p
4661 && (actual_fsize == 0 || !sparc_leaf_function_p);
4664 /* This function generates the assembly code for function exit. */
4667 sparc_asm_function_epilogue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED)
4669 /* If code does not drop into the epilogue, we have to still output
4670 a dummy nop for the sake of sane backtraces. Otherwise, if the
4671 last two instructions of a function were "call foo; dslot;" this
4672 can make the return PC of foo (i.e. address of call instruction
4673 plus 8) point to the first instruction in the next function. */
4675 rtx insn, last_real_insn;
4677 insn = get_last_insn ();
4679 last_real_insn = prev_real_insn (insn);
4681 && GET_CODE (last_real_insn) == INSN
4682 && GET_CODE (PATTERN (last_real_insn)) == SEQUENCE)
4683 last_real_insn = XVECEXP (PATTERN (last_real_insn), 0, 0);
4685 if (last_real_insn && GET_CODE (last_real_insn) == CALL_INSN)
4686 fputs("\tnop\n", file);
4688 sparc_output_deferred_case_vectors ();
4691 /* Output a 'restore' instruction. */
4694 output_restore (rtx pat)
4700 fputs ("\t restore\n", asm_out_file);
4704 gcc_assert (GET_CODE (pat) == SET);
4706 operands[0] = SET_DEST (pat);
4707 pat = SET_SRC (pat);
4709 switch (GET_CODE (pat))
4712 operands[1] = XEXP (pat, 0);
4713 operands[2] = XEXP (pat, 1);
4714 output_asm_insn (" restore %r1, %2, %Y0", operands);
4717 operands[1] = XEXP (pat, 0);
4718 operands[2] = XEXP (pat, 1);
4719 output_asm_insn (" restore %r1, %%lo(%a2), %Y0", operands);
4722 operands[1] = XEXP (pat, 0);
4723 gcc_assert (XEXP (pat, 1) == const1_rtx);
4724 output_asm_insn (" restore %r1, %r1, %Y0", operands);
4728 output_asm_insn (" restore %%g0, %1, %Y0", operands);
4733 /* Output a return. */
4736 output_return (rtx insn)
4738 if (sparc_leaf_function_p)
4740 /* This is a leaf function so we don't have to bother restoring the
4741 register window, which frees us from dealing with the convoluted
4742 semantics of restore/return. We simply output the jump to the
4743 return address and the insn in the delay slot (if any). */
4745 gcc_assert (! current_function_calls_eh_return);
4747 return "jmp\t%%o7+%)%#";
4751 /* This is a regular function so we have to restore the register window.
4752 We may have a pending insn for the delay slot, which will be either
4753 combined with the 'restore' instruction or put in the delay slot of
4754 the 'return' instruction. */
4756 if (current_function_calls_eh_return)
4758 /* If the function uses __builtin_eh_return, the eh_return
4759 machinery occupies the delay slot. */
4760 gcc_assert (! final_sequence);
4762 if (! flag_delayed_branch)
4763 fputs ("\tadd\t%fp, %g1, %fp\n", asm_out_file);
4766 fputs ("\treturn\t%i7+8\n", asm_out_file);
4768 fputs ("\trestore\n\tjmp\t%o7+8\n", asm_out_file);
4770 if (flag_delayed_branch)
4771 fputs ("\t add\t%sp, %g1, %sp\n", asm_out_file);
4773 fputs ("\t nop\n", asm_out_file);
4775 else if (final_sequence)
4779 delay = NEXT_INSN (insn);
4782 pat = PATTERN (delay);
4784 if (TARGET_V9 && ! epilogue_renumber (&pat, 1))
4786 epilogue_renumber (&pat, 0);
4787 return "return\t%%i7+%)%#";
4791 output_asm_insn ("jmp\t%%i7+%)", NULL);
4792 output_restore (pat);
4793 PATTERN (delay) = gen_blockage ();
4794 INSN_CODE (delay) = -1;
4799 /* The delay slot is empty. */
4801 return "return\t%%i7+%)\n\t nop";
4802 else if (flag_delayed_branch)
4803 return "jmp\t%%i7+%)\n\t restore";
4805 return "restore\n\tjmp\t%%o7+%)\n\t nop";
4812 /* Output a sibling call. */
4815 output_sibcall (rtx insn, rtx call_operand)
4819 gcc_assert (flag_delayed_branch);
4821 operands[0] = call_operand;
4823 if (sparc_leaf_function_p)
4825 /* This is a leaf function so we don't have to bother restoring the
4826 register window. We simply output the jump to the function and
4827 the insn in the delay slot (if any). */
4829 gcc_assert (!(LEAF_SIBCALL_SLOT_RESERVED_P && final_sequence));
4832 output_asm_insn ("sethi\t%%hi(%a0), %%g1\n\tjmp\t%%g1 + %%lo(%a0)%#",
4835 /* Use or with rs2 %%g0 instead of mov, so that as/ld can optimize
4836 it into branch if possible. */
4837 output_asm_insn ("or\t%%o7, %%g0, %%g1\n\tcall\t%a0, 0\n\t or\t%%g1, %%g0, %%o7",
4842 /* This is a regular function so we have to restore the register window.
4843 We may have a pending insn for the delay slot, which will be combined
4844 with the 'restore' instruction. */
4846 output_asm_insn ("call\t%a0, 0", operands);
4850 rtx delay = NEXT_INSN (insn);
4853 output_restore (PATTERN (delay));
4855 PATTERN (delay) = gen_blockage ();
4856 INSN_CODE (delay) = -1;
4859 output_restore (NULL_RTX);
4865 /* Functions for handling argument passing.
4867 For 32-bit, the first 6 args are normally in registers and the rest are
4868 pushed. Any arg that starts within the first 6 words is at least
4869 partially passed in a register unless its data type forbids.
4871 For 64-bit, the argument registers are laid out as an array of 16 elements
4872 and arguments are added sequentially. The first 6 int args and up to the
4873 first 16 fp args (depending on size) are passed in regs.
4875 Slot Stack Integral Float Float in structure Double Long Double
4876 ---- ----- -------- ----- ------------------ ------ -----------
4877 15 [SP+248] %f31 %f30,%f31 %d30
4878 14 [SP+240] %f29 %f28,%f29 %d28 %q28
4879 13 [SP+232] %f27 %f26,%f27 %d26
4880 12 [SP+224] %f25 %f24,%f25 %d24 %q24
4881 11 [SP+216] %f23 %f22,%f23 %d22
4882 10 [SP+208] %f21 %f20,%f21 %d20 %q20
4883 9 [SP+200] %f19 %f18,%f19 %d18
4884 8 [SP+192] %f17 %f16,%f17 %d16 %q16
4885 7 [SP+184] %f15 %f14,%f15 %d14
4886 6 [SP+176] %f13 %f12,%f13 %d12 %q12
4887 5 [SP+168] %o5 %f11 %f10,%f11 %d10
4888 4 [SP+160] %o4 %f9 %f8,%f9 %d8 %q8
4889 3 [SP+152] %o3 %f7 %f6,%f7 %d6
4890 2 [SP+144] %o2 %f5 %f4,%f5 %d4 %q4
4891 1 [SP+136] %o1 %f3 %f2,%f3 %d2
4892 0 [SP+128] %o0 %f1 %f0,%f1 %d0 %q0
4894 Here SP = %sp if -mno-stack-bias or %sp+stack_bias otherwise.
4896 Integral arguments are always passed as 64-bit quantities appropriately
4899 Passing of floating point values is handled as follows.
4900 If a prototype is in scope:
4901 If the value is in a named argument (i.e. not a stdarg function or a
4902 value not part of the `...') then the value is passed in the appropriate
4904 If the value is part of the `...' and is passed in one of the first 6
4905 slots then the value is passed in the appropriate int reg.
4906 If the value is part of the `...' and is not passed in one of the first 6
4907 slots then the value is passed in memory.
4908 If a prototype is not in scope:
4909 If the value is one of the first 6 arguments the value is passed in the
4910 appropriate integer reg and the appropriate fp reg.
4911 If the value is not one of the first 6 arguments the value is passed in
4912 the appropriate fp reg and in memory.
4915 Summary of the calling conventions implemented by GCC on SPARC:
4918 size argument return value
4920 small integer <4 int. reg. int. reg.
4921 word 4 int. reg. int. reg.
4922 double word 8 int. reg. int. reg.
4924 _Complex small integer <8 int. reg. int. reg.
4925 _Complex word 8 int. reg. int. reg.
4926 _Complex double word 16 memory int. reg.
4928 vector integer <=8 int. reg. FP reg.
4929 vector integer >8 memory memory
4931 float 4 int. reg. FP reg.
4932 double 8 int. reg. FP reg.
4933 long double 16 memory memory
4935 _Complex float 8 memory FP reg.
4936 _Complex double 16 memory FP reg.
4937 _Complex long double 32 memory FP reg.
4939 vector float any memory memory
4941 aggregate any memory memory
4946 size argument return value
4948 small integer <8 int. reg. int. reg.
4949 word 8 int. reg. int. reg.
4950 double word 16 int. reg. int. reg.
4952 _Complex small integer <16 int. reg. int. reg.
4953 _Complex word 16 int. reg. int. reg.
4954 _Complex double word 32 memory int. reg.
4956 vector integer <=16 FP reg. FP reg.
4957 vector integer 16<s<=32 memory FP reg.
4958 vector integer >32 memory memory
4960 float 4 FP reg. FP reg.
4961 double 8 FP reg. FP reg.
4962 long double 16 FP reg. FP reg.
4964 _Complex float 8 FP reg. FP reg.
4965 _Complex double 16 FP reg. FP reg.
4966 _Complex long double 32 memory FP reg.
4968 vector float <=16 FP reg. FP reg.
4969 vector float 16<s<=32 memory FP reg.
4970 vector float >32 memory memory
4972 aggregate <=16 reg. reg.
4973 aggregate 16<s<=32 memory reg.
4974 aggregate >32 memory memory
4978 Note #1: complex floating-point types follow the extended SPARC ABIs as
4979 implemented by the Sun compiler.
4981 Note #2: integral vector types follow the scalar floating-point types
4982 conventions to match what is implemented by the Sun VIS SDK.
4984 Note #3: floating-point vector types follow the aggregate types
4988 /* Maximum number of int regs for args. */
4989 #define SPARC_INT_ARG_MAX 6
4990 /* Maximum number of fp regs for args. */
4991 #define SPARC_FP_ARG_MAX 16
4993 #define ROUND_ADVANCE(SIZE) (((SIZE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
4995 /* Handle the INIT_CUMULATIVE_ARGS macro.
4996 Initialize a variable CUM of type CUMULATIVE_ARGS
4997 for a call to a function whose data type is FNTYPE.
4998 For a library call, FNTYPE is 0. */
5001 init_cumulative_args (struct sparc_args *cum, tree fntype,
5002 rtx libname ATTRIBUTE_UNUSED,
5003 tree fndecl ATTRIBUTE_UNUSED)
5006 cum->prototype_p = fntype && TYPE_ARG_TYPES (fntype);
5007 cum->libcall_p = fntype == 0;
5010 /* Handle the TARGET_PROMOTE_PROTOTYPES target hook.
5011 When a prototype says `char' or `short', really pass an `int'. */
5014 sparc_promote_prototypes (tree fntype ATTRIBUTE_UNUSED)
5016 return TARGET_ARCH32 ? true : false;
5019 /* Handle the TARGET_STRICT_ARGUMENT_NAMING target hook. */
5022 sparc_strict_argument_naming (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED)
5024 return TARGET_ARCH64 ? true : false;
5027 /* Scan the record type TYPE and return the following predicates:
5028 - INTREGS_P: the record contains at least one field or sub-field
5029 that is eligible for promotion in integer registers.
5030 - FP_REGS_P: the record contains at least one field or sub-field
5031 that is eligible for promotion in floating-point registers.
5032 - PACKED_P: the record contains at least one field that is packed.
5034 Sub-fields are not taken into account for the PACKED_P predicate. */
5037 scan_record_type (tree type, int *intregs_p, int *fpregs_p, int *packed_p)
5041 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
5043 if (TREE_CODE (field) == FIELD_DECL)
5045 if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE)
5046 scan_record_type (TREE_TYPE (field), intregs_p, fpregs_p, 0);
5047 else if ((FLOAT_TYPE_P (TREE_TYPE (field))
5048 || TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE)
5054 if (packed_p && DECL_PACKED (field))
5060 /* Compute the slot number to pass an argument in.
5061 Return the slot number or -1 if passing on the stack.
5063 CUM is a variable of type CUMULATIVE_ARGS which gives info about
5064 the preceding args and about the function being called.
5065 MODE is the argument's machine mode.
5066 TYPE is the data type of the argument (as a tree).
5067 This is null for libcalls where that information may
5069 NAMED is nonzero if this argument is a named parameter
5070 (otherwise it is an extra parameter matching an ellipsis).
5071 INCOMING_P is zero for FUNCTION_ARG, nonzero for FUNCTION_INCOMING_ARG.
5072 *PREGNO records the register number to use if scalar type.
5073 *PPADDING records the amount of padding needed in words. */
5076 function_arg_slotno (const struct sparc_args *cum, enum machine_mode mode,
5077 tree type, int named, int incoming_p,
5078 int *pregno, int *ppadding)
5080 int regbase = (incoming_p
5081 ? SPARC_INCOMING_INT_ARG_FIRST
5082 : SPARC_OUTGOING_INT_ARG_FIRST);
5083 int slotno = cum->words;
5084 enum mode_class mclass;
5089 if (type && TREE_ADDRESSABLE (type))
5095 && TYPE_ALIGN (type) % PARM_BOUNDARY != 0)
5098 /* For SPARC64, objects requiring 16-byte alignment get it. */
5100 && GET_MODE_ALIGNMENT (mode) >= 2 * BITS_PER_WORD
5101 && (slotno & 1) != 0)
5102 slotno++, *ppadding = 1;
5104 mclass = GET_MODE_CLASS (mode);
5105 if (type && TREE_CODE (type) == VECTOR_TYPE)
5107 /* Vector types deserve special treatment because they are
5108 polymorphic wrt their mode, depending upon whether VIS
5109 instructions are enabled. */
5110 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
5112 /* The SPARC port defines no floating-point vector modes. */
5113 gcc_assert (mode == BLKmode);
5117 /* Integral vector types should either have a vector
5118 mode or an integral mode, because we are guaranteed
5119 by pass_by_reference that their size is not greater
5120 than 16 bytes and TImode is 16-byte wide. */
5121 gcc_assert (mode != BLKmode);
5123 /* Vector integers are handled like floats according to
5125 mclass = MODE_FLOAT;
5132 case MODE_COMPLEX_FLOAT:
5133 if (TARGET_ARCH64 && TARGET_FPU && named)
5135 if (slotno >= SPARC_FP_ARG_MAX)
5137 regno = SPARC_FP_ARG_FIRST + slotno * 2;
5138 /* Arguments filling only one single FP register are
5139 right-justified in the outer double FP register. */
5140 if (GET_MODE_SIZE (mode) <= 4)
5147 case MODE_COMPLEX_INT:
5148 if (slotno >= SPARC_INT_ARG_MAX)
5150 regno = regbase + slotno;
5154 if (mode == VOIDmode)
5155 /* MODE is VOIDmode when generating the actual call. */
5158 gcc_assert (mode == BLKmode);
5160 /* For SPARC64, objects requiring 16-byte alignment get it. */
5163 && TYPE_ALIGN (type) >= 2 * BITS_PER_WORD
5164 && (slotno & 1) != 0)
5165 slotno++, *ppadding = 1;
5167 if (TARGET_ARCH32 || !type || (TREE_CODE (type) == UNION_TYPE))
5169 if (slotno >= SPARC_INT_ARG_MAX)
5171 regno = regbase + slotno;
5173 else /* TARGET_ARCH64 && type */
5175 int intregs_p = 0, fpregs_p = 0, packed_p = 0;
5177 /* First see what kinds of registers we would need. */
5178 if (TREE_CODE (type) == VECTOR_TYPE)
5181 scan_record_type (type, &intregs_p, &fpregs_p, &packed_p);
5183 /* The ABI obviously doesn't specify how packed structures
5184 are passed. These are defined to be passed in int regs
5185 if possible, otherwise memory. */
5186 if (packed_p || !named)
5187 fpregs_p = 0, intregs_p = 1;
5189 /* If all arg slots are filled, then must pass on stack. */
5190 if (fpregs_p && slotno >= SPARC_FP_ARG_MAX)
5193 /* If there are only int args and all int arg slots are filled,
5194 then must pass on stack. */
5195 if (!fpregs_p && intregs_p && slotno >= SPARC_INT_ARG_MAX)
5198 /* Note that even if all int arg slots are filled, fp members may
5199 still be passed in regs if such regs are available.
5200 *PREGNO isn't set because there may be more than one, it's up
5201 to the caller to compute them. */
5214 /* Handle recursive register counting for structure field layout. */
5216 struct function_arg_record_value_parms
5218 rtx ret; /* return expression being built. */
5219 int slotno; /* slot number of the argument. */
5220 int named; /* whether the argument is named. */
5221 int regbase; /* regno of the base register. */
5222 int stack; /* 1 if part of the argument is on the stack. */
5223 int intoffset; /* offset of the first pending integer field. */
5224 unsigned int nregs; /* number of words passed in registers. */
5227 static void function_arg_record_value_3
5228 (HOST_WIDE_INT, struct function_arg_record_value_parms *);
5229 static void function_arg_record_value_2
5230 (tree, HOST_WIDE_INT, struct function_arg_record_value_parms *, bool);
5231 static void function_arg_record_value_1
5232 (tree, HOST_WIDE_INT, struct function_arg_record_value_parms *, bool);
5233 static rtx function_arg_record_value (tree, enum machine_mode, int, int, int);
5234 static rtx function_arg_union_value (int, enum machine_mode, int, int);
5236 /* A subroutine of function_arg_record_value. Traverse the structure
5237 recursively and determine how many registers will be required. */
5240 function_arg_record_value_1 (tree type, HOST_WIDE_INT startbitpos,
5241 struct function_arg_record_value_parms *parms,
5246 /* We need to compute how many registers are needed so we can
5247 allocate the PARALLEL but before we can do that we need to know
5248 whether there are any packed fields. The ABI obviously doesn't
5249 specify how structures are passed in this case, so they are
5250 defined to be passed in int regs if possible, otherwise memory,
5251 regardless of whether there are fp values present. */
5254 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
5256 if (TREE_CODE (field) == FIELD_DECL && DECL_PACKED (field))
5263 /* Compute how many registers we need. */
5264 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
5266 if (TREE_CODE (field) == FIELD_DECL)
5268 HOST_WIDE_INT bitpos = startbitpos;
5270 if (DECL_SIZE (field) != 0)
5272 if (integer_zerop (DECL_SIZE (field)))
5275 if (host_integerp (bit_position (field), 1))
5276 bitpos += int_bit_position (field);
5279 /* ??? FIXME: else assume zero offset. */
5281 if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE)
5282 function_arg_record_value_1 (TREE_TYPE (field),
5286 else if ((FLOAT_TYPE_P (TREE_TYPE (field))
5287 || TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE)
5292 if (parms->intoffset != -1)
5294 unsigned int startbit, endbit;
5295 int intslots, this_slotno;
5297 startbit = parms->intoffset & -BITS_PER_WORD;
5298 endbit = (bitpos + BITS_PER_WORD - 1) & -BITS_PER_WORD;
5300 intslots = (endbit - startbit) / BITS_PER_WORD;
5301 this_slotno = parms->slotno + parms->intoffset
5304 if (intslots > 0 && intslots > SPARC_INT_ARG_MAX - this_slotno)
5306 intslots = MAX (0, SPARC_INT_ARG_MAX - this_slotno);
5307 /* We need to pass this field on the stack. */
5311 parms->nregs += intslots;
5312 parms->intoffset = -1;
5315 /* There's no need to check this_slotno < SPARC_FP_ARG MAX.
5316 If it wasn't true we wouldn't be here. */
5317 if (TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE
5318 && DECL_MODE (field) == BLKmode)
5319 parms->nregs += TYPE_VECTOR_SUBPARTS (TREE_TYPE (field));
5320 else if (TREE_CODE (TREE_TYPE (field)) == COMPLEX_TYPE)
5327 if (parms->intoffset == -1)
5328 parms->intoffset = bitpos;
5334 /* A subroutine of function_arg_record_value. Assign the bits of the
5335 structure between parms->intoffset and bitpos to integer registers. */
5338 function_arg_record_value_3 (HOST_WIDE_INT bitpos,
5339 struct function_arg_record_value_parms *parms)
5341 enum machine_mode mode;
5343 unsigned int startbit, endbit;
5344 int this_slotno, intslots, intoffset;
5347 if (parms->intoffset == -1)
5350 intoffset = parms->intoffset;
5351 parms->intoffset = -1;
5353 startbit = intoffset & -BITS_PER_WORD;
5354 endbit = (bitpos + BITS_PER_WORD - 1) & -BITS_PER_WORD;
5355 intslots = (endbit - startbit) / BITS_PER_WORD;
5356 this_slotno = parms->slotno + intoffset / BITS_PER_WORD;
5358 intslots = MIN (intslots, SPARC_INT_ARG_MAX - this_slotno);
5362 /* If this is the trailing part of a word, only load that much into
5363 the register. Otherwise load the whole register. Note that in
5364 the latter case we may pick up unwanted bits. It's not a problem
5365 at the moment but may wish to revisit. */
5367 if (intoffset % BITS_PER_WORD != 0)
5368 mode = smallest_mode_for_size (BITS_PER_WORD - intoffset % BITS_PER_WORD,
5373 intoffset /= BITS_PER_UNIT;
5376 regno = parms->regbase + this_slotno;
5377 reg = gen_rtx_REG (mode, regno);
5378 XVECEXP (parms->ret, 0, parms->stack + parms->nregs)
5379 = gen_rtx_EXPR_LIST (VOIDmode, reg, GEN_INT (intoffset));
5382 intoffset = (intoffset | (UNITS_PER_WORD-1)) + 1;
5387 while (intslots > 0);
5390 /* A subroutine of function_arg_record_value. Traverse the structure
5391 recursively and assign bits to floating point registers. Track which
5392 bits in between need integer registers; invoke function_arg_record_value_3
5393 to make that happen. */
5396 function_arg_record_value_2 (tree type, HOST_WIDE_INT startbitpos,
5397 struct function_arg_record_value_parms *parms,
5403 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
5405 if (TREE_CODE (field) == FIELD_DECL && DECL_PACKED (field))
5412 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
5414 if (TREE_CODE (field) == FIELD_DECL)
5416 HOST_WIDE_INT bitpos = startbitpos;
5418 if (DECL_SIZE (field) != 0)
5420 if (integer_zerop (DECL_SIZE (field)))
5423 if (host_integerp (bit_position (field), 1))
5424 bitpos += int_bit_position (field);
5427 /* ??? FIXME: else assume zero offset. */
5429 if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE)
5430 function_arg_record_value_2 (TREE_TYPE (field),
5434 else if ((FLOAT_TYPE_P (TREE_TYPE (field))
5435 || TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE)
5440 int this_slotno = parms->slotno + bitpos / BITS_PER_WORD;
5441 int regno, nregs, pos;
5442 enum machine_mode mode = DECL_MODE (field);
5445 function_arg_record_value_3 (bitpos, parms);
5447 if (TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE
5450 mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (field)));
5451 nregs = TYPE_VECTOR_SUBPARTS (TREE_TYPE (field));
5453 else if (TREE_CODE (TREE_TYPE (field)) == COMPLEX_TYPE)
5455 mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (field)));
5461 regno = SPARC_FP_ARG_FIRST + this_slotno * 2;
5462 if (GET_MODE_SIZE (mode) <= 4 && (bitpos & 32) != 0)
5464 reg = gen_rtx_REG (mode, regno);
5465 pos = bitpos / BITS_PER_UNIT;
5466 XVECEXP (parms->ret, 0, parms->stack + parms->nregs)
5467 = gen_rtx_EXPR_LIST (VOIDmode, reg, GEN_INT (pos));
5471 regno += GET_MODE_SIZE (mode) / 4;
5472 reg = gen_rtx_REG (mode, regno);
5473 pos += GET_MODE_SIZE (mode);
5474 XVECEXP (parms->ret, 0, parms->stack + parms->nregs)
5475 = gen_rtx_EXPR_LIST (VOIDmode, reg, GEN_INT (pos));
5481 if (parms->intoffset == -1)
5482 parms->intoffset = bitpos;
5488 /* Used by function_arg and function_value to implement the complex
5489 conventions of the 64-bit ABI for passing and returning structures.
5490 Return an expression valid as a return value for the two macros
5491 FUNCTION_ARG and FUNCTION_VALUE.
5493 TYPE is the data type of the argument (as a tree).
5494 This is null for libcalls where that information may
5496 MODE is the argument's machine mode.
5497 SLOTNO is the index number of the argument's slot in the parameter array.
5498 NAMED is nonzero if this argument is a named parameter
5499 (otherwise it is an extra parameter matching an ellipsis).
5500 REGBASE is the regno of the base register for the parameter array. */
5503 function_arg_record_value (tree type, enum machine_mode mode,
5504 int slotno, int named, int regbase)
5506 HOST_WIDE_INT typesize = int_size_in_bytes (type);
5507 struct function_arg_record_value_parms parms;
5510 parms.ret = NULL_RTX;
5511 parms.slotno = slotno;
5512 parms.named = named;
5513 parms.regbase = regbase;
5516 /* Compute how many registers we need. */
5518 parms.intoffset = 0;
5519 function_arg_record_value_1 (type, 0, &parms, false);
5521 /* Take into account pending integer fields. */
5522 if (parms.intoffset != -1)
5524 unsigned int startbit, endbit;
5525 int intslots, this_slotno;
5527 startbit = parms.intoffset & -BITS_PER_WORD;
5528 endbit = (typesize*BITS_PER_UNIT + BITS_PER_WORD - 1) & -BITS_PER_WORD;
5529 intslots = (endbit - startbit) / BITS_PER_WORD;
5530 this_slotno = slotno + parms.intoffset / BITS_PER_WORD;
5532 if (intslots > 0 && intslots > SPARC_INT_ARG_MAX - this_slotno)
5534 intslots = MAX (0, SPARC_INT_ARG_MAX - this_slotno);
5535 /* We need to pass this field on the stack. */
5539 parms.nregs += intslots;
5541 nregs = parms.nregs;
5543 /* Allocate the vector and handle some annoying special cases. */
5546 /* ??? Empty structure has no value? Duh? */
5549 /* Though there's nothing really to store, return a word register
5550 anyway so the rest of gcc doesn't go nuts. Returning a PARALLEL
5551 leads to breakage due to the fact that there are zero bytes to
5553 return gen_rtx_REG (mode, regbase);
5557 /* ??? C++ has structures with no fields, and yet a size. Give up
5558 for now and pass everything back in integer registers. */
5559 nregs = (typesize + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
5561 if (nregs + slotno > SPARC_INT_ARG_MAX)
5562 nregs = SPARC_INT_ARG_MAX - slotno;
5564 gcc_assert (nregs != 0);
5566 parms.ret = gen_rtx_PARALLEL (mode, rtvec_alloc (parms.stack + nregs));
5568 /* If at least one field must be passed on the stack, generate
5569 (parallel [(expr_list (nil) ...) ...]) so that all fields will
5570 also be passed on the stack. We can't do much better because the
5571 semantics of TARGET_ARG_PARTIAL_BYTES doesn't handle the case
5572 of structures for which the fields passed exclusively in registers
5573 are not at the beginning of the structure. */
5575 XVECEXP (parms.ret, 0, 0)
5576 = gen_rtx_EXPR_LIST (VOIDmode, NULL_RTX, const0_rtx);
5578 /* Fill in the entries. */
5580 parms.intoffset = 0;
5581 function_arg_record_value_2 (type, 0, &parms, false);
5582 function_arg_record_value_3 (typesize * BITS_PER_UNIT, &parms);
5584 gcc_assert (parms.nregs == nregs);
5589 /* Used by function_arg and function_value to implement the conventions
5590 of the 64-bit ABI for passing and returning unions.
5591 Return an expression valid as a return value for the two macros
5592 FUNCTION_ARG and FUNCTION_VALUE.
5594 SIZE is the size in bytes of the union.
5595 MODE is the argument's machine mode.
5596 REGNO is the hard register the union will be passed in. */
5599 function_arg_union_value (int size, enum machine_mode mode, int slotno,
5602 int nwords = ROUND_ADVANCE (size), i;
5605 /* See comment in previous function for empty structures. */
5607 return gen_rtx_REG (mode, regno);
5609 if (slotno == SPARC_INT_ARG_MAX - 1)
5612 regs = gen_rtx_PARALLEL (mode, rtvec_alloc (nwords));
5614 for (i = 0; i < nwords; i++)
5616 /* Unions are passed left-justified. */
5617 XVECEXP (regs, 0, i)
5618 = gen_rtx_EXPR_LIST (VOIDmode,
5619 gen_rtx_REG (word_mode, regno),
5620 GEN_INT (UNITS_PER_WORD * i));
5627 /* Used by function_arg and function_value to implement the conventions
5628 for passing and returning large (BLKmode) vectors.
5629 Return an expression valid as a return value for the two macros
5630 FUNCTION_ARG and FUNCTION_VALUE.
5632 SIZE is the size in bytes of the vector.
5633 BASE_MODE is the argument's base machine mode.
5634 REGNO is the FP hard register the vector will be passed in. */
5637 function_arg_vector_value (int size, enum machine_mode base_mode, int regno)
5639 unsigned short base_mode_size = GET_MODE_SIZE (base_mode);
5640 int nregs = size / base_mode_size, i;
5643 regs = gen_rtx_PARALLEL (BLKmode, rtvec_alloc (nregs));
5645 for (i = 0; i < nregs; i++)
5647 XVECEXP (regs, 0, i)
5648 = gen_rtx_EXPR_LIST (VOIDmode,
5649 gen_rtx_REG (base_mode, regno),
5650 GEN_INT (base_mode_size * i));
5651 regno += base_mode_size / 4;
5657 /* Handle the FUNCTION_ARG macro.
5658 Determine where to put an argument to a function.
5659 Value is zero to push the argument on the stack,
5660 or a hard register in which to store the argument.
5662 CUM is a variable of type CUMULATIVE_ARGS which gives info about
5663 the preceding args and about the function being called.
5664 MODE is the argument's machine mode.
5665 TYPE is the data type of the argument (as a tree).
5666 This is null for libcalls where that information may
5668 NAMED is nonzero if this argument is a named parameter
5669 (otherwise it is an extra parameter matching an ellipsis).
5670 INCOMING_P is zero for FUNCTION_ARG, nonzero for FUNCTION_INCOMING_ARG. */
5673 function_arg (const struct sparc_args *cum, enum machine_mode mode,
5674 tree type, int named, int incoming_p)
5676 int regbase = (incoming_p
5677 ? SPARC_INCOMING_INT_ARG_FIRST
5678 : SPARC_OUTGOING_INT_ARG_FIRST);
5679 int slotno, regno, padding;
5680 enum mode_class mclass = GET_MODE_CLASS (mode);
5683 slotno = function_arg_slotno (cum, mode, type, named, incoming_p,
5691 reg = gen_rtx_REG (mode, regno);
5695 if (type && TREE_CODE (type) == RECORD_TYPE)
5697 /* Structures up to 16 bytes in size are passed in arg slots on the
5698 stack and are promoted to registers where possible. */
5700 gcc_assert (int_size_in_bytes (type) <= 16);
5702 return function_arg_record_value (type, mode, slotno, named, regbase);
5704 else if (type && TREE_CODE (type) == UNION_TYPE)
5706 HOST_WIDE_INT size = int_size_in_bytes (type);
5708 gcc_assert (size <= 16);
5710 return function_arg_union_value (size, mode, slotno, regno);
5712 else if (type && TREE_CODE (type) == VECTOR_TYPE)
5714 /* Vector types deserve special treatment because they are
5715 polymorphic wrt their mode, depending upon whether VIS
5716 instructions are enabled. */
5717 HOST_WIDE_INT size = int_size_in_bytes (type);
5719 gcc_assert (size <= 16);
5721 if (mode == BLKmode)
5722 return function_arg_vector_value (size,
5723 TYPE_MODE (TREE_TYPE (type)),
5724 SPARC_FP_ARG_FIRST + 2*slotno);
5726 mclass = MODE_FLOAT;
5729 /* v9 fp args in reg slots beyond the int reg slots get passed in regs
5730 but also have the slot allocated for them.
5731 If no prototype is in scope fp values in register slots get passed
5732 in two places, either fp regs and int regs or fp regs and memory. */
5733 if ((mclass == MODE_FLOAT || mclass == MODE_COMPLEX_FLOAT)
5734 && SPARC_FP_REG_P (regno))
5736 reg = gen_rtx_REG (mode, regno);
5737 if (cum->prototype_p || cum->libcall_p)
5739 /* "* 2" because fp reg numbers are recorded in 4 byte
5742 /* ??? This will cause the value to be passed in the fp reg and
5743 in the stack. When a prototype exists we want to pass the
5744 value in the reg but reserve space on the stack. That's an
5745 optimization, and is deferred [for a bit]. */
5746 if ((regno - SPARC_FP_ARG_FIRST) >= SPARC_INT_ARG_MAX * 2)
5747 return gen_rtx_PARALLEL (mode,
5749 gen_rtx_EXPR_LIST (VOIDmode,
5750 NULL_RTX, const0_rtx),
5751 gen_rtx_EXPR_LIST (VOIDmode,
5755 /* ??? It seems that passing back a register even when past
5756 the area declared by REG_PARM_STACK_SPACE will allocate
5757 space appropriately, and will not copy the data onto the
5758 stack, exactly as we desire.
5760 This is due to locate_and_pad_parm being called in
5761 expand_call whenever reg_parm_stack_space > 0, which
5762 while beneficial to our example here, would seem to be
5763 in error from what had been intended. Ho hum... -- r~ */
5771 if ((regno - SPARC_FP_ARG_FIRST) < SPARC_INT_ARG_MAX * 2)
5775 /* On incoming, we don't need to know that the value
5776 is passed in %f0 and %i0, and it confuses other parts
5777 causing needless spillage even on the simplest cases. */
5781 intreg = (SPARC_OUTGOING_INT_ARG_FIRST
5782 + (regno - SPARC_FP_ARG_FIRST) / 2);
5784 v0 = gen_rtx_EXPR_LIST (VOIDmode, reg, const0_rtx);
5785 v1 = gen_rtx_EXPR_LIST (VOIDmode, gen_rtx_REG (mode, intreg),
5787 return gen_rtx_PARALLEL (mode, gen_rtvec (2, v0, v1));
5791 v0 = gen_rtx_EXPR_LIST (VOIDmode, NULL_RTX, const0_rtx);
5792 v1 = gen_rtx_EXPR_LIST (VOIDmode, reg, const0_rtx);
5793 return gen_rtx_PARALLEL (mode, gen_rtvec (2, v0, v1));
5799 /* Scalar or complex int. */
5800 reg = gen_rtx_REG (mode, regno);
5806 /* For an arg passed partly in registers and partly in memory,
5807 this is the number of bytes of registers used.
5808 For args passed entirely in registers or entirely in memory, zero.
5810 Any arg that starts in the first 6 regs but won't entirely fit in them
5811 needs partial registers on v8. On v9, structures with integer
5812 values in arg slots 5,6 will be passed in %o5 and SP+176, and complex fp
5813 values that begin in the last fp reg [where "last fp reg" varies with the
5814 mode] will be split between that reg and memory. */
5817 sparc_arg_partial_bytes (CUMULATIVE_ARGS *cum, enum machine_mode mode,
5818 tree type, bool named)
5820 int slotno, regno, padding;
5822 /* We pass 0 for incoming_p here, it doesn't matter. */
5823 slotno = function_arg_slotno (cum, mode, type, named, 0, ®no, &padding);
5830 if ((slotno + (mode == BLKmode
5831 ? ROUND_ADVANCE (int_size_in_bytes (type))
5832 : ROUND_ADVANCE (GET_MODE_SIZE (mode))))
5833 > SPARC_INT_ARG_MAX)
5834 return (SPARC_INT_ARG_MAX - slotno) * UNITS_PER_WORD;
5838 /* We are guaranteed by pass_by_reference that the size of the
5839 argument is not greater than 16 bytes, so we only need to return
5840 one word if the argument is partially passed in registers. */
5842 if (type && AGGREGATE_TYPE_P (type))
5844 int size = int_size_in_bytes (type);
5846 if (size > UNITS_PER_WORD
5847 && slotno == SPARC_INT_ARG_MAX - 1)
5848 return UNITS_PER_WORD;
5850 else if (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT
5851 || (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
5852 && ! (TARGET_FPU && named)))
5854 /* The complex types are passed as packed types. */
5855 if (GET_MODE_SIZE (mode) > UNITS_PER_WORD
5856 && slotno == SPARC_INT_ARG_MAX - 1)
5857 return UNITS_PER_WORD;
5859 else if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
5861 if ((slotno + GET_MODE_SIZE (mode) / UNITS_PER_WORD)
5863 return UNITS_PER_WORD;
5870 /* Handle the TARGET_PASS_BY_REFERENCE target hook.
5871 Specify whether to pass the argument by reference. */
5874 sparc_pass_by_reference (CUMULATIVE_ARGS *cum ATTRIBUTE_UNUSED,
5875 enum machine_mode mode, tree type,
5876 bool named ATTRIBUTE_UNUSED)
5880 /* Original SPARC 32-bit ABI says that structures and unions,
5881 and quad-precision floats are passed by reference. For Pascal,
5882 also pass arrays by reference. All other base types are passed
5885 Extended ABI (as implemented by the Sun compiler) says that all
5886 complex floats are passed by reference. Pass complex integers
5887 in registers up to 8 bytes. More generally, enforce the 2-word
5888 cap for passing arguments in registers.
5890 Vector ABI (as implemented by the Sun VIS SDK) says that vector
5891 integers are passed like floats of the same size, that is in
5892 registers up to 8 bytes. Pass all vector floats by reference
5893 like structure and unions. */
5894 return ((type && (AGGREGATE_TYPE_P (type) || VECTOR_FLOAT_TYPE_P (type)))
5896 /* Catch CDImode, TFmode, DCmode and TCmode. */
5897 || GET_MODE_SIZE (mode) > 8
5899 && TREE_CODE (type) == VECTOR_TYPE
5900 && (unsigned HOST_WIDE_INT) int_size_in_bytes (type) > 8));
5904 /* Original SPARC 64-bit ABI says that structures and unions
5905 smaller than 16 bytes are passed in registers, as well as
5906 all other base types. For Pascal, pass arrays by reference.
5908 Extended ABI (as implemented by the Sun compiler) says that
5909 complex floats are passed in registers up to 16 bytes. Pass
5910 all complex integers in registers up to 16 bytes. More generally,
5911 enforce the 2-word cap for passing arguments in registers.
5913 Vector ABI (as implemented by the Sun VIS SDK) says that vector
5914 integers are passed like floats of the same size, that is in
5915 registers (up to 16 bytes). Pass all vector floats like structure
5917 return ((type && TREE_CODE (type) == ARRAY_TYPE)
5919 && (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == VECTOR_TYPE)
5920 && (unsigned HOST_WIDE_INT) int_size_in_bytes (type) > 16)
5921 /* Catch CTImode and TCmode. */
5922 || GET_MODE_SIZE (mode) > 16);
5926 /* Handle the FUNCTION_ARG_ADVANCE macro.
5927 Update the data in CUM to advance over an argument
5928 of mode MODE and data type TYPE.
5929 TYPE is null for libcalls where that information may not be available. */
5932 function_arg_advance (struct sparc_args *cum, enum machine_mode mode,
5933 tree type, int named)
5935 int slotno, regno, padding;
5937 /* We pass 0 for incoming_p here, it doesn't matter. */
5938 slotno = function_arg_slotno (cum, mode, type, named, 0, ®no, &padding);
5940 /* If register required leading padding, add it. */
5942 cum->words += padding;
5946 cum->words += (mode != BLKmode
5947 ? ROUND_ADVANCE (GET_MODE_SIZE (mode))
5948 : ROUND_ADVANCE (int_size_in_bytes (type)));
5952 if (type && AGGREGATE_TYPE_P (type))
5954 int size = int_size_in_bytes (type);
5958 else if (size <= 16)
5960 else /* passed by reference */
5965 cum->words += (mode != BLKmode
5966 ? ROUND_ADVANCE (GET_MODE_SIZE (mode))
5967 : ROUND_ADVANCE (int_size_in_bytes (type)));
5972 /* Handle the FUNCTION_ARG_PADDING macro.
5973 For the 64 bit ABI structs are always stored left shifted in their
5977 function_arg_padding (enum machine_mode mode, tree type)
5979 if (TARGET_ARCH64 && type != 0 && AGGREGATE_TYPE_P (type))
5982 /* Fall back to the default. */
5983 return DEFAULT_FUNCTION_ARG_PADDING (mode, type);
5986 /* Handle the TARGET_RETURN_IN_MEMORY target hook.
5987 Specify whether to return the return value in memory. */
5990 sparc_return_in_memory (tree type, tree fntype ATTRIBUTE_UNUSED)
5993 /* Original SPARC 32-bit ABI says that structures and unions,
5994 and quad-precision floats are returned in memory. All other
5995 base types are returned in registers.
5997 Extended ABI (as implemented by the Sun compiler) says that
5998 all complex floats are returned in registers (8 FP registers
5999 at most for '_Complex long double'). Return all complex integers
6000 in registers (4 at most for '_Complex long long').
6002 Vector ABI (as implemented by the Sun VIS SDK) says that vector
6003 integers are returned like floats of the same size, that is in
6004 registers up to 8 bytes and in memory otherwise. Return all
6005 vector floats in memory like structure and unions; note that
6006 they always have BLKmode like the latter. */
6007 return (TYPE_MODE (type) == BLKmode
6008 || TYPE_MODE (type) == TFmode
6009 || (TREE_CODE (type) == VECTOR_TYPE
6010 && (unsigned HOST_WIDE_INT) int_size_in_bytes (type) > 8));
6012 /* Original SPARC 64-bit ABI says that structures and unions
6013 smaller than 32 bytes are returned in registers, as well as
6014 all other base types.
6016 Extended ABI (as implemented by the Sun compiler) says that all
6017 complex floats are returned in registers (8 FP registers at most
6018 for '_Complex long double'). Return all complex integers in
6019 registers (4 at most for '_Complex TItype').
6021 Vector ABI (as implemented by the Sun VIS SDK) says that vector
6022 integers are returned like floats of the same size, that is in
6023 registers. Return all vector floats like structure and unions;
6024 note that they always have BLKmode like the latter. */
6025 return ((TYPE_MODE (type) == BLKmode
6026 && (unsigned HOST_WIDE_INT) int_size_in_bytes (type) > 32));
6029 /* Handle the TARGET_STRUCT_VALUE target hook.
6030 Return where to find the structure return value address. */
6033 sparc_struct_value_rtx (tree fndecl ATTRIBUTE_UNUSED, int incoming)
6042 mem = gen_rtx_MEM (Pmode, plus_constant (frame_pointer_rtx,
6043 STRUCT_VALUE_OFFSET));
6045 mem = gen_rtx_MEM (Pmode, plus_constant (stack_pointer_rtx,
6046 STRUCT_VALUE_OFFSET));
6048 set_mem_alias_set (mem, struct_value_alias_set);
6053 /* Handle FUNCTION_VALUE, FUNCTION_OUTGOING_VALUE, and LIBCALL_VALUE macros.
6054 For v9, function return values are subject to the same rules as arguments,
6055 except that up to 32 bytes may be returned in registers. */
6058 function_value (tree type, enum machine_mode mode, int incoming_p)
6060 /* Beware that the two values are swapped here wrt function_arg. */
6061 int regbase = (incoming_p
6062 ? SPARC_OUTGOING_INT_ARG_FIRST
6063 : SPARC_INCOMING_INT_ARG_FIRST);
6064 enum mode_class mclass = GET_MODE_CLASS (mode);
6067 if (type && TREE_CODE (type) == VECTOR_TYPE)
6069 /* Vector types deserve special treatment because they are
6070 polymorphic wrt their mode, depending upon whether VIS
6071 instructions are enabled. */
6072 HOST_WIDE_INT size = int_size_in_bytes (type);
6074 gcc_assert ((TARGET_ARCH32 && size <= 8)
6075 || (TARGET_ARCH64 && size <= 32));
6077 if (mode == BLKmode)
6078 return function_arg_vector_value (size,
6079 TYPE_MODE (TREE_TYPE (type)),
6080 SPARC_FP_ARG_FIRST);
6082 mclass = MODE_FLOAT;
6084 else if (type && TARGET_ARCH64)
6086 if (TREE_CODE (type) == RECORD_TYPE)
6088 /* Structures up to 32 bytes in size are passed in registers,
6089 promoted to fp registers where possible. */
6091 gcc_assert (int_size_in_bytes (type) <= 32);
6093 return function_arg_record_value (type, mode, 0, 1, regbase);
6095 else if (TREE_CODE (type) == UNION_TYPE)
6097 HOST_WIDE_INT size = int_size_in_bytes (type);
6099 gcc_assert (size <= 32);
6101 return function_arg_union_value (size, mode, 0, regbase);
6103 else if (AGGREGATE_TYPE_P (type))
6105 /* All other aggregate types are passed in an integer register
6106 in a mode corresponding to the size of the type. */
6107 HOST_WIDE_INT bytes = int_size_in_bytes (type);
6109 gcc_assert (bytes <= 32);
6111 mode = mode_for_size (bytes * BITS_PER_UNIT, MODE_INT, 0);
6113 /* ??? We probably should have made the same ABI change in
6114 3.4.0 as the one we made for unions. The latter was
6115 required by the SCD though, while the former is not
6116 specified, so we favored compatibility and efficiency.
6118 Now we're stuck for aggregates larger than 16 bytes,
6119 because OImode vanished in the meantime. Let's not
6120 try to be unduly clever, and simply follow the ABI
6121 for unions in that case. */
6122 if (mode == BLKmode)
6123 return function_arg_union_value (bytes, mode, 0, regbase);
6127 else if (mclass == MODE_INT
6128 && GET_MODE_SIZE (mode) < UNITS_PER_WORD)
6132 if ((mclass == MODE_FLOAT || mclass == MODE_COMPLEX_FLOAT)
6134 regno = SPARC_FP_ARG_FIRST;
6138 return gen_rtx_REG (mode, regno);
6141 /* Do what is necessary for `va_start'. We look at the current function
6142 to determine if stdarg or varargs is used and return the address of
6143 the first unnamed parameter. */
6146 sparc_builtin_saveregs (void)
6148 int first_reg = current_function_args_info.words;
6152 for (regno = first_reg; regno < SPARC_INT_ARG_MAX; regno++)
6153 emit_move_insn (gen_rtx_MEM (word_mode,
6154 gen_rtx_PLUS (Pmode,
6156 GEN_INT (FIRST_PARM_OFFSET (0)
6159 gen_rtx_REG (word_mode,
6160 SPARC_INCOMING_INT_ARG_FIRST + regno));
6162 address = gen_rtx_PLUS (Pmode,
6164 GEN_INT (FIRST_PARM_OFFSET (0)
6165 + UNITS_PER_WORD * first_reg));
6170 /* Implement `va_start' for stdarg. */
6173 sparc_va_start (tree valist, rtx nextarg)
6175 nextarg = expand_builtin_saveregs ();
6176 std_expand_builtin_va_start (valist, nextarg);
6179 /* Implement `va_arg' for stdarg. */
6182 sparc_gimplify_va_arg (tree valist, tree type, tree *pre_p, tree *post_p)
6184 HOST_WIDE_INT size, rsize, align;
6187 tree ptrtype = build_pointer_type (type);
6189 if (pass_by_reference (NULL, TYPE_MODE (type), type, false))
6192 size = rsize = UNITS_PER_WORD;
6198 size = int_size_in_bytes (type);
6199 rsize = (size + UNITS_PER_WORD - 1) & -UNITS_PER_WORD;
6204 /* For SPARC64, objects requiring 16-byte alignment get it. */
6205 if (TYPE_ALIGN (type) >= 2 * (unsigned) BITS_PER_WORD)
6206 align = 2 * UNITS_PER_WORD;
6208 /* SPARC-V9 ABI states that structures up to 16 bytes in size
6209 are left-justified in their slots. */
6210 if (AGGREGATE_TYPE_P (type))
6213 size = rsize = UNITS_PER_WORD;
6223 incr = fold (build2 (PLUS_EXPR, ptr_type_node, incr,
6224 ssize_int (align - 1)));
6225 incr = fold (build2 (BIT_AND_EXPR, ptr_type_node, incr,
6226 ssize_int (-align)));
6229 gimplify_expr (&incr, pre_p, post_p, is_gimple_val, fb_rvalue);
6232 if (BYTES_BIG_ENDIAN && size < rsize)
6233 addr = fold (build2 (PLUS_EXPR, ptr_type_node, incr,
6234 ssize_int (rsize - size)));
6238 addr = fold_convert (build_pointer_type (ptrtype), addr);
6239 addr = build_va_arg_indirect_ref (addr);
6241 /* If the address isn't aligned properly for the type,
6242 we may need to copy to a temporary.
6243 FIXME: This is inefficient. Usually we can do this
6246 && TYPE_ALIGN (type) > BITS_PER_WORD)
6248 tree tmp = create_tmp_var (type, "va_arg_tmp");
6249 tree dest_addr = build_fold_addr_expr (tmp);
6251 tree copy = build_function_call_expr
6252 (implicit_built_in_decls[BUILT_IN_MEMCPY],
6253 tree_cons (NULL_TREE, dest_addr,
6254 tree_cons (NULL_TREE, addr,
6255 tree_cons (NULL_TREE, size_int (rsize),
6258 gimplify_and_add (copy, pre_p);
6262 addr = fold_convert (ptrtype, addr);
6264 incr = fold (build2 (PLUS_EXPR, ptr_type_node, incr, ssize_int (rsize)));
6265 incr = build2 (MODIFY_EXPR, ptr_type_node, valist, incr);
6266 gimplify_and_add (incr, post_p);
6268 return build_va_arg_indirect_ref (addr);
6271 /* Implement the TARGET_VECTOR_MODE_SUPPORTED_P target hook.
6272 Specify whether the vector mode is supported by the hardware. */
6275 sparc_vector_mode_supported_p (enum machine_mode mode)
6277 return TARGET_VIS && VECTOR_MODE_P (mode) ? true : false;
6280 /* Return the string to output an unconditional branch to LABEL, which is
6281 the operand number of the label.
6283 DEST is the destination insn (i.e. the label), INSN is the source. */
6286 output_ubranch (rtx dest, int label, rtx insn)
6288 static char string[64];
6289 bool v9_form = false;
6292 if (TARGET_V9 && INSN_ADDRESSES_SET_P ())
6294 int delta = (INSN_ADDRESSES (INSN_UID (dest))
6295 - INSN_ADDRESSES (INSN_UID (insn)));
6296 /* Leave some instructions for "slop". */
6297 if (delta >= -260000 && delta < 260000)
6302 strcpy (string, "ba%*,pt\t%%xcc, ");
6304 strcpy (string, "b%*\t");
6306 p = strchr (string, '\0');
6317 /* Return the string to output a conditional branch to LABEL, which is
6318 the operand number of the label. OP is the conditional expression.
6319 XEXP (OP, 0) is assumed to be a condition code register (integer or
6320 floating point) and its mode specifies what kind of comparison we made.
6322 DEST is the destination insn (i.e. the label), INSN is the source.
6324 REVERSED is nonzero if we should reverse the sense of the comparison.
6326 ANNUL is nonzero if we should generate an annulling branch. */
6329 output_cbranch (rtx op, rtx dest, int label, int reversed, int annul,
6332 static char string[64];
6333 enum rtx_code code = GET_CODE (op);
6334 rtx cc_reg = XEXP (op, 0);
6335 enum machine_mode mode = GET_MODE (cc_reg);
6336 const char *labelno, *branch;
6337 int spaces = 8, far;
6340 /* v9 branches are limited to +-1MB. If it is too far away,
6353 fbne,a,pn %fcc2, .LC29
6361 far = TARGET_V9 && (get_attr_length (insn) >= 3);
6364 /* Reversal of FP compares takes care -- an ordered compare
6365 becomes an unordered compare and vice versa. */
6366 if (mode == CCFPmode || mode == CCFPEmode)
6367 code = reverse_condition_maybe_unordered (code);
6369 code = reverse_condition (code);
6372 /* Start by writing the branch condition. */
6373 if (mode == CCFPmode || mode == CCFPEmode)
6424 /* ??? !v9: FP branches cannot be preceded by another floating point
6425 insn. Because there is currently no concept of pre-delay slots,
6426 we can fix this only by always emitting a nop before a floating
6431 strcpy (string, "nop\n\t");
6432 strcat (string, branch);
6445 if (mode == CC_NOOVmode || mode == CCX_NOOVmode)
6457 if (mode == CC_NOOVmode || mode == CCX_NOOVmode)
6478 strcpy (string, branch);
6480 spaces -= strlen (branch);
6481 p = strchr (string, '\0');
6483 /* Now add the annulling, the label, and a possible noop. */
6496 if (! far && insn && INSN_ADDRESSES_SET_P ())
6498 int delta = (INSN_ADDRESSES (INSN_UID (dest))
6499 - INSN_ADDRESSES (INSN_UID (insn)));
6500 /* Leave some instructions for "slop". */
6501 if (delta < -260000 || delta >= 260000)
6505 if (mode == CCFPmode || mode == CCFPEmode)
6507 static char v9_fcc_labelno[] = "%%fccX, ";
6508 /* Set the char indicating the number of the fcc reg to use. */
6509 v9_fcc_labelno[5] = REGNO (cc_reg) - SPARC_FIRST_V9_FCC_REG + '0';
6510 labelno = v9_fcc_labelno;
6513 gcc_assert (REGNO (cc_reg) == SPARC_FCC_REG);
6517 else if (mode == CCXmode || mode == CCX_NOOVmode)
6519 labelno = "%%xcc, ";
6524 labelno = "%%icc, ";
6529 if (*labelno && insn && (note = find_reg_note (insn, REG_BR_PROB, NULL_RTX)))
6532 ((INTVAL (XEXP (note, 0)) >= REG_BR_PROB_BASE / 2) ^ far)
6545 strcpy (p, labelno);
6546 p = strchr (p, '\0');
6549 strcpy (p, ".+12\n\t nop\n\tb\t");
6550 /* Skip the next insn if requested or
6551 if we know that it will be a nop. */
6552 if (annul || ! final_sequence)
6566 /* Emit a library call comparison between floating point X and Y.
6567 COMPARISON is the rtl operator to compare with (EQ, NE, GT, etc.).
6568 TARGET_ARCH64 uses _Qp_* functions, which use pointers to TFmode
6569 values as arguments instead of the TFmode registers themselves,
6570 that's why we cannot call emit_float_lib_cmp. */
6572 sparc_emit_float_lib_cmp (rtx x, rtx y, enum rtx_code comparison)
6575 rtx slot0, slot1, result, tem, tem2;
6576 enum machine_mode mode;
6581 qpfunc = (TARGET_ARCH64) ? "_Qp_feq" : "_Q_feq";
6585 qpfunc = (TARGET_ARCH64) ? "_Qp_fne" : "_Q_fne";
6589 qpfunc = (TARGET_ARCH64) ? "_Qp_fgt" : "_Q_fgt";
6593 qpfunc = (TARGET_ARCH64) ? "_Qp_fge" : "_Q_fge";
6597 qpfunc = (TARGET_ARCH64) ? "_Qp_flt" : "_Q_flt";
6601 qpfunc = (TARGET_ARCH64) ? "_Qp_fle" : "_Q_fle";
6612 qpfunc = (TARGET_ARCH64) ? "_Qp_cmp" : "_Q_cmp";
6621 if (GET_CODE (x) != MEM)
6623 slot0 = assign_stack_temp (TFmode, GET_MODE_SIZE(TFmode), 0);
6624 emit_insn (gen_rtx_SET (VOIDmode, slot0, x));
6629 if (GET_CODE (y) != MEM)
6631 slot1 = assign_stack_temp (TFmode, GET_MODE_SIZE(TFmode), 0);
6632 emit_insn (gen_rtx_SET (VOIDmode, slot1, y));
6637 emit_library_call (gen_rtx_SYMBOL_REF (Pmode, qpfunc), LCT_NORMAL,
6639 XEXP (slot0, 0), Pmode,
6640 XEXP (slot1, 0), Pmode);
6646 emit_library_call (gen_rtx_SYMBOL_REF (Pmode, qpfunc), LCT_NORMAL,
6648 x, TFmode, y, TFmode);
6654 /* Immediately move the result of the libcall into a pseudo
6655 register so reload doesn't clobber the value if it needs
6656 the return register for a spill reg. */
6657 result = gen_reg_rtx (mode);
6658 emit_move_insn (result, hard_libcall_value (mode));
6663 emit_cmp_insn (result, const0_rtx, NE, NULL_RTX, mode, 0);
6667 emit_cmp_insn (result, GEN_INT(3), comparison == UNORDERED ? EQ : NE,
6672 emit_cmp_insn (result, const1_rtx,
6673 comparison == UNGT ? GT : NE, NULL_RTX, mode, 0);
6676 emit_cmp_insn (result, const2_rtx, NE, NULL_RTX, mode, 0);
6679 tem = gen_reg_rtx (mode);
6681 emit_insn (gen_andsi3 (tem, result, const1_rtx));
6683 emit_insn (gen_anddi3 (tem, result, const1_rtx));
6684 emit_cmp_insn (tem, const0_rtx, NE, NULL_RTX, mode, 0);
6688 tem = gen_reg_rtx (mode);
6690 emit_insn (gen_addsi3 (tem, result, const1_rtx));
6692 emit_insn (gen_adddi3 (tem, result, const1_rtx));
6693 tem2 = gen_reg_rtx (mode);
6695 emit_insn (gen_andsi3 (tem2, tem, const2_rtx));
6697 emit_insn (gen_anddi3 (tem2, tem, const2_rtx));
6698 emit_cmp_insn (tem2, const0_rtx, comparison == UNEQ ? EQ : NE,
6704 /* Generate an unsigned DImode to FP conversion. This is the same code
6705 optabs would emit if we didn't have TFmode patterns. */
6708 sparc_emit_floatunsdi (rtx *operands, enum machine_mode mode)
6710 rtx neglab, donelab, i0, i1, f0, in, out;
6713 in = force_reg (DImode, operands[1]);
6714 neglab = gen_label_rtx ();
6715 donelab = gen_label_rtx ();
6716 i0 = gen_reg_rtx (DImode);
6717 i1 = gen_reg_rtx (DImode);
6718 f0 = gen_reg_rtx (mode);
6720 emit_cmp_and_jump_insns (in, const0_rtx, LT, const0_rtx, DImode, 0, neglab);
6722 emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_FLOAT (mode, in)));
6723 emit_jump_insn (gen_jump (donelab));
6726 emit_label (neglab);
6728 emit_insn (gen_lshrdi3 (i0, in, const1_rtx));
6729 emit_insn (gen_anddi3 (i1, in, const1_rtx));
6730 emit_insn (gen_iordi3 (i0, i0, i1));
6731 emit_insn (gen_rtx_SET (VOIDmode, f0, gen_rtx_FLOAT (mode, i0)));
6732 emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_PLUS (mode, f0, f0)));
6734 emit_label (donelab);
6737 /* Generate an FP to unsigned DImode conversion. This is the same code
6738 optabs would emit if we didn't have TFmode patterns. */
6741 sparc_emit_fixunsdi (rtx *operands, enum machine_mode mode)
6743 rtx neglab, donelab, i0, i1, f0, in, out, limit;
6746 in = force_reg (mode, operands[1]);
6747 neglab = gen_label_rtx ();
6748 donelab = gen_label_rtx ();
6749 i0 = gen_reg_rtx (DImode);
6750 i1 = gen_reg_rtx (DImode);
6751 limit = gen_reg_rtx (mode);
6752 f0 = gen_reg_rtx (mode);
6754 emit_move_insn (limit,
6755 CONST_DOUBLE_FROM_REAL_VALUE (
6756 REAL_VALUE_ATOF ("9223372036854775808.0", mode), mode));
6757 emit_cmp_and_jump_insns (in, limit, GE, NULL_RTX, mode, 0, neglab);
6759 emit_insn (gen_rtx_SET (VOIDmode,
6761 gen_rtx_FIX (DImode, gen_rtx_FIX (mode, in))));
6762 emit_jump_insn (gen_jump (donelab));
6765 emit_label (neglab);
6767 emit_insn (gen_rtx_SET (VOIDmode, f0, gen_rtx_MINUS (mode, in, limit)));
6768 emit_insn (gen_rtx_SET (VOIDmode,
6770 gen_rtx_FIX (DImode, gen_rtx_FIX (mode, f0))));
6771 emit_insn (gen_movdi (i1, const1_rtx));
6772 emit_insn (gen_ashldi3 (i1, i1, GEN_INT (63)));
6773 emit_insn (gen_xordi3 (out, i0, i1));
6775 emit_label (donelab);
6778 /* Return the string to output a conditional branch to LABEL, testing
6779 register REG. LABEL is the operand number of the label; REG is the
6780 operand number of the reg. OP is the conditional expression. The mode
6781 of REG says what kind of comparison we made.
6783 DEST is the destination insn (i.e. the label), INSN is the source.
6785 REVERSED is nonzero if we should reverse the sense of the comparison.
6787 ANNUL is nonzero if we should generate an annulling branch. */
6790 output_v9branch (rtx op, rtx dest, int reg, int label, int reversed,
6791 int annul, rtx insn)
6793 static char string[64];
6794 enum rtx_code code = GET_CODE (op);
6795 enum machine_mode mode = GET_MODE (XEXP (op, 0));
6800 /* branch on register are limited to +-128KB. If it is too far away,
6813 brgez,a,pn %o1, .LC29
6819 ba,pt %xcc, .LC29 */
6821 far = get_attr_length (insn) >= 3;
6823 /* If not floating-point or if EQ or NE, we can just reverse the code. */
6825 code = reverse_condition (code);
6827 /* Only 64 bit versions of these instructions exist. */
6828 gcc_assert (mode == DImode);
6830 /* Start by writing the branch condition. */
6835 strcpy (string, "brnz");
6839 strcpy (string, "brz");
6843 strcpy (string, "brgez");
6847 strcpy (string, "brlz");
6851 strcpy (string, "brlez");
6855 strcpy (string, "brgz");
6862 p = strchr (string, '\0');
6864 /* Now add the annulling, reg, label, and nop. */
6871 if (insn && (note = find_reg_note (insn, REG_BR_PROB, NULL_RTX)))
6874 ((INTVAL (XEXP (note, 0)) >= REG_BR_PROB_BASE / 2) ^ far)
6879 *p = p < string + 8 ? '\t' : ' ';
6887 int veryfar = 1, delta;
6889 if (INSN_ADDRESSES_SET_P ())
6891 delta = (INSN_ADDRESSES (INSN_UID (dest))
6892 - INSN_ADDRESSES (INSN_UID (insn)));
6893 /* Leave some instructions for "slop". */
6894 if (delta >= -260000 && delta < 260000)
6898 strcpy (p, ".+12\n\t nop\n\t");
6899 /* Skip the next insn if requested or
6900 if we know that it will be a nop. */
6901 if (annul || ! final_sequence)
6911 strcpy (p, "ba,pt\t%%xcc, ");
6925 /* Return 1, if any of the registers of the instruction are %l[0-7] or %o[0-7].
6926 Such instructions cannot be used in the delay slot of return insn on v9.
6927 If TEST is 0, also rename all %i[0-7] registers to their %o[0-7] counterparts.
6931 epilogue_renumber (register rtx *where, int test)
6933 register const char *fmt;
6935 register enum rtx_code code;
6940 code = GET_CODE (*where);
6945 if (REGNO (*where) >= 8 && REGNO (*where) < 24) /* oX or lX */
6947 if (! test && REGNO (*where) >= 24 && REGNO (*where) < 32)
6948 *where = gen_rtx_REG (GET_MODE (*where), OUTGOING_REGNO (REGNO(*where)));
6956 /* Do not replace the frame pointer with the stack pointer because
6957 it can cause the delayed instruction to load below the stack.
6958 This occurs when instructions like:
6960 (set (reg/i:SI 24 %i0)
6961 (mem/f:SI (plus:SI (reg/f:SI 30 %fp)
6962 (const_int -20 [0xffffffec])) 0))
6964 are in the return delayed slot. */
6966 if (GET_CODE (XEXP (*where, 0)) == REG
6967 && REGNO (XEXP (*where, 0)) == HARD_FRAME_POINTER_REGNUM
6968 && (GET_CODE (XEXP (*where, 1)) != CONST_INT
6969 || INTVAL (XEXP (*where, 1)) < SPARC_STACK_BIAS))
6974 if (SPARC_STACK_BIAS
6975 && GET_CODE (XEXP (*where, 0)) == REG
6976 && REGNO (XEXP (*where, 0)) == HARD_FRAME_POINTER_REGNUM)
6984 fmt = GET_RTX_FORMAT (code);
6986 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
6991 for (j = XVECLEN (*where, i) - 1; j >= 0; j--)
6992 if (epilogue_renumber (&(XVECEXP (*where, i, j)), test))
6995 else if (fmt[i] == 'e'
6996 && epilogue_renumber (&(XEXP (*where, i)), test))
7002 /* Leaf functions and non-leaf functions have different needs. */
7005 reg_leaf_alloc_order[] = REG_LEAF_ALLOC_ORDER;
7008 reg_nonleaf_alloc_order[] = REG_ALLOC_ORDER;
7010 static const int *const reg_alloc_orders[] = {
7011 reg_leaf_alloc_order,
7012 reg_nonleaf_alloc_order};
7015 order_regs_for_local_alloc (void)
7017 static int last_order_nonleaf = 1;
7019 if (regs_ever_live[15] != last_order_nonleaf)
7021 last_order_nonleaf = !last_order_nonleaf;
7022 memcpy ((char *) reg_alloc_order,
7023 (const char *) reg_alloc_orders[last_order_nonleaf],
7024 FIRST_PSEUDO_REGISTER * sizeof (int));
7028 /* Return 1 if REG and MEM are legitimate enough to allow the various
7029 mem<-->reg splits to be run. */
7032 sparc_splitdi_legitimate (rtx reg, rtx mem)
7034 /* Punt if we are here by mistake. */
7035 gcc_assert (reload_completed);
7037 /* We must have an offsettable memory reference. */
7038 if (! offsettable_memref_p (mem))
7041 /* If we have legitimate args for ldd/std, we do not want
7042 the split to happen. */
7043 if ((REGNO (reg) % 2) == 0
7044 && mem_min_alignment (mem, 8))
7051 /* Return 1 if x and y are some kind of REG and they refer to
7052 different hard registers. This test is guaranteed to be
7053 run after reload. */
7056 sparc_absnegfloat_split_legitimate (rtx x, rtx y)
7058 if (GET_CODE (x) != REG)
7060 if (GET_CODE (y) != REG)
7062 if (REGNO (x) == REGNO (y))
7067 /* Return 1 if REGNO (reg1) is even and REGNO (reg1) == REGNO (reg2) - 1.
7068 This makes them candidates for using ldd and std insns.
7070 Note reg1 and reg2 *must* be hard registers. */
7073 registers_ok_for_ldd_peep (rtx reg1, rtx reg2)
7075 /* We might have been passed a SUBREG. */
7076 if (GET_CODE (reg1) != REG || GET_CODE (reg2) != REG)
7079 if (REGNO (reg1) % 2 != 0)
7082 /* Integer ldd is deprecated in SPARC V9 */
7083 if (TARGET_V9 && REGNO (reg1) < 32)
7086 return (REGNO (reg1) == REGNO (reg2) - 1);
7089 /* Return 1 if the addresses in mem1 and mem2 are suitable for use in
7092 This can only happen when addr1 and addr2, the addresses in mem1
7093 and mem2, are consecutive memory locations (addr1 + 4 == addr2).
7094 addr1 must also be aligned on a 64-bit boundary.
7096 Also iff dependent_reg_rtx is not null it should not be used to
7097 compute the address for mem1, i.e. we cannot optimize a sequence
7109 But, note that the transformation from:
7114 is perfectly fine. Thus, the peephole2 patterns always pass us
7115 the destination register of the first load, never the second one.
7117 For stores we don't have a similar problem, so dependent_reg_rtx is
7121 mems_ok_for_ldd_peep (rtx mem1, rtx mem2, rtx dependent_reg_rtx)
7125 HOST_WIDE_INT offset1;
7127 /* The mems cannot be volatile. */
7128 if (MEM_VOLATILE_P (mem1) || MEM_VOLATILE_P (mem2))
7131 /* MEM1 should be aligned on a 64-bit boundary. */
7132 if (MEM_ALIGN (mem1) < 64)
7135 addr1 = XEXP (mem1, 0);
7136 addr2 = XEXP (mem2, 0);
7138 /* Extract a register number and offset (if used) from the first addr. */
7139 if (GET_CODE (addr1) == PLUS)
7141 /* If not a REG, return zero. */
7142 if (GET_CODE (XEXP (addr1, 0)) != REG)
7146 reg1 = REGNO (XEXP (addr1, 0));
7147 /* The offset must be constant! */
7148 if (GET_CODE (XEXP (addr1, 1)) != CONST_INT)
7150 offset1 = INTVAL (XEXP (addr1, 1));
7153 else if (GET_CODE (addr1) != REG)
7157 reg1 = REGNO (addr1);
7158 /* This was a simple (mem (reg)) expression. Offset is 0. */
7162 /* Make sure the second address is a (mem (plus (reg) (const_int). */
7163 if (GET_CODE (addr2) != PLUS)
7166 if (GET_CODE (XEXP (addr2, 0)) != REG
7167 || GET_CODE (XEXP (addr2, 1)) != CONST_INT)
7170 if (reg1 != REGNO (XEXP (addr2, 0)))
7173 if (dependent_reg_rtx != NULL_RTX && reg1 == REGNO (dependent_reg_rtx))
7176 /* The first offset must be evenly divisible by 8 to ensure the
7177 address is 64 bit aligned. */
7178 if (offset1 % 8 != 0)
7181 /* The offset for the second addr must be 4 more than the first addr. */
7182 if (INTVAL (XEXP (addr2, 1)) != offset1 + 4)
7185 /* All the tests passed. addr1 and addr2 are valid for ldd and std
7190 /* Return 1 if reg is a pseudo, or is the first register in
7191 a hard register pair. This makes it a candidate for use in
7192 ldd and std insns. */
7195 register_ok_for_ldd (rtx reg)
7197 /* We might have been passed a SUBREG. */
7198 if (GET_CODE (reg) != REG)
7201 if (REGNO (reg) < FIRST_PSEUDO_REGISTER)
7202 return (REGNO (reg) % 2 == 0);
7207 /* Print operand X (an rtx) in assembler syntax to file FILE.
7208 CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified.
7209 For `%' followed by punctuation, CODE is the punctuation and X is null. */
7212 print_operand (FILE *file, rtx x, int code)
7217 /* Output an insn in a delay slot. */
7219 sparc_indent_opcode = 1;
7221 fputs ("\n\t nop", file);
7224 /* Output an annul flag if there's nothing for the delay slot and we
7225 are optimizing. This is always used with '(' below.
7226 Sun OS 4.1.1 dbx can't handle an annulled unconditional branch;
7227 this is a dbx bug. So, we only do this when optimizing.
7228 On UltraSPARC, a branch in a delay slot causes a pipeline flush.
7229 Always emit a nop in case the next instruction is a branch. */
7230 if (! final_sequence && (optimize && (int)sparc_cpu < PROCESSOR_V9))
7234 /* Output a 'nop' if there's nothing for the delay slot and we are
7235 not optimizing. This is always used with '*' above. */
7236 if (! final_sequence && ! (optimize && (int)sparc_cpu < PROCESSOR_V9))
7237 fputs ("\n\t nop", file);
7238 else if (final_sequence)
7239 sparc_indent_opcode = 1;
7242 /* Output the right displacement from the saved PC on function return.
7243 The caller may have placed an "unimp" insn immediately after the call
7244 so we have to account for it. This insn is used in the 32-bit ABI
7245 when calling a function that returns a non zero-sized structure. The
7246 64-bit ABI doesn't have it. Be careful to have this test be the same
7247 as that used on the call. */
7249 && current_function_returns_struct
7250 && (TREE_CODE (DECL_SIZE (DECL_RESULT (current_function_decl)))
7252 && ! integer_zerop (DECL_SIZE (DECL_RESULT (current_function_decl))))
7258 /* Output the Embedded Medium/Anywhere code model base register. */
7259 fputs (EMBMEDANY_BASE_REG, file);
7262 /* Print some local dynamic TLS name. */
7263 assemble_name (file, get_some_local_dynamic_name ());
7267 /* Adjust the operand to take into account a RESTORE operation. */
7268 if (GET_CODE (x) == CONST_INT)
7270 else if (GET_CODE (x) != REG)
7271 output_operand_lossage ("invalid %%Y operand");
7272 else if (REGNO (x) < 8)
7273 fputs (reg_names[REGNO (x)], file);
7274 else if (REGNO (x) >= 24 && REGNO (x) < 32)
7275 fputs (reg_names[REGNO (x)-16], file);
7277 output_operand_lossage ("invalid %%Y operand");
7280 /* Print out the low order register name of a register pair. */
7281 if (WORDS_BIG_ENDIAN)
7282 fputs (reg_names[REGNO (x)+1], file);
7284 fputs (reg_names[REGNO (x)], file);
7287 /* Print out the high order register name of a register pair. */
7288 if (WORDS_BIG_ENDIAN)
7289 fputs (reg_names[REGNO (x)], file);
7291 fputs (reg_names[REGNO (x)+1], file);
7294 /* Print out the second register name of a register pair or quad.
7295 I.e., R (%o0) => %o1. */
7296 fputs (reg_names[REGNO (x)+1], file);
7299 /* Print out the third register name of a register quad.
7300 I.e., S (%o0) => %o2. */
7301 fputs (reg_names[REGNO (x)+2], file);
7304 /* Print out the fourth register name of a register quad.
7305 I.e., T (%o0) => %o3. */
7306 fputs (reg_names[REGNO (x)+3], file);
7309 /* Print a condition code register. */
7310 if (REGNO (x) == SPARC_ICC_REG)
7312 /* We don't handle CC[X]_NOOVmode because they're not supposed
7314 if (GET_MODE (x) == CCmode)
7315 fputs ("%icc", file);
7316 else if (GET_MODE (x) == CCXmode)
7317 fputs ("%xcc", file);
7322 /* %fccN register */
7323 fputs (reg_names[REGNO (x)], file);
7326 /* Print the operand's address only. */
7327 output_address (XEXP (x, 0));
7330 /* In this case we need a register. Use %g0 if the
7331 operand is const0_rtx. */
7333 || (GET_MODE (x) != VOIDmode && x == CONST0_RTX (GET_MODE (x))))
7335 fputs ("%g0", file);
7342 switch (GET_CODE (x))
7344 case IOR: fputs ("or", file); break;
7345 case AND: fputs ("and", file); break;
7346 case XOR: fputs ("xor", file); break;
7347 default: output_operand_lossage ("invalid %%A operand");
7352 switch (GET_CODE (x))
7354 case IOR: fputs ("orn", file); break;
7355 case AND: fputs ("andn", file); break;
7356 case XOR: fputs ("xnor", file); break;
7357 default: output_operand_lossage ("invalid %%B operand");
7361 /* These are used by the conditional move instructions. */
7365 enum rtx_code rc = GET_CODE (x);
7369 enum machine_mode mode = GET_MODE (XEXP (x, 0));
7370 if (mode == CCFPmode || mode == CCFPEmode)
7371 rc = reverse_condition_maybe_unordered (GET_CODE (x));
7373 rc = reverse_condition (GET_CODE (x));
7377 case NE: fputs ("ne", file); break;
7378 case EQ: fputs ("e", file); break;
7379 case GE: fputs ("ge", file); break;
7380 case GT: fputs ("g", file); break;
7381 case LE: fputs ("le", file); break;
7382 case LT: fputs ("l", file); break;
7383 case GEU: fputs ("geu", file); break;
7384 case GTU: fputs ("gu", file); break;
7385 case LEU: fputs ("leu", file); break;
7386 case LTU: fputs ("lu", file); break;
7387 case LTGT: fputs ("lg", file); break;
7388 case UNORDERED: fputs ("u", file); break;
7389 case ORDERED: fputs ("o", file); break;
7390 case UNLT: fputs ("ul", file); break;
7391 case UNLE: fputs ("ule", file); break;
7392 case UNGT: fputs ("ug", file); break;
7393 case UNGE: fputs ("uge", file); break;
7394 case UNEQ: fputs ("ue", file); break;
7395 default: output_operand_lossage (code == 'c'
7396 ? "invalid %%c operand"
7397 : "invalid %%C operand");
7402 /* These are used by the movr instruction pattern. */
7406 enum rtx_code rc = (code == 'd'
7407 ? reverse_condition (GET_CODE (x))
7411 case NE: fputs ("ne", file); break;
7412 case EQ: fputs ("e", file); break;
7413 case GE: fputs ("gez", file); break;
7414 case LT: fputs ("lz", file); break;
7415 case LE: fputs ("lez", file); break;
7416 case GT: fputs ("gz", file); break;
7417 default: output_operand_lossage (code == 'd'
7418 ? "invalid %%d operand"
7419 : "invalid %%D operand");
7426 /* Print a sign-extended character. */
7427 int i = trunc_int_for_mode (INTVAL (x), QImode);
7428 fprintf (file, "%d", i);
7433 /* Operand must be a MEM; write its address. */
7434 if (GET_CODE (x) != MEM)
7435 output_operand_lossage ("invalid %%f operand");
7436 output_address (XEXP (x, 0));
7441 /* Print a sign-extended 32-bit value. */
7443 if (GET_CODE(x) == CONST_INT)
7445 else if (GET_CODE(x) == CONST_DOUBLE)
7446 i = CONST_DOUBLE_LOW (x);
7449 output_operand_lossage ("invalid %%s operand");
7452 i = trunc_int_for_mode (i, SImode);
7453 fprintf (file, HOST_WIDE_INT_PRINT_DEC, i);
7458 /* Do nothing special. */
7462 /* Undocumented flag. */
7463 output_operand_lossage ("invalid operand output code");
7466 if (GET_CODE (x) == REG)
7467 fputs (reg_names[REGNO (x)], file);
7468 else if (GET_CODE (x) == MEM)
7471 /* Poor Sun assembler doesn't understand absolute addressing. */
7472 if (CONSTANT_P (XEXP (x, 0)))
7473 fputs ("%g0+", file);
7474 output_address (XEXP (x, 0));
7477 else if (GET_CODE (x) == HIGH)
7479 fputs ("%hi(", file);
7480 output_addr_const (file, XEXP (x, 0));
7483 else if (GET_CODE (x) == LO_SUM)
7485 print_operand (file, XEXP (x, 0), 0);
7486 if (TARGET_CM_MEDMID)
7487 fputs ("+%l44(", file);
7489 fputs ("+%lo(", file);
7490 output_addr_const (file, XEXP (x, 1));
7493 else if (GET_CODE (x) == CONST_DOUBLE
7494 && (GET_MODE (x) == VOIDmode
7495 || GET_MODE_CLASS (GET_MODE (x)) == MODE_INT))
7497 if (CONST_DOUBLE_HIGH (x) == 0)
7498 fprintf (file, "%u", (unsigned int) CONST_DOUBLE_LOW (x));
7499 else if (CONST_DOUBLE_HIGH (x) == -1
7500 && CONST_DOUBLE_LOW (x) < 0)
7501 fprintf (file, "%d", (int) CONST_DOUBLE_LOW (x));
7503 output_operand_lossage ("long long constant not a valid immediate operand");
7505 else if (GET_CODE (x) == CONST_DOUBLE)
7506 output_operand_lossage ("floating point constant not a valid immediate operand");
7507 else { output_addr_const (file, x); }
7510 /* Target hook for assembling integer objects. The sparc version has
7511 special handling for aligned DI-mode objects. */
7514 sparc_assemble_integer (rtx x, unsigned int size, int aligned_p)
7516 /* ??? We only output .xword's for symbols and only then in environments
7517 where the assembler can handle them. */
7518 if (aligned_p && size == 8
7519 && (GET_CODE (x) != CONST_INT && GET_CODE (x) != CONST_DOUBLE))
7523 assemble_integer_with_op ("\t.xword\t", x);
7528 assemble_aligned_integer (4, const0_rtx);
7529 assemble_aligned_integer (4, x);
7533 return default_assemble_integer (x, size, aligned_p);
7536 /* Return the value of a code used in the .proc pseudo-op that says
7537 what kind of result this function returns. For non-C types, we pick
7538 the closest C type. */
7540 #ifndef SHORT_TYPE_SIZE
7541 #define SHORT_TYPE_SIZE (BITS_PER_UNIT * 2)
7544 #ifndef INT_TYPE_SIZE
7545 #define INT_TYPE_SIZE BITS_PER_WORD
7548 #ifndef LONG_TYPE_SIZE
7549 #define LONG_TYPE_SIZE BITS_PER_WORD
7552 #ifndef LONG_LONG_TYPE_SIZE
7553 #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
7556 #ifndef FLOAT_TYPE_SIZE
7557 #define FLOAT_TYPE_SIZE BITS_PER_WORD
7560 #ifndef DOUBLE_TYPE_SIZE
7561 #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
7564 #ifndef LONG_DOUBLE_TYPE_SIZE
7565 #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
7569 sparc_type_code (register tree type)
7571 register unsigned long qualifiers = 0;
7572 register unsigned shift;
7574 /* Only the first 30 bits of the qualifier are valid. We must refrain from
7575 setting more, since some assemblers will give an error for this. Also,
7576 we must be careful to avoid shifts of 32 bits or more to avoid getting
7577 unpredictable results. */
7579 for (shift = 6; shift < 30; shift += 2, type = TREE_TYPE (type))
7581 switch (TREE_CODE (type))
7587 qualifiers |= (3 << shift);
7592 qualifiers |= (2 << shift);
7596 case REFERENCE_TYPE:
7598 qualifiers |= (1 << shift);
7602 return (qualifiers | 8);
7605 case QUAL_UNION_TYPE:
7606 return (qualifiers | 9);
7609 return (qualifiers | 10);
7612 return (qualifiers | 16);
7615 /* If this is a range type, consider it to be the underlying
7617 if (TREE_TYPE (type) != 0)
7620 /* Carefully distinguish all the standard types of C,
7621 without messing up if the language is not C. We do this by
7622 testing TYPE_PRECISION and TYPE_UNSIGNED. The old code used to
7623 look at both the names and the above fields, but that's redundant.
7624 Any type whose size is between two C types will be considered
7625 to be the wider of the two types. Also, we do not have a
7626 special code to use for "long long", so anything wider than
7627 long is treated the same. Note that we can't distinguish
7628 between "int" and "long" in this code if they are the same
7629 size, but that's fine, since neither can the assembler. */
7631 if (TYPE_PRECISION (type) <= CHAR_TYPE_SIZE)
7632 return (qualifiers | (TYPE_UNSIGNED (type) ? 12 : 2));
7634 else if (TYPE_PRECISION (type) <= SHORT_TYPE_SIZE)
7635 return (qualifiers | (TYPE_UNSIGNED (type) ? 13 : 3));
7637 else if (TYPE_PRECISION (type) <= INT_TYPE_SIZE)
7638 return (qualifiers | (TYPE_UNSIGNED (type) ? 14 : 4));
7641 return (qualifiers | (TYPE_UNSIGNED (type) ? 15 : 5));
7644 /* If this is a range type, consider it to be the underlying
7646 if (TREE_TYPE (type) != 0)
7649 /* Carefully distinguish all the standard types of C,
7650 without messing up if the language is not C. */
7652 if (TYPE_PRECISION (type) == FLOAT_TYPE_SIZE)
7653 return (qualifiers | 6);
7656 return (qualifiers | 7);
7658 case COMPLEX_TYPE: /* GNU Fortran COMPLEX type. */
7659 /* ??? We need to distinguish between double and float complex types,
7660 but I don't know how yet because I can't reach this code from
7661 existing front-ends. */
7662 return (qualifiers | 7); /* Who knows? */
7665 case CHAR_TYPE: /* GNU Pascal CHAR type. Not used in C. */
7666 case BOOLEAN_TYPE: /* GNU Fortran BOOLEAN type. */
7667 case LANG_TYPE: /* ? */
7671 gcc_unreachable (); /* Not a type! */
7678 /* Nested function support. */
7680 /* Emit RTL insns to initialize the variable parts of a trampoline.
7681 FNADDR is an RTX for the address of the function's pure code.
7682 CXT is an RTX for the static chain value for the function.
7684 This takes 16 insns: 2 shifts & 2 ands (to split up addresses), 4 sethi
7685 (to load in opcodes), 4 iors (to merge address and opcodes), and 4 writes
7686 (to store insns). This is a bit excessive. Perhaps a different
7687 mechanism would be better here.
7689 Emit enough FLUSH insns to synchronize the data and instruction caches. */
7692 sparc_initialize_trampoline (rtx tramp, rtx fnaddr, rtx cxt)
7694 /* SPARC 32-bit trampoline:
7697 sethi %hi(static), %g2
7699 or %g2, %lo(static), %g2
7701 SETHI i,r = 00rr rrr1 00ii iiii iiii iiii iiii iiii
7702 JMPL r+i,d = 10dd ddd1 1100 0rrr rr1i iiii iiii iiii
7706 (gen_rtx_MEM (SImode, plus_constant (tramp, 0)),
7707 expand_binop (SImode, ior_optab,
7708 expand_shift (RSHIFT_EXPR, SImode, fnaddr,
7709 size_int (10), 0, 1),
7710 GEN_INT (trunc_int_for_mode (0x03000000, SImode)),
7711 NULL_RTX, 1, OPTAB_DIRECT));
7714 (gen_rtx_MEM (SImode, plus_constant (tramp, 4)),
7715 expand_binop (SImode, ior_optab,
7716 expand_shift (RSHIFT_EXPR, SImode, cxt,
7717 size_int (10), 0, 1),
7718 GEN_INT (trunc_int_for_mode (0x05000000, SImode)),
7719 NULL_RTX, 1, OPTAB_DIRECT));
7722 (gen_rtx_MEM (SImode, plus_constant (tramp, 8)),
7723 expand_binop (SImode, ior_optab,
7724 expand_and (SImode, fnaddr, GEN_INT (0x3ff), NULL_RTX),
7725 GEN_INT (trunc_int_for_mode (0x81c06000, SImode)),
7726 NULL_RTX, 1, OPTAB_DIRECT));
7729 (gen_rtx_MEM (SImode, plus_constant (tramp, 12)),
7730 expand_binop (SImode, ior_optab,
7731 expand_and (SImode, cxt, GEN_INT (0x3ff), NULL_RTX),
7732 GEN_INT (trunc_int_for_mode (0x8410a000, SImode)),
7733 NULL_RTX, 1, OPTAB_DIRECT));
7735 /* On UltraSPARC a flush flushes an entire cache line. The trampoline is
7736 aligned on a 16 byte boundary so one flush clears it all. */
7737 emit_insn (gen_flush (validize_mem (gen_rtx_MEM (SImode, tramp))));
7738 if (sparc_cpu != PROCESSOR_ULTRASPARC
7739 && sparc_cpu != PROCESSOR_ULTRASPARC3)
7740 emit_insn (gen_flush (validize_mem (gen_rtx_MEM (SImode,
7741 plus_constant (tramp, 8)))));
7743 /* Call __enable_execute_stack after writing onto the stack to make sure
7744 the stack address is accessible. */
7745 #ifdef ENABLE_EXECUTE_STACK
7746 emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__enable_execute_stack"),
7747 LCT_NORMAL, VOIDmode, 1, tramp, Pmode);
7752 /* The 64-bit version is simpler because it makes more sense to load the
7753 values as "immediate" data out of the trampoline. It's also easier since
7754 we can read the PC without clobbering a register. */
7757 sparc64_initialize_trampoline (rtx tramp, rtx fnaddr, rtx cxt)
7759 /* SPARC 64-bit trampoline:
7768 emit_move_insn (gen_rtx_MEM (SImode, tramp),
7769 GEN_INT (trunc_int_for_mode (0x83414000, SImode)));
7770 emit_move_insn (gen_rtx_MEM (SImode, plus_constant (tramp, 4)),
7771 GEN_INT (trunc_int_for_mode (0xca586018, SImode)));
7772 emit_move_insn (gen_rtx_MEM (SImode, plus_constant (tramp, 8)),
7773 GEN_INT (trunc_int_for_mode (0x81c14000, SImode)));
7774 emit_move_insn (gen_rtx_MEM (SImode, plus_constant (tramp, 12)),
7775 GEN_INT (trunc_int_for_mode (0xca586010, SImode)));
7776 emit_move_insn (gen_rtx_MEM (DImode, plus_constant (tramp, 16)), cxt);
7777 emit_move_insn (gen_rtx_MEM (DImode, plus_constant (tramp, 24)), fnaddr);
7778 emit_insn (gen_flushdi (validize_mem (gen_rtx_MEM (DImode, tramp))));
7780 if (sparc_cpu != PROCESSOR_ULTRASPARC
7781 && sparc_cpu != PROCESSOR_ULTRASPARC3)
7782 emit_insn (gen_flushdi (validize_mem (gen_rtx_MEM (DImode, plus_constant (tramp, 8)))));
7784 /* Call __enable_execute_stack after writing onto the stack to make sure
7785 the stack address is accessible. */
7786 #ifdef ENABLE_EXECUTE_STACK
7787 emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__enable_execute_stack"),
7788 LCT_NORMAL, VOIDmode, 1, tramp, Pmode);
7792 /* Adjust the cost of a scheduling dependency. Return the new cost of
7793 a dependency LINK or INSN on DEP_INSN. COST is the current cost. */
7796 supersparc_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
7798 enum attr_type insn_type;
7800 if (! recog_memoized (insn))
7803 insn_type = get_attr_type (insn);
7805 if (REG_NOTE_KIND (link) == 0)
7807 /* Data dependency; DEP_INSN writes a register that INSN reads some
7810 /* if a load, then the dependence must be on the memory address;
7811 add an extra "cycle". Note that the cost could be two cycles
7812 if the reg was written late in an instruction group; we ca not tell
7814 if (insn_type == TYPE_LOAD || insn_type == TYPE_FPLOAD)
7817 /* Get the delay only if the address of the store is the dependence. */
7818 if (insn_type == TYPE_STORE || insn_type == TYPE_FPSTORE)
7820 rtx pat = PATTERN(insn);
7821 rtx dep_pat = PATTERN (dep_insn);
7823 if (GET_CODE (pat) != SET || GET_CODE (dep_pat) != SET)
7824 return cost; /* This should not happen! */
7826 /* The dependency between the two instructions was on the data that
7827 is being stored. Assume that this implies that the address of the
7828 store is not dependent. */
7829 if (rtx_equal_p (SET_DEST (dep_pat), SET_SRC (pat)))
7832 return cost + 3; /* An approximation. */
7835 /* A shift instruction cannot receive its data from an instruction
7836 in the same cycle; add a one cycle penalty. */
7837 if (insn_type == TYPE_SHIFT)
7838 return cost + 3; /* Split before cascade into shift. */
7842 /* Anti- or output- dependency; DEP_INSN reads/writes a register that
7843 INSN writes some cycles later. */
7845 /* These are only significant for the fpu unit; writing a fp reg before
7846 the fpu has finished with it stalls the processor. */
7848 /* Reusing an integer register causes no problems. */
7849 if (insn_type == TYPE_IALU || insn_type == TYPE_SHIFT)
7857 hypersparc_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
7859 enum attr_type insn_type, dep_type;
7860 rtx pat = PATTERN(insn);
7861 rtx dep_pat = PATTERN (dep_insn);
7863 if (recog_memoized (insn) < 0 || recog_memoized (dep_insn) < 0)
7866 insn_type = get_attr_type (insn);
7867 dep_type = get_attr_type (dep_insn);
7869 switch (REG_NOTE_KIND (link))
7872 /* Data dependency; DEP_INSN writes a register that INSN reads some
7879 /* Get the delay iff the address of the store is the dependence. */
7880 if (GET_CODE (pat) != SET || GET_CODE (dep_pat) != SET)
7883 if (rtx_equal_p (SET_DEST (dep_pat), SET_SRC (pat)))
7890 /* If a load, then the dependence must be on the memory address. If
7891 the addresses aren't equal, then it might be a false dependency */
7892 if (dep_type == TYPE_STORE || dep_type == TYPE_FPSTORE)
7894 if (GET_CODE (pat) != SET || GET_CODE (dep_pat) != SET
7895 || GET_CODE (SET_DEST (dep_pat)) != MEM
7896 || GET_CODE (SET_SRC (pat)) != MEM
7897 || ! rtx_equal_p (XEXP (SET_DEST (dep_pat), 0),
7898 XEXP (SET_SRC (pat), 0)))
7906 /* Compare to branch latency is 0. There is no benefit from
7907 separating compare and branch. */
7908 if (dep_type == TYPE_COMPARE)
7910 /* Floating point compare to branch latency is less than
7911 compare to conditional move. */
7912 if (dep_type == TYPE_FPCMP)
7921 /* Anti-dependencies only penalize the fpu unit. */
7922 if (insn_type == TYPE_IALU || insn_type == TYPE_SHIFT)
7934 sparc_adjust_cost(rtx insn, rtx link, rtx dep, int cost)
7938 case PROCESSOR_SUPERSPARC:
7939 cost = supersparc_adjust_cost (insn, link, dep, cost);
7941 case PROCESSOR_HYPERSPARC:
7942 case PROCESSOR_SPARCLITE86X:
7943 cost = hypersparc_adjust_cost (insn, link, dep, cost);
7952 sparc_sched_init (FILE *dump ATTRIBUTE_UNUSED,
7953 int sched_verbose ATTRIBUTE_UNUSED,
7954 int max_ready ATTRIBUTE_UNUSED)
7959 sparc_use_sched_lookahead (void)
7961 if (sparc_cpu == PROCESSOR_ULTRASPARC
7962 || sparc_cpu == PROCESSOR_ULTRASPARC3)
7964 if ((1 << sparc_cpu) &
7965 ((1 << PROCESSOR_SUPERSPARC) | (1 << PROCESSOR_HYPERSPARC) |
7966 (1 << PROCESSOR_SPARCLITE86X)))
7972 sparc_issue_rate (void)
7979 /* Assume V9 processors are capable of at least dual-issue. */
7981 case PROCESSOR_SUPERSPARC:
7983 case PROCESSOR_HYPERSPARC:
7984 case PROCESSOR_SPARCLITE86X:
7986 case PROCESSOR_ULTRASPARC:
7987 case PROCESSOR_ULTRASPARC3:
7993 set_extends (rtx insn)
7995 register rtx pat = PATTERN (insn);
7997 switch (GET_CODE (SET_SRC (pat)))
7999 /* Load and some shift instructions zero extend. */
8002 /* sethi clears the high bits */
8004 /* LO_SUM is used with sethi. sethi cleared the high
8005 bits and the values used with lo_sum are positive */
8007 /* Store flag stores 0 or 1 */
8017 rtx op0 = XEXP (SET_SRC (pat), 0);
8018 rtx op1 = XEXP (SET_SRC (pat), 1);
8019 if (GET_CODE (op1) == CONST_INT)
8020 return INTVAL (op1) >= 0;
8021 if (GET_CODE (op0) != REG)
8023 if (sparc_check_64 (op0, insn) == 1)
8025 return (GET_CODE (op1) == REG && sparc_check_64 (op1, insn) == 1);
8030 rtx op0 = XEXP (SET_SRC (pat), 0);
8031 rtx op1 = XEXP (SET_SRC (pat), 1);
8032 if (GET_CODE (op0) != REG || sparc_check_64 (op0, insn) <= 0)
8034 if (GET_CODE (op1) == CONST_INT)
8035 return INTVAL (op1) >= 0;
8036 return (GET_CODE (op1) == REG && sparc_check_64 (op1, insn) == 1);
8039 return GET_MODE (SET_SRC (pat)) == SImode;
8040 /* Positive integers leave the high bits zero. */
8042 return ! (CONST_DOUBLE_LOW (SET_SRC (pat)) & 0x80000000);
8044 return ! (INTVAL (SET_SRC (pat)) & 0x80000000);
8047 return - (GET_MODE (SET_SRC (pat)) == SImode);
8049 return sparc_check_64 (SET_SRC (pat), insn);
8055 /* We _ought_ to have only one kind per function, but... */
8056 static GTY(()) rtx sparc_addr_diff_list;
8057 static GTY(()) rtx sparc_addr_list;
8060 sparc_defer_case_vector (rtx lab, rtx vec, int diff)
8062 vec = gen_rtx_EXPR_LIST (VOIDmode, lab, vec);
8064 sparc_addr_diff_list
8065 = gen_rtx_EXPR_LIST (VOIDmode, vec, sparc_addr_diff_list);
8067 sparc_addr_list = gen_rtx_EXPR_LIST (VOIDmode, vec, sparc_addr_list);
8071 sparc_output_addr_vec (rtx vec)
8073 rtx lab = XEXP (vec, 0), body = XEXP (vec, 1);
8074 int idx, vlen = XVECLEN (body, 0);
8076 #ifdef ASM_OUTPUT_ADDR_VEC_START
8077 ASM_OUTPUT_ADDR_VEC_START (asm_out_file);
8080 #ifdef ASM_OUTPUT_CASE_LABEL
8081 ASM_OUTPUT_CASE_LABEL (asm_out_file, "L", CODE_LABEL_NUMBER (lab),
8084 (*targetm.asm_out.internal_label) (asm_out_file, "L", CODE_LABEL_NUMBER (lab));
8087 for (idx = 0; idx < vlen; idx++)
8089 ASM_OUTPUT_ADDR_VEC_ELT
8090 (asm_out_file, CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 0, idx), 0)));
8093 #ifdef ASM_OUTPUT_ADDR_VEC_END
8094 ASM_OUTPUT_ADDR_VEC_END (asm_out_file);
8099 sparc_output_addr_diff_vec (rtx vec)
8101 rtx lab = XEXP (vec, 0), body = XEXP (vec, 1);
8102 rtx base = XEXP (XEXP (body, 0), 0);
8103 int idx, vlen = XVECLEN (body, 1);
8105 #ifdef ASM_OUTPUT_ADDR_VEC_START
8106 ASM_OUTPUT_ADDR_VEC_START (asm_out_file);
8109 #ifdef ASM_OUTPUT_CASE_LABEL
8110 ASM_OUTPUT_CASE_LABEL (asm_out_file, "L", CODE_LABEL_NUMBER (lab),
8113 (*targetm.asm_out.internal_label) (asm_out_file, "L", CODE_LABEL_NUMBER (lab));
8116 for (idx = 0; idx < vlen; idx++)
8118 ASM_OUTPUT_ADDR_DIFF_ELT
8121 CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 1, idx), 0)),
8122 CODE_LABEL_NUMBER (base));
8125 #ifdef ASM_OUTPUT_ADDR_VEC_END
8126 ASM_OUTPUT_ADDR_VEC_END (asm_out_file);
8131 sparc_output_deferred_case_vectors (void)
8136 if (sparc_addr_list == NULL_RTX
8137 && sparc_addr_diff_list == NULL_RTX)
8140 /* Align to cache line in the function's code section. */
8141 current_function_section (current_function_decl);
8143 align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
8145 ASM_OUTPUT_ALIGN (asm_out_file, align);
8147 for (t = sparc_addr_list; t ; t = XEXP (t, 1))
8148 sparc_output_addr_vec (XEXP (t, 0));
8149 for (t = sparc_addr_diff_list; t ; t = XEXP (t, 1))
8150 sparc_output_addr_diff_vec (XEXP (t, 0));
8152 sparc_addr_list = sparc_addr_diff_list = NULL_RTX;
8155 /* Return 0 if the high 32 bits of X (the low word of X, if DImode) are
8156 unknown. Return 1 if the high bits are zero, -1 if the register is
8159 sparc_check_64 (rtx x, rtx insn)
8161 /* If a register is set only once it is safe to ignore insns this
8162 code does not know how to handle. The loop will either recognize
8163 the single set and return the correct value or fail to recognize
8168 gcc_assert (GET_CODE (x) == REG);
8170 if (GET_MODE (x) == DImode)
8171 y = gen_rtx_REG (SImode, REGNO (x) + WORDS_BIG_ENDIAN);
8173 if (flag_expensive_optimizations
8174 && REG_N_SETS (REGNO (y)) == 1)
8180 insn = get_last_insn_anywhere ();
8185 while ((insn = PREV_INSN (insn)))
8187 switch (GET_CODE (insn))
8200 rtx pat = PATTERN (insn);
8201 if (GET_CODE (pat) != SET)
8203 if (rtx_equal_p (x, SET_DEST (pat)))
8204 return set_extends (insn);
8205 if (y && rtx_equal_p (y, SET_DEST (pat)))
8206 return set_extends (insn);
8207 if (reg_overlap_mentioned_p (SET_DEST (pat), y))
8215 /* Returns assembly code to perform a DImode shift using
8216 a 64-bit global or out register on SPARC-V8+. */
8218 output_v8plus_shift (rtx *operands, rtx insn, const char *opcode)
8220 static char asm_code[60];
8222 /* The scratch register is only required when the destination
8223 register is not a 64-bit global or out register. */
8224 if (which_alternative != 2)
8225 operands[3] = operands[0];
8227 /* We can only shift by constants <= 63. */
8228 if (GET_CODE (operands[2]) == CONST_INT)
8229 operands[2] = GEN_INT (INTVAL (operands[2]) & 0x3f);
8231 if (GET_CODE (operands[1]) == CONST_INT)
8233 output_asm_insn ("mov\t%1, %3", operands);
8237 output_asm_insn ("sllx\t%H1, 32, %3", operands);
8238 if (sparc_check_64 (operands[1], insn) <= 0)
8239 output_asm_insn ("srl\t%L1, 0, %L1", operands);
8240 output_asm_insn ("or\t%L1, %3, %3", operands);
8243 strcpy(asm_code, opcode);
8245 if (which_alternative != 2)
8246 return strcat (asm_code, "\t%0, %2, %L0\n\tsrlx\t%L0, 32, %H0");
8248 return strcat (asm_code, "\t%3, %2, %3\n\tsrlx\t%3, 32, %H0\n\tmov\t%3, %L0");
8251 /* Output rtl to increment the profiler label LABELNO
8252 for profiling a function entry. */
8255 sparc_profile_hook (int labelno)
8260 ASM_GENERATE_INTERNAL_LABEL (buf, "LP", labelno);
8261 lab = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf));
8262 fun = gen_rtx_SYMBOL_REF (Pmode, MCOUNT_FUNCTION);
8264 emit_library_call (fun, LCT_NORMAL, VOIDmode, 1, lab, Pmode);
8267 #ifdef OBJECT_FORMAT_ELF
8269 sparc_elf_asm_named_section (const char *name, unsigned int flags,
8272 if (flags & SECTION_MERGE)
8274 /* entsize cannot be expressed in this section attributes
8276 default_elf_asm_named_section (name, flags, decl);
8280 fprintf (asm_out_file, "\t.section\t\"%s\"", name);
8282 if (!(flags & SECTION_DEBUG))
8283 fputs (",#alloc", asm_out_file);
8284 if (flags & SECTION_WRITE)
8285 fputs (",#write", asm_out_file);
8286 if (flags & SECTION_TLS)
8287 fputs (",#tls", asm_out_file);
8288 if (flags & SECTION_CODE)
8289 fputs (",#execinstr", asm_out_file);
8291 /* ??? Handle SECTION_BSS. */
8293 fputc ('\n', asm_out_file);
8295 #endif /* OBJECT_FORMAT_ELF */
8297 /* We do not allow indirect calls to be optimized into sibling calls.
8299 We cannot use sibling calls when delayed branches are disabled
8300 because they will likely require the call delay slot to be filled.
8302 Also, on SPARC 32-bit we cannot emit a sibling call when the
8303 current function returns a structure. This is because the "unimp
8304 after call" convention would cause the callee to return to the
8305 wrong place. The generic code already disallows cases where the
8306 function being called returns a structure.
8308 It may seem strange how this last case could occur. Usually there
8309 is code after the call which jumps to epilogue code which dumps the
8310 return value into the struct return area. That ought to invalidate
8311 the sibling call right? Well, in the C++ case we can end up passing
8312 the pointer to the struct return area to a constructor (which returns
8313 void) and then nothing else happens. Such a sibling call would look
8314 valid without the added check here. */
8316 sparc_function_ok_for_sibcall (tree decl, tree exp ATTRIBUTE_UNUSED)
8319 && flag_delayed_branch
8320 && (TARGET_ARCH64 || ! current_function_returns_struct));
8323 /* libfunc renaming. */
8324 #include "config/gofast.h"
8327 sparc_init_libfuncs (void)
8331 /* Use the subroutines that Sun's library provides for integer
8332 multiply and divide. The `*' prevents an underscore from
8333 being prepended by the compiler. .umul is a little faster
8335 set_optab_libfunc (smul_optab, SImode, "*.umul");
8336 set_optab_libfunc (sdiv_optab, SImode, "*.div");
8337 set_optab_libfunc (udiv_optab, SImode, "*.udiv");
8338 set_optab_libfunc (smod_optab, SImode, "*.rem");
8339 set_optab_libfunc (umod_optab, SImode, "*.urem");
8341 /* TFmode arithmetic. These names are part of the SPARC 32bit ABI. */
8342 set_optab_libfunc (add_optab, TFmode, "_Q_add");
8343 set_optab_libfunc (sub_optab, TFmode, "_Q_sub");
8344 set_optab_libfunc (neg_optab, TFmode, "_Q_neg");
8345 set_optab_libfunc (smul_optab, TFmode, "_Q_mul");
8346 set_optab_libfunc (sdiv_optab, TFmode, "_Q_div");
8348 /* We can define the TFmode sqrt optab only if TARGET_FPU. This
8349 is because with soft-float, the SFmode and DFmode sqrt
8350 instructions will be absent, and the compiler will notice and
8351 try to use the TFmode sqrt instruction for calls to the
8352 builtin function sqrt, but this fails. */
8354 set_optab_libfunc (sqrt_optab, TFmode, "_Q_sqrt");
8356 set_optab_libfunc (eq_optab, TFmode, "_Q_feq");
8357 set_optab_libfunc (ne_optab, TFmode, "_Q_fne");
8358 set_optab_libfunc (gt_optab, TFmode, "_Q_fgt");
8359 set_optab_libfunc (ge_optab, TFmode, "_Q_fge");
8360 set_optab_libfunc (lt_optab, TFmode, "_Q_flt");
8361 set_optab_libfunc (le_optab, TFmode, "_Q_fle");
8363 set_conv_libfunc (sext_optab, TFmode, SFmode, "_Q_stoq");
8364 set_conv_libfunc (sext_optab, TFmode, DFmode, "_Q_dtoq");
8365 set_conv_libfunc (trunc_optab, SFmode, TFmode, "_Q_qtos");
8366 set_conv_libfunc (trunc_optab, DFmode, TFmode, "_Q_qtod");
8368 set_conv_libfunc (sfix_optab, SImode, TFmode, "_Q_qtoi");
8369 set_conv_libfunc (ufix_optab, SImode, TFmode, "_Q_qtou");
8370 set_conv_libfunc (sfloat_optab, TFmode, SImode, "_Q_itoq");
8372 if (DITF_CONVERSION_LIBFUNCS)
8374 set_conv_libfunc (sfix_optab, DImode, TFmode, "_Q_qtoll");
8375 set_conv_libfunc (ufix_optab, DImode, TFmode, "_Q_qtoull");
8376 set_conv_libfunc (sfloat_optab, TFmode, DImode, "_Q_lltoq");
8379 if (SUN_CONVERSION_LIBFUNCS)
8381 set_conv_libfunc (sfix_optab, DImode, SFmode, "__ftoll");
8382 set_conv_libfunc (ufix_optab, DImode, SFmode, "__ftoull");
8383 set_conv_libfunc (sfix_optab, DImode, DFmode, "__dtoll");
8384 set_conv_libfunc (ufix_optab, DImode, DFmode, "__dtoull");
8389 /* In the SPARC 64bit ABI, SImode multiply and divide functions
8390 do not exist in the library. Make sure the compiler does not
8391 emit calls to them by accident. (It should always use the
8392 hardware instructions.) */
8393 set_optab_libfunc (smul_optab, SImode, 0);
8394 set_optab_libfunc (sdiv_optab, SImode, 0);
8395 set_optab_libfunc (udiv_optab, SImode, 0);
8396 set_optab_libfunc (smod_optab, SImode, 0);
8397 set_optab_libfunc (umod_optab, SImode, 0);
8399 if (SUN_INTEGER_MULTIPLY_64)
8401 set_optab_libfunc (smul_optab, DImode, "__mul64");
8402 set_optab_libfunc (sdiv_optab, DImode, "__div64");
8403 set_optab_libfunc (udiv_optab, DImode, "__udiv64");
8404 set_optab_libfunc (smod_optab, DImode, "__rem64");
8405 set_optab_libfunc (umod_optab, DImode, "__urem64");
8408 if (SUN_CONVERSION_LIBFUNCS)
8410 set_conv_libfunc (sfix_optab, DImode, SFmode, "__ftol");
8411 set_conv_libfunc (ufix_optab, DImode, SFmode, "__ftoul");
8412 set_conv_libfunc (sfix_optab, DImode, DFmode, "__dtol");
8413 set_conv_libfunc (ufix_optab, DImode, DFmode, "__dtoul");
8417 gofast_maybe_init_libfuncs ();
8420 #define def_builtin(NAME, CODE, TYPE) \
8421 lang_hooks.builtin_function((NAME), (TYPE), (CODE), BUILT_IN_MD, NULL, \
8424 /* Implement the TARGET_INIT_BUILTINS target hook.
8425 Create builtin functions for special SPARC instructions. */
8428 sparc_init_builtins (void)
8431 sparc_vis_init_builtins ();
8434 /* Create builtin functions for VIS 1.0 instructions. */
8437 sparc_vis_init_builtins (void)
8439 tree v4qi = build_vector_type (unsigned_intQI_type_node, 4);
8440 tree v8qi = build_vector_type (unsigned_intQI_type_node, 8);
8441 tree v4hi = build_vector_type (intHI_type_node, 4);
8442 tree v2hi = build_vector_type (intHI_type_node, 2);
8443 tree v2si = build_vector_type (intSI_type_node, 2);
8445 tree v4qi_ftype_v4hi = build_function_type_list (v4qi, v4hi, 0);
8446 tree v8qi_ftype_v2si_v8qi = build_function_type_list (v8qi, v2si, v8qi, 0);
8447 tree v2hi_ftype_v2si = build_function_type_list (v2hi, v2si, 0);
8448 tree v4hi_ftype_v4qi = build_function_type_list (v4hi, v4qi, 0);
8449 tree v8qi_ftype_v4qi_v4qi = build_function_type_list (v8qi, v4qi, v4qi, 0);
8450 tree v4hi_ftype_v4qi_v4hi = build_function_type_list (v4hi, v4qi, v4hi, 0);
8451 tree v4hi_ftype_v4qi_v2hi = build_function_type_list (v4hi, v4qi, v2hi, 0);
8452 tree v2si_ftype_v4qi_v2hi = build_function_type_list (v2si, v4qi, v2hi, 0);
8453 tree v4hi_ftype_v8qi_v4hi = build_function_type_list (v4hi, v8qi, v4hi, 0);
8454 tree v4hi_ftype_v4hi_v4hi = build_function_type_list (v4hi, v4hi, v4hi, 0);
8455 tree v2si_ftype_v2si_v2si = build_function_type_list (v2si, v2si, v2si, 0);
8456 tree v8qi_ftype_v8qi_v8qi = build_function_type_list (v8qi, v8qi, v8qi, 0);
8457 tree di_ftype_v8qi_v8qi_di = build_function_type_list (intDI_type_node,
8459 intDI_type_node, 0);
8460 tree di_ftype_di_di = build_function_type_list (intDI_type_node,
8462 intDI_type_node, 0);
8463 tree ptr_ftype_ptr_si = build_function_type_list (ptr_type_node,
8465 intSI_type_node, 0);
8466 tree ptr_ftype_ptr_di = build_function_type_list (ptr_type_node,
8468 intDI_type_node, 0);
8470 /* Packing and expanding vectors. */
8471 def_builtin ("__builtin_vis_fpack16", CODE_FOR_fpack16_vis, v4qi_ftype_v4hi);
8472 def_builtin ("__builtin_vis_fpack32", CODE_FOR_fpack32_vis,
8473 v8qi_ftype_v2si_v8qi);
8474 def_builtin ("__builtin_vis_fpackfix", CODE_FOR_fpackfix_vis,
8476 def_builtin ("__builtin_vis_fexpand", CODE_FOR_fexpand_vis, v4hi_ftype_v4qi);
8477 def_builtin ("__builtin_vis_fpmerge", CODE_FOR_fpmerge_vis,
8478 v8qi_ftype_v4qi_v4qi);
8480 /* Multiplications. */
8481 def_builtin ("__builtin_vis_fmul8x16", CODE_FOR_fmul8x16_vis,
8482 v4hi_ftype_v4qi_v4hi);
8483 def_builtin ("__builtin_vis_fmul8x16au", CODE_FOR_fmul8x16au_vis,
8484 v4hi_ftype_v4qi_v2hi);
8485 def_builtin ("__builtin_vis_fmul8x16al", CODE_FOR_fmul8x16al_vis,
8486 v4hi_ftype_v4qi_v2hi);
8487 def_builtin ("__builtin_vis_fmul8sux16", CODE_FOR_fmul8sux16_vis,
8488 v4hi_ftype_v8qi_v4hi);
8489 def_builtin ("__builtin_vis_fmul8ulx16", CODE_FOR_fmul8ulx16_vis,
8490 v4hi_ftype_v8qi_v4hi);
8491 def_builtin ("__builtin_vis_fmuld8sux16", CODE_FOR_fmuld8sux16_vis,
8492 v2si_ftype_v4qi_v2hi);
8493 def_builtin ("__builtin_vis_fmuld8ulx16", CODE_FOR_fmuld8ulx16_vis,
8494 v2si_ftype_v4qi_v2hi);
8496 /* Data aligning. */
8497 def_builtin ("__builtin_vis_faligndatav4hi", CODE_FOR_faligndatav4hi_vis,
8498 v4hi_ftype_v4hi_v4hi);
8499 def_builtin ("__builtin_vis_faligndatav8qi", CODE_FOR_faligndatav8qi_vis,
8500 v8qi_ftype_v8qi_v8qi);
8501 def_builtin ("__builtin_vis_faligndatav2si", CODE_FOR_faligndatav2si_vis,
8502 v2si_ftype_v2si_v2si);
8503 def_builtin ("__builtin_vis_faligndatadi", CODE_FOR_faligndatadi_vis,
8506 def_builtin ("__builtin_vis_alignaddr", CODE_FOR_alignaddrdi_vis,
8509 def_builtin ("__builtin_vis_alignaddr", CODE_FOR_alignaddrsi_vis,
8512 /* Pixel distance. */
8513 def_builtin ("__builtin_vis_pdist", CODE_FOR_pdist_vis,
8514 di_ftype_v8qi_v8qi_di);
8517 /* Handle TARGET_EXPAND_BUILTIN target hook.
8518 Expand builtin functions for sparc instrinsics. */
8521 sparc_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED,
8522 enum machine_mode tmode, int ignore ATTRIBUTE_UNUSED)
8525 tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
8526 unsigned int icode = DECL_FUNCTION_CODE (fndecl);
8528 enum machine_mode mode[4];
8531 mode[arg_count] = tmode;
8534 || GET_MODE (target) != tmode
8535 || ! (*insn_data[icode].operand[0].predicate) (target, tmode))
8536 op[arg_count] = gen_reg_rtx (tmode);
8538 op[arg_count] = target;
8540 for (arglist = TREE_OPERAND (exp, 1); arglist;
8541 arglist = TREE_CHAIN (arglist))
8543 tree arg = TREE_VALUE (arglist);
8546 mode[arg_count] = insn_data[icode].operand[arg_count].mode;
8547 op[arg_count] = expand_expr (arg, NULL_RTX, VOIDmode, 0);
8549 if (! (*insn_data[icode].operand[arg_count].predicate) (op[arg_count],
8551 op[arg_count] = copy_to_mode_reg (mode[arg_count], op[arg_count]);
8557 pat = GEN_FCN (icode) (op[0], op[1]);
8560 pat = GEN_FCN (icode) (op[0], op[1], op[2]);
8563 pat = GEN_FCN (icode) (op[0], op[1], op[2], op[3]);
8578 sparc_extra_constraint_check (rtx op, int c, int strict)
8583 && (c == 'T' || c == 'U'))
8589 return fp_sethi_p (op);
8592 return fp_mov_p (op);
8595 return fp_high_losum_p (op);
8599 || (GET_CODE (op) == REG
8600 && (REGNO (op) < FIRST_PSEUDO_REGISTER
8601 || reg_renumber[REGNO (op)] >= 0)))
8602 return register_ok_for_ldd (op);
8611 return fp_zero_operand (op, GET_MODE (op));
8617 /* Our memory extra constraints have to emulate the
8618 behavior of 'm' and 'o' in order for reload to work
8620 if (GET_CODE (op) == MEM)
8623 if ((TARGET_ARCH64 || mem_min_alignment (op, 8))
8625 || strict_memory_address_p (Pmode, XEXP (op, 0))))
8630 reload_ok_mem = (reload_in_progress
8631 && GET_CODE (op) == REG
8632 && REGNO (op) >= FIRST_PSEUDO_REGISTER
8633 && reg_renumber [REGNO (op)] < 0);
8636 return reload_ok_mem;
8639 /* ??? This duplicates information provided to the compiler by the
8640 ??? scheduler description. Some day, teach genautomata to output
8641 ??? the latencies and then CSE will just use that. */
8644 sparc_rtx_costs (rtx x, int code, int outer_code, int *total)
8646 enum machine_mode mode = GET_MODE (x);
8647 bool float_mode_p = FLOAT_MODE_P (mode);
8652 if (INTVAL (x) < 0x1000 && INTVAL (x) >= -0x1000)
8670 if (GET_MODE (x) == DImode
8671 && ((XINT (x, 3) == 0
8672 && (unsigned HOST_WIDE_INT) XINT (x, 2) < 0x1000)
8673 || (XINT (x, 3) == -1
8675 && XINT (x, 2) >= -0x1000)))
8682 /* If outer-code was a sign or zero extension, a cost
8683 of COSTS_N_INSNS (1) was already added in. This is
8684 why we are subtracting it back out. */
8685 if (outer_code == ZERO_EXTEND)
8687 *total = sparc_costs->int_zload - COSTS_N_INSNS (1);
8689 else if (outer_code == SIGN_EXTEND)
8691 *total = sparc_costs->int_sload - COSTS_N_INSNS (1);
8693 else if (float_mode_p)
8695 *total = sparc_costs->float_load;
8699 *total = sparc_costs->int_load;
8707 *total = sparc_costs->float_plusminus;
8709 *total = COSTS_N_INSNS (1);
8714 *total = sparc_costs->float_mul;
8715 else if (! TARGET_HARD_MUL)
8716 *total = COSTS_N_INSNS (25);
8722 if (sparc_costs->int_mul_bit_factor)
8726 if (GET_CODE (XEXP (x, 1)) == CONST_INT)
8728 unsigned HOST_WIDE_INT value = INTVAL (XEXP (x, 1));
8729 for (nbits = 0; value != 0; value &= value - 1)
8732 else if (GET_CODE (XEXP (x, 1)) == CONST_DOUBLE
8733 && GET_MODE (XEXP (x, 1)) == DImode)
8735 rtx x1 = XEXP (x, 1);
8736 unsigned HOST_WIDE_INT value1 = XINT (x1, 2);
8737 unsigned HOST_WIDE_INT value2 = XINT (x1, 3);
8739 for (nbits = 0; value1 != 0; value1 &= value1 - 1)
8741 for (; value2 != 0; value2 &= value2 - 1)
8749 bit_cost = (nbits - 3) / sparc_costs->int_mul_bit_factor;
8750 bit_cost = COSTS_N_INSNS (bit_cost);
8754 *total = sparc_costs->int_mulX + bit_cost;
8756 *total = sparc_costs->int_mul + bit_cost;
8763 *total = COSTS_N_INSNS (1) + sparc_costs->shift_penalty;
8773 *total = sparc_costs->float_div_df;
8775 *total = sparc_costs->float_div_sf;
8780 *total = sparc_costs->int_divX;
8782 *total = sparc_costs->int_div;
8789 *total = COSTS_N_INSNS (1);
8796 case UNSIGNED_FLOAT:
8800 case FLOAT_TRUNCATE:
8801 *total = sparc_costs->float_move;
8806 *total = sparc_costs->float_sqrt_df;
8808 *total = sparc_costs->float_sqrt_sf;
8813 *total = sparc_costs->float_cmp;
8815 *total = COSTS_N_INSNS (1);
8820 *total = sparc_costs->float_cmove;
8822 *total = sparc_costs->int_cmove;
8826 /* Handle the NAND vector patterns. */
8827 if (sparc_vector_mode_supported_p (GET_MODE (x))
8828 && GET_CODE (XEXP (x, 0)) == NOT
8829 && GET_CODE (XEXP (x, 1)) == NOT)
8831 *total = COSTS_N_INSNS (1);
8842 /* Emit the sequence of insns SEQ while preserving the register REG. */
8845 emit_and_preserve (rtx seq, rtx reg)
8847 rtx slot = gen_rtx_MEM (word_mode,
8848 plus_constant (stack_pointer_rtx, SPARC_STACK_BIAS));
8850 emit_insn (gen_stack_pointer_dec (GEN_INT (STACK_BOUNDARY/BITS_PER_UNIT)));
8851 emit_insn (gen_rtx_SET (VOIDmode, slot, reg));
8853 emit_insn (gen_rtx_SET (VOIDmode, reg, slot));
8854 emit_insn (gen_stack_pointer_inc (GEN_INT (STACK_BOUNDARY/BITS_PER_UNIT)));
8857 /* Output the assembler code for a thunk function. THUNK_DECL is the
8858 declaration for the thunk function itself, FUNCTION is the decl for
8859 the target function. DELTA is an immediate constant offset to be
8860 added to THIS. If VCALL_OFFSET is nonzero, the word at address
8861 (*THIS + VCALL_OFFSET) should be additionally added to THIS. */
8864 sparc_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED,
8865 HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset,
8868 rtx this, insn, funexp;
8869 unsigned int int_arg_first;
8871 reload_completed = 1;
8872 epilogue_completed = 1;
8874 reset_block_changes ();
8876 emit_note (NOTE_INSN_PROLOGUE_END);
8878 if (flag_delayed_branch)
8880 /* We will emit a regular sibcall below, so we need to instruct
8881 output_sibcall that we are in a leaf function. */
8882 sparc_leaf_function_p = current_function_uses_only_leaf_regs = 1;
8884 /* This will cause final.c to invoke leaf_renumber_regs so we
8885 must behave as if we were in a not-yet-leafified function. */
8886 int_arg_first = SPARC_INCOMING_INT_ARG_FIRST;
8890 /* We will emit the sibcall manually below, so we will need to
8891 manually spill non-leaf registers. */
8892 sparc_leaf_function_p = current_function_uses_only_leaf_regs = 0;
8894 /* We really are in a leaf function. */
8895 int_arg_first = SPARC_OUTGOING_INT_ARG_FIRST;
8898 /* Find the "this" pointer. Normally in %o0, but in ARCH64 if the function
8899 returns a structure, the structure return pointer is there instead. */
8900 if (TARGET_ARCH64 && aggregate_value_p (TREE_TYPE (TREE_TYPE (function)), function))
8901 this = gen_rtx_REG (Pmode, int_arg_first + 1);
8903 this = gen_rtx_REG (Pmode, int_arg_first);
8905 /* Add DELTA. When possible use a plain add, otherwise load it into
8906 a register first. */
8909 rtx delta_rtx = GEN_INT (delta);
8911 if (! SPARC_SIMM13_P (delta))
8913 rtx scratch = gen_rtx_REG (Pmode, 1);
8914 emit_move_insn (scratch, delta_rtx);
8915 delta_rtx = scratch;
8918 /* THIS += DELTA. */
8919 emit_insn (gen_add2_insn (this, delta_rtx));
8922 /* Add the word at address (*THIS + VCALL_OFFSET). */
8925 rtx vcall_offset_rtx = GEN_INT (vcall_offset);
8926 rtx scratch = gen_rtx_REG (Pmode, 1);
8928 gcc_assert (vcall_offset < 0);
8930 /* SCRATCH = *THIS. */
8931 emit_move_insn (scratch, gen_rtx_MEM (Pmode, this));
8933 /* Prepare for adding VCALL_OFFSET. The difficulty is that we
8934 may not have any available scratch register at this point. */
8935 if (SPARC_SIMM13_P (vcall_offset))
8937 /* This is the case if ARCH64 (unless -ffixed-g5 is passed). */
8938 else if (! fixed_regs[5]
8939 /* The below sequence is made up of at least 2 insns,
8940 while the default method may need only one. */
8941 && vcall_offset < -8192)
8943 rtx scratch2 = gen_rtx_REG (Pmode, 5);
8944 emit_move_insn (scratch2, vcall_offset_rtx);
8945 vcall_offset_rtx = scratch2;
8949 rtx increment = GEN_INT (-4096);
8951 /* VCALL_OFFSET is a negative number whose typical range can be
8952 estimated as -32768..0 in 32-bit mode. In almost all cases
8953 it is therefore cheaper to emit multiple add insns than
8954 spilling and loading the constant into a register (at least
8956 while (! SPARC_SIMM13_P (vcall_offset))
8958 emit_insn (gen_add2_insn (scratch, increment));
8959 vcall_offset += 4096;
8961 vcall_offset_rtx = GEN_INT (vcall_offset); /* cannot be 0 */
8964 /* SCRATCH = *(*THIS + VCALL_OFFSET). */
8965 emit_move_insn (scratch, gen_rtx_MEM (Pmode,
8966 gen_rtx_PLUS (Pmode,
8968 vcall_offset_rtx)));
8970 /* THIS += *(*THIS + VCALL_OFFSET). */
8971 emit_insn (gen_add2_insn (this, scratch));
8974 /* Generate a tail call to the target function. */
8975 if (! TREE_USED (function))
8977 assemble_external (function);
8978 TREE_USED (function) = 1;
8980 funexp = XEXP (DECL_RTL (function), 0);
8982 if (flag_delayed_branch)
8984 funexp = gen_rtx_MEM (FUNCTION_MODE, funexp);
8985 insn = emit_call_insn (gen_sibcall (funexp));
8986 SIBLING_CALL_P (insn) = 1;
8990 /* The hoops we have to jump through in order to generate a sibcall
8991 without using delay slots... */
8992 rtx spill_reg, seq, scratch = gen_rtx_REG (Pmode, 1);
8996 spill_reg = gen_rtx_REG (word_mode, 15); /* %o7 */
8998 /* Delay emitting the PIC helper function because it needs to
8999 change the section and we are emitting assembly code. */
9000 load_pic_register (true); /* clobbers %o7 */
9001 scratch = legitimize_pic_address (funexp, Pmode, scratch);
9004 emit_and_preserve (seq, spill_reg);
9006 else if (TARGET_ARCH32)
9008 emit_insn (gen_rtx_SET (VOIDmode,
9010 gen_rtx_HIGH (SImode, funexp)));
9011 emit_insn (gen_rtx_SET (VOIDmode,
9013 gen_rtx_LO_SUM (SImode, scratch, funexp)));
9015 else /* TARGET_ARCH64 */
9017 switch (sparc_cmodel)
9021 /* The destination can serve as a temporary. */
9022 sparc_emit_set_symbolic_const64 (scratch, funexp, scratch);
9027 /* The destination cannot serve as a temporary. */
9028 spill_reg = gen_rtx_REG (DImode, 15); /* %o7 */
9030 sparc_emit_set_symbolic_const64 (scratch, funexp, spill_reg);
9033 emit_and_preserve (seq, spill_reg);
9041 emit_jump_insn (gen_indirect_jump (scratch));
9046 /* Run just enough of rest_of_compilation to get the insns emitted.
9047 There's not really enough bulk here to make other passes such as
9048 instruction scheduling worth while. Note that use_thunk calls
9049 assemble_start_function and assemble_end_function. */
9050 insn = get_insns ();
9051 insn_locators_initialize ();
9052 shorten_branches (insn);
9053 final_start_function (insn, file, 1);
9054 final (insn, file, 1);
9055 final_end_function ();
9057 reload_completed = 0;
9058 epilogue_completed = 0;
9062 /* Return true if sparc_output_mi_thunk would be able to output the
9063 assembler code for the thunk function specified by the arguments
9064 it is passed, and false otherwise. */
9066 sparc_can_output_mi_thunk (tree thunk_fndecl ATTRIBUTE_UNUSED,
9067 HOST_WIDE_INT delta ATTRIBUTE_UNUSED,
9068 HOST_WIDE_INT vcall_offset,
9069 tree function ATTRIBUTE_UNUSED)
9071 /* Bound the loop used in the default method above. */
9072 return (vcall_offset >= -32768 || ! fixed_regs[5]);
9075 /* How to allocate a 'struct machine_function'. */
9077 static struct machine_function *
9078 sparc_init_machine_status (void)
9080 return ggc_alloc_cleared (sizeof (struct machine_function));
9083 /* Locate some local-dynamic symbol still in use by this function
9084 so that we can print its name in local-dynamic base patterns. */
9087 get_some_local_dynamic_name (void)
9091 if (cfun->machine->some_ld_name)
9092 return cfun->machine->some_ld_name;
9094 for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
9096 && for_each_rtx (&PATTERN (insn), get_some_local_dynamic_name_1, 0))
9097 return cfun->machine->some_ld_name;
9103 get_some_local_dynamic_name_1 (rtx *px, void *data ATTRIBUTE_UNUSED)
9108 && GET_CODE (x) == SYMBOL_REF
9109 && SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_DYNAMIC)
9111 cfun->machine->some_ld_name = XSTR (x, 0);
9118 /* Handle the TARGET_DWARF_HANDLE_FRAME_UNSPEC hook.
9119 This is called from dwarf2out.c to emit call frame instructions
9120 for frame-related insns containing UNSPECs and UNSPEC_VOLATILEs. */
9122 sparc_dwarf_handle_frame_unspec (const char *label,
9123 rtx pattern ATTRIBUTE_UNUSED,
9124 int index ATTRIBUTE_UNUSED)
9126 gcc_assert (index == UNSPECV_SAVEW);
9127 dwarf2out_window_save (label);
9130 /* This is called from dwarf2out.c via ASM_OUTPUT_DWARF_DTPREL.
9131 We need to emit DTP-relative relocations. */
9134 sparc_output_dwarf_dtprel (FILE *file, int size, rtx x)
9139 fputs ("\t.word\t%r_tls_dtpoff32(", file);
9142 fputs ("\t.xword\t%r_tls_dtpoff64(", file);
9147 output_addr_const (file, x);
9152 void sparc_file_end (void)
9154 /* If we haven't emitted the special PIC helper function, do so now. */
9155 if (pic_helper_symbol_name[0] && !pic_helper_emitted_p)
9158 if (NEED_INDICATE_EXEC_STACK)
9159 file_end_indicate_exec_stack ();
9162 #include "gt-sparc.h"