1 /* FR30 specific functions.
2 Copyright (C) 1998-2019 Free Software Foundation, Inc.
3 Contributed by Cygnus Solutions.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #define IN_TARGET_CODE 1
27 #include "coretypes.h"
32 #include "stringpool.h"
37 #include "stor-layout.h"
43 /* This file should be included last. */
44 #include "target-def.h"
47 /*{{{ Function Prologues & Epilogues */
49 /* The FR30 stack looks like this:
51 Before call After call
53 +-----------------------+ +-----------------------+ high
55 | local variables, | | local variables, |
56 | reg save area, etc. | | reg save area, etc. |
58 +-----------------------+ +-----------------------+
60 | args to the func that | | args to this func. |
61 | is being called that | | |
62 SP ->| do not fit in regs | | |
63 +-----------------------+ +-----------------------+
64 | args that used to be | \
65 | in regs; only created | | pretend_size
66 AP-> | for vararg funcs | /
67 +-----------------------+
69 | register save area | |
71 +-----------------------+ | reg_size
73 +-----------------------+ |
74 FP ->| previous frame ptr | /
75 +-----------------------+
77 | local variables | | var_size
79 +-----------------------+
81 low | room for args to | |
82 memory | other funcs called | | args_size
85 +-----------------------+
87 Note, AP is a fake hard register. It will be eliminated in favor of
88 SP or FP as appropriate.
90 Note, Some or all of the stack sections above may be omitted if they
93 /* Structure to be filled in by fr30_compute_frame_size() with register
94 save masks, and offsets for the current function. */
95 struct fr30_frame_info
97 unsigned int total_size
; /* # Bytes that the entire frame takes up. */
98 unsigned int pretend_size
; /* # Bytes we push and pretend caller did. */
99 unsigned int args_size
; /* # Bytes that outgoing arguments take up. */
100 unsigned int reg_size
; /* # Bytes needed to store regs. */
101 unsigned int var_size
; /* # Bytes that variables take up. */
102 unsigned int frame_size
; /* # Bytes in current frame. */
103 unsigned int gmask
; /* Mask of saved registers. */
104 unsigned int save_fp
; /* Nonzero if frame pointer must be saved. */
105 unsigned int save_rp
; /* Nonzero if return pointer must be saved. */
106 int initialised
; /* Nonzero if frame size already calculated. */
109 /* Current frame information calculated by fr30_compute_frame_size(). */
110 static struct fr30_frame_info current_frame_info
;
112 /* Zero structure to initialize current_frame_info. */
113 static struct fr30_frame_info zero_frame_info
;
115 static void fr30_setup_incoming_varargs (cumulative_args_t
, machine_mode
,
117 static bool fr30_must_pass_in_stack (machine_mode
, const_tree
);
118 static int fr30_arg_partial_bytes (cumulative_args_t
, machine_mode
,
120 static rtx
fr30_function_arg (cumulative_args_t
, machine_mode
,
122 static void fr30_function_arg_advance (cumulative_args_t
, machine_mode
,
124 static bool fr30_frame_pointer_required (void);
125 static rtx
fr30_function_value (const_tree
, const_tree
, bool);
126 static rtx
fr30_libcall_value (machine_mode
, const_rtx
);
127 static bool fr30_function_value_regno_p (const unsigned int);
128 static bool fr30_can_eliminate (const int, const int);
129 static void fr30_asm_trampoline_template (FILE *);
130 static void fr30_trampoline_init (rtx
, tree
, rtx
);
131 static int fr30_num_arg_regs (machine_mode
, const_tree
);
133 #define FRAME_POINTER_MASK (1 << (FRAME_POINTER_REGNUM))
134 #define RETURN_POINTER_MASK (1 << (RETURN_POINTER_REGNUM))
136 /* Tell prologue and epilogue if register REGNO should be saved / restored.
137 The return address and frame pointer are treated separately.
138 Don't consider them here. */
139 #define MUST_SAVE_REGISTER(regno) \
140 ( (regno) != RETURN_POINTER_REGNUM \
141 && (regno) != FRAME_POINTER_REGNUM \
142 && df_regs_ever_live_p (regno) \
143 && ! call_used_regs [regno] )
145 #define MUST_SAVE_FRAME_POINTER (df_regs_ever_live_p (FRAME_POINTER_REGNUM) || frame_pointer_needed)
146 #define MUST_SAVE_RETURN_POINTER (df_regs_ever_live_p (RETURN_POINTER_REGNUM) || crtl->profile)
148 #if UNITS_PER_WORD == 4
149 #define WORD_ALIGN(SIZE) (((SIZE) + 3) & ~3)
152 /* Initialize the GCC target structure. */
153 #undef TARGET_ASM_ALIGNED_HI_OP
154 #define TARGET_ASM_ALIGNED_HI_OP "\t.hword\t"
155 #undef TARGET_ASM_ALIGNED_SI_OP
156 #define TARGET_ASM_ALIGNED_SI_OP "\t.word\t"
158 #undef TARGET_PROMOTE_PROTOTYPES
159 #define TARGET_PROMOTE_PROTOTYPES hook_bool_const_tree_true
160 #undef TARGET_PASS_BY_REFERENCE
161 #define TARGET_PASS_BY_REFERENCE hook_pass_by_reference_must_pass_in_stack
162 #undef TARGET_ARG_PARTIAL_BYTES
163 #define TARGET_ARG_PARTIAL_BYTES fr30_arg_partial_bytes
164 #undef TARGET_FUNCTION_ARG
165 #define TARGET_FUNCTION_ARG fr30_function_arg
166 #undef TARGET_FUNCTION_ARG_ADVANCE
167 #define TARGET_FUNCTION_ARG_ADVANCE fr30_function_arg_advance
169 #undef TARGET_FUNCTION_VALUE
170 #define TARGET_FUNCTION_VALUE fr30_function_value
171 #undef TARGET_LIBCALL_VALUE
172 #define TARGET_LIBCALL_VALUE fr30_libcall_value
173 #undef TARGET_FUNCTION_VALUE_REGNO_P
174 #define TARGET_FUNCTION_VALUE_REGNO_P fr30_function_value_regno_p
176 #undef TARGET_SETUP_INCOMING_VARARGS
177 #define TARGET_SETUP_INCOMING_VARARGS fr30_setup_incoming_varargs
178 #undef TARGET_MUST_PASS_IN_STACK
179 #define TARGET_MUST_PASS_IN_STACK fr30_must_pass_in_stack
181 #undef TARGET_FRAME_POINTER_REQUIRED
182 #define TARGET_FRAME_POINTER_REQUIRED fr30_frame_pointer_required
184 #undef TARGET_CAN_ELIMINATE
185 #define TARGET_CAN_ELIMINATE fr30_can_eliminate
188 #define TARGET_LRA_P hook_bool_void_false
190 #undef TARGET_ASM_TRAMPOLINE_TEMPLATE
191 #define TARGET_ASM_TRAMPOLINE_TEMPLATE fr30_asm_trampoline_template
192 #undef TARGET_TRAMPOLINE_INIT
193 #define TARGET_TRAMPOLINE_INIT fr30_trampoline_init
195 #undef TARGET_CONSTANT_ALIGNMENT
196 #define TARGET_CONSTANT_ALIGNMENT constant_alignment_word_strings
198 #undef TARGET_HAVE_SPECULATION_SAFE_VALUE
199 #define TARGET_HAVE_SPECULATION_SAFE_VALUE speculation_safe_value_not_needed
201 struct gcc_target targetm
= TARGET_INITIALIZER
;
204 /* Worker function for TARGET_CAN_ELIMINATE. */
207 fr30_can_eliminate (const int from ATTRIBUTE_UNUSED
, const int to
)
209 return (to
== FRAME_POINTER_REGNUM
|| ! frame_pointer_needed
);
212 /* Returns the number of bytes offset between FROM_REG and TO_REG
213 for the current function. As a side effect it fills in the
214 current_frame_info structure, if the data is available. */
216 fr30_compute_frame_size (int from_reg
, int to_reg
)
219 unsigned int return_value
;
220 unsigned int var_size
;
221 unsigned int args_size
;
222 unsigned int pretend_size
;
223 unsigned int reg_size
;
226 var_size
= WORD_ALIGN (get_frame_size ());
227 args_size
= WORD_ALIGN (crtl
->outgoing_args_size
);
228 pretend_size
= crtl
->args
.pretend_args_size
;
233 /* Calculate space needed for registers. */
234 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
236 if (MUST_SAVE_REGISTER (regno
))
238 reg_size
+= UNITS_PER_WORD
;
243 current_frame_info
.save_fp
= MUST_SAVE_FRAME_POINTER
;
244 current_frame_info
.save_rp
= MUST_SAVE_RETURN_POINTER
;
246 reg_size
+= (current_frame_info
.save_fp
+ current_frame_info
.save_rp
)
249 /* Save computed information. */
250 current_frame_info
.pretend_size
= pretend_size
;
251 current_frame_info
.var_size
= var_size
;
252 current_frame_info
.args_size
= args_size
;
253 current_frame_info
.reg_size
= reg_size
;
254 current_frame_info
.frame_size
= args_size
+ var_size
;
255 current_frame_info
.total_size
= args_size
+ var_size
+ reg_size
+ pretend_size
;
256 current_frame_info
.gmask
= gmask
;
257 current_frame_info
.initialised
= reload_completed
;
259 /* Calculate the required distance. */
262 if (to_reg
== STACK_POINTER_REGNUM
)
263 return_value
+= args_size
+ var_size
;
265 if (from_reg
== ARG_POINTER_REGNUM
)
266 return_value
+= reg_size
;
271 /* Called after register allocation to add any instructions needed for the
272 prologue. Using a prologue insn is favored compared to putting all of the
273 instructions in output_function_prologue(), since it allows the scheduler
274 to intermix instructions with the saves of the caller saved registers. In
275 some cases, it might be necessary to emit a barrier instruction as the last
276 insn to prevent such scheduling. */
279 fr30_expand_prologue (void)
284 if (! current_frame_info
.initialised
)
285 fr30_compute_frame_size (0, 0);
287 /* This cases shouldn't happen. Catch it now. */
288 gcc_assert (current_frame_info
.total_size
|| !current_frame_info
.gmask
);
290 /* Allocate space for register arguments if this is a variadic function. */
291 if (current_frame_info
.pretend_size
)
293 int regs_to_save
= current_frame_info
.pretend_size
/ UNITS_PER_WORD
;
295 /* Push argument registers into the pretend arg area. */
296 for (regno
= FIRST_ARG_REGNUM
+ FR30_NUM_ARG_REGS
; regno
--, regs_to_save
--;)
298 insn
= emit_insn (gen_movsi_push (gen_rtx_REG (Pmode
, regno
)));
299 RTX_FRAME_RELATED_P (insn
) = 1;
303 if (current_frame_info
.gmask
)
305 /* Save any needed call-saved regs. */
306 for (regno
= STACK_POINTER_REGNUM
; regno
--;)
308 if ((current_frame_info
.gmask
& (1 << regno
)) != 0)
310 insn
= emit_insn (gen_movsi_push (gen_rtx_REG (Pmode
, regno
)));
311 RTX_FRAME_RELATED_P (insn
) = 1;
316 /* Save return address if necessary. */
317 if (current_frame_info
.save_rp
)
319 insn
= emit_insn (gen_movsi_push (gen_rtx_REG (Pmode
,
320 RETURN_POINTER_REGNUM
)));
321 RTX_FRAME_RELATED_P (insn
) = 1;
324 /* Save old frame pointer and create new one, if necessary. */
325 if (current_frame_info
.save_fp
)
327 if (current_frame_info
.frame_size
< ((1 << 10) - UNITS_PER_WORD
))
329 int enter_size
= current_frame_info
.frame_size
+ UNITS_PER_WORD
;
332 insn
= emit_insn (gen_enter_func (GEN_INT (enter_size
)));
333 RTX_FRAME_RELATED_P (insn
) = 1;
335 pattern
= PATTERN (insn
);
337 /* Also mark all 3 subexpressions as RTX_FRAME_RELATED_P. */
338 if (GET_CODE (pattern
) == PARALLEL
)
341 for (x
= XVECLEN (pattern
, 0); x
--;)
343 rtx part
= XVECEXP (pattern
, 0, x
);
345 /* One of the insns in the ENTER pattern updates the
346 frame pointer. If we do not actually need the frame
347 pointer in this function then this is a side effect
348 rather than a desired effect, so we do not mark that
349 insn as being related to the frame set up. Doing this
350 allows us to compile the crash66.C test file in the
352 if (! frame_pointer_needed
353 && GET_CODE (part
) == SET
354 && SET_DEST (part
) == hard_frame_pointer_rtx
)
355 RTX_FRAME_RELATED_P (part
) = 0;
357 RTX_FRAME_RELATED_P (part
) = 1;
363 insn
= emit_insn (gen_movsi_push (frame_pointer_rtx
));
364 RTX_FRAME_RELATED_P (insn
) = 1;
366 if (frame_pointer_needed
)
368 insn
= emit_insn (gen_movsi (frame_pointer_rtx
, stack_pointer_rtx
));
369 RTX_FRAME_RELATED_P (insn
) = 1;
374 /* Allocate the stack frame. */
375 if (current_frame_info
.frame_size
== 0)
376 ; /* Nothing to do. */
377 else if (current_frame_info
.save_fp
378 && current_frame_info
.frame_size
< ((1 << 10) - UNITS_PER_WORD
))
379 ; /* Nothing to do. */
380 else if (current_frame_info
.frame_size
<= 512)
382 insn
= emit_insn (gen_add_to_stack
383 (GEN_INT (- (signed) current_frame_info
.frame_size
)));
384 RTX_FRAME_RELATED_P (insn
) = 1;
388 rtx tmp
= gen_rtx_REG (Pmode
, PROLOGUE_TMP_REGNUM
);
389 insn
= emit_insn (gen_movsi (tmp
, GEN_INT (current_frame_info
.frame_size
)));
390 RTX_FRAME_RELATED_P (insn
) = 1;
391 insn
= emit_insn (gen_subsi3 (stack_pointer_rtx
, stack_pointer_rtx
, tmp
));
392 RTX_FRAME_RELATED_P (insn
) = 1;
396 emit_insn (gen_blockage ());
399 /* Called after register allocation to add any instructions needed for the
400 epilogue. Using an epilogue insn is favored compared to putting all of the
401 instructions in output_function_epilogue(), since it allows the scheduler
402 to intermix instructions with the restores of the caller saved registers.
403 In some cases, it might be necessary to emit a barrier instruction as the
404 first insn to prevent such scheduling. */
406 fr30_expand_epilogue (void)
410 /* Perform the inversion operations of the prologue. */
411 gcc_assert (current_frame_info
.initialised
);
413 /* Pop local variables and arguments off the stack.
414 If frame_pointer_needed is TRUE then the frame pointer register
415 has actually been used as a frame pointer, and we can recover
416 the stack pointer from it, otherwise we must unwind the stack
418 if (current_frame_info
.frame_size
> 0)
420 if (current_frame_info
.save_fp
&& frame_pointer_needed
)
422 emit_insn (gen_leave_func ());
423 current_frame_info
.save_fp
= 0;
425 else if (current_frame_info
.frame_size
<= 508)
426 emit_insn (gen_add_to_stack
427 (GEN_INT (current_frame_info
.frame_size
)));
430 rtx tmp
= gen_rtx_REG (Pmode
, PROLOGUE_TMP_REGNUM
);
431 emit_insn (gen_movsi (tmp
, GEN_INT (current_frame_info
.frame_size
)));
432 emit_insn (gen_addsi3 (stack_pointer_rtx
, stack_pointer_rtx
, tmp
));
436 if (current_frame_info
.save_fp
)
437 emit_insn (gen_movsi_pop (frame_pointer_rtx
));
439 /* Pop all the registers that were pushed. */
440 if (current_frame_info
.save_rp
)
441 emit_insn (gen_movsi_pop (gen_rtx_REG (Pmode
, RETURN_POINTER_REGNUM
)));
443 for (regno
= 0; regno
< STACK_POINTER_REGNUM
; regno
++)
444 if (current_frame_info
.gmask
& (1 << regno
))
445 emit_insn (gen_movsi_pop (gen_rtx_REG (Pmode
, regno
)));
447 if (current_frame_info
.pretend_size
)
448 emit_insn (gen_add_to_stack (GEN_INT (current_frame_info
.pretend_size
)));
450 /* Reset state info for each function. */
451 current_frame_info
= zero_frame_info
;
453 emit_jump_insn (gen_return_from_func ());
456 /* Do any needed setup for a variadic function. We must create a register
457 parameter block, and then copy any anonymous arguments, plus the last
458 named argument, from registers into memory. * copying actually done in
459 fr30_expand_prologue().
461 ARG_REGS_USED_SO_FAR has *not* been updated for the last named argument
462 which has type TYPE and mode MODE, and we rely on this fact. */
464 fr30_setup_incoming_varargs (cumulative_args_t arg_regs_used_so_far_v
,
466 tree type ATTRIBUTE_UNUSED
,
468 int second_time ATTRIBUTE_UNUSED
)
470 CUMULATIVE_ARGS
*arg_regs_used_so_far
471 = get_cumulative_args (arg_regs_used_so_far_v
);
474 /* All BLKmode values are passed by reference. */
475 gcc_assert (mode
!= BLKmode
);
477 /* ??? This run-time test as well as the code inside the if
478 statement is probably unnecessary. */
479 if (targetm
.calls
.strict_argument_naming (arg_regs_used_so_far_v
))
480 /* If TARGET_STRICT_ARGUMENT_NAMING returns true, then the last named
481 arg must not be treated as an anonymous arg. */
482 /* ??? This is a pointer increment, which makes no sense. */
483 arg_regs_used_so_far
+= fr30_num_arg_regs (mode
, type
);
485 size
= FR30_NUM_ARG_REGS
- (* arg_regs_used_so_far
);
490 * pretend_size
= (size
* UNITS_PER_WORD
);
494 /*{{{ Printing operands */
496 /* Print a memory address as an operand to reference that memory location. */
499 fr30_print_operand_address (FILE *stream
, rtx address
)
501 switch (GET_CODE (address
))
504 output_addr_const (stream
, address
);
508 fprintf (stderr
, "code = %x\n", GET_CODE (address
));
510 output_operand_lossage ("fr30_print_operand_address: unhandled address");
515 /* Print an operand. */
518 fr30_print_operand (FILE *file
, rtx x
, int code
)
525 /* Output a :D if this instruction is delayed. */
526 if (dbr_sequence_length () != 0)
531 /* Compute the register name of the second register in a hi/lo
533 if (GET_CODE (x
) != REG
)
534 output_operand_lossage ("fr30_print_operand: unrecognized %%p code");
536 fprintf (file
, "r%d", REGNO (x
) + 1);
540 /* Convert GCC's comparison operators into FR30 comparison codes. */
541 switch (GET_CODE (x
))
543 case EQ
: fprintf (file
, "eq"); break;
544 case NE
: fprintf (file
, "ne"); break;
545 case LT
: fprintf (file
, "lt"); break;
546 case LE
: fprintf (file
, "le"); break;
547 case GT
: fprintf (file
, "gt"); break;
548 case GE
: fprintf (file
, "ge"); break;
549 case LTU
: fprintf (file
, "c"); break;
550 case LEU
: fprintf (file
, "ls"); break;
551 case GTU
: fprintf (file
, "hi"); break;
552 case GEU
: fprintf (file
, "nc"); break;
554 output_operand_lossage ("fr30_print_operand: unrecognized %%b code");
560 /* Convert GCC's comparison operators into the complimentary FR30
562 switch (GET_CODE (x
))
564 case EQ
: fprintf (file
, "ne"); break;
565 case NE
: fprintf (file
, "eq"); break;
566 case LT
: fprintf (file
, "ge"); break;
567 case LE
: fprintf (file
, "gt"); break;
568 case GT
: fprintf (file
, "le"); break;
569 case GE
: fprintf (file
, "lt"); break;
570 case LTU
: fprintf (file
, "nc"); break;
571 case LEU
: fprintf (file
, "hi"); break;
572 case GTU
: fprintf (file
, "ls"); break;
573 case GEU
: fprintf (file
, "c"); break;
575 output_operand_lossage ("fr30_print_operand: unrecognized %%B code");
581 /* Print a signed byte value as an unsigned value. */
582 if (GET_CODE (x
) != CONST_INT
)
583 output_operand_lossage ("fr30_print_operand: invalid operand to %%A code");
592 fprintf (file
, HOST_WIDE_INT_PRINT_DEC
, val
);
597 if (GET_CODE (x
) != CONST_INT
600 output_operand_lossage ("fr30_print_operand: invalid %%x code");
602 fprintf (file
, HOST_WIDE_INT_PRINT_DEC
, INTVAL (x
) - 16);
606 if (GET_CODE (x
) != CONST_DOUBLE
)
607 output_operand_lossage ("fr30_print_operand: invalid %%F code");
612 real_to_decimal (str
, CONST_DOUBLE_REAL_VALUE (x
),
623 fprintf (stderr
, "unknown code = %x\n", code
);
624 output_operand_lossage ("fr30_print_operand: unknown code");
628 switch (GET_CODE (x
))
631 fputs (reg_names
[REGNO (x
)], file
);
637 switch (GET_CODE (x0
))
640 gcc_assert ((unsigned) REGNO (x0
) < ARRAY_SIZE (reg_names
));
641 fprintf (file
, "@%s", reg_names
[REGNO (x0
)]);
645 if (GET_CODE (XEXP (x0
, 0)) != REG
646 || REGNO (XEXP (x0
, 0)) < FRAME_POINTER_REGNUM
647 || REGNO (XEXP (x0
, 0)) > STACK_POINTER_REGNUM
648 || GET_CODE (XEXP (x0
, 1)) != CONST_INT
)
650 fprintf (stderr
, "bad INDEXed address:");
652 output_operand_lossage ("fr30_print_operand: unhandled MEM");
654 else if (REGNO (XEXP (x0
, 0)) == FRAME_POINTER_REGNUM
)
656 HOST_WIDE_INT val
= INTVAL (XEXP (x0
, 1));
657 if (val
< -(1 << 9) || val
> ((1 << 9) - 4))
659 fprintf (stderr
, "frame INDEX out of range:");
661 output_operand_lossage ("fr30_print_operand: unhandled MEM");
663 fprintf (file
, "@(r14, #" HOST_WIDE_INT_PRINT_DEC
")", val
);
667 HOST_WIDE_INT val
= INTVAL (XEXP (x0
, 1));
668 if (val
< 0 || val
> ((1 << 6) - 4))
670 fprintf (stderr
, "stack INDEX out of range:");
672 output_operand_lossage ("fr30_print_operand: unhandled MEM");
674 fprintf (file
, "@(r15, #" HOST_WIDE_INT_PRINT_DEC
")", val
);
679 output_address (VOIDmode
, x0
);
683 fprintf (stderr
, "bad MEM code = %x\n", GET_CODE (x0
));
685 output_operand_lossage ("fr30_print_operand: unhandled MEM");
691 /* We handle SFmode constants here as output_addr_const doesn't. */
692 if (GET_MODE (x
) == SFmode
)
696 REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (x
), l
);
697 fprintf (file
, "0x%08lx", l
);
702 /* Let output_addr_const deal with it. */
704 output_addr_const (file
, x
);
713 /* Implements TARGET_FUNCTION_VALUE. */
716 fr30_function_value (const_tree valtype
,
717 const_tree fntype_or_decli ATTRIBUTE_UNUSED
,
718 bool outgoing ATTRIBUTE_UNUSED
)
720 return gen_rtx_REG (TYPE_MODE (valtype
), RETURN_VALUE_REGNUM
);
723 /* Implements TARGET_LIBCALL_VALUE. */
726 fr30_libcall_value (machine_mode mode
,
727 const_rtx fun ATTRIBUTE_UNUSED
)
729 return gen_rtx_REG (mode
, RETURN_VALUE_REGNUM
);
732 /* Implements TARGET_FUNCTION_VALUE_REGNO_P. */
735 fr30_function_value_regno_p (const unsigned int regno
)
737 return (regno
== RETURN_VALUE_REGNUM
);
740 /*{{{ Function arguments */
742 /* Return true if we should pass an argument on the stack rather than
746 fr30_must_pass_in_stack (machine_mode mode
, const_tree type
)
752 return AGGREGATE_TYPE_P (type
);
755 /* Compute the number of word sized registers needed to hold a
756 function argument of mode INT_MODE and tree type TYPE. */
758 fr30_num_arg_regs (machine_mode mode
, const_tree type
)
762 if (targetm
.calls
.must_pass_in_stack (mode
, type
))
765 if (type
&& mode
== BLKmode
)
766 size
= int_size_in_bytes (type
);
768 size
= GET_MODE_SIZE (mode
);
770 return (size
+ UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
773 /* Returns the number of bytes in which *part* of a parameter of machine
774 mode MODE and tree type TYPE (which may be NULL if the type is not known).
775 If the argument fits entirely in the argument registers, or entirely on
776 the stack, then 0 is returned.
777 CUM is the number of argument registers already used by earlier
778 parameters to the function. */
781 fr30_arg_partial_bytes (cumulative_args_t cum_v
, machine_mode mode
,
782 tree type
, bool named
)
784 CUMULATIVE_ARGS
*cum
= get_cumulative_args (cum_v
);
786 /* Unnamed arguments, i.e. those that are prototyped as ...
787 are always passed on the stack.
788 Also check here to see if all the argument registers are full. */
789 if (named
== 0 || *cum
>= FR30_NUM_ARG_REGS
)
792 /* Work out how many argument registers would be needed if this
793 parameter were to be passed entirely in registers. If there
794 are sufficient argument registers available (or if no registers
795 are needed because the parameter must be passed on the stack)
796 then return zero, as this parameter does not require partial
797 register, partial stack stack space. */
798 if (*cum
+ fr30_num_arg_regs (mode
, type
) <= FR30_NUM_ARG_REGS
)
801 return (FR30_NUM_ARG_REGS
- *cum
) * UNITS_PER_WORD
;
805 fr30_function_arg (cumulative_args_t cum_v
, machine_mode mode
,
806 const_tree type
, bool named
)
808 CUMULATIVE_ARGS
*cum
= get_cumulative_args (cum_v
);
811 || fr30_must_pass_in_stack (mode
, type
)
812 || *cum
>= FR30_NUM_ARG_REGS
)
815 return gen_rtx_REG (mode
, *cum
+ FIRST_ARG_REGNUM
);
818 /* A C statement (sans semicolon) to update the summarizer variable CUM to
819 advance past an argument in the argument list. The values MODE, TYPE and
820 NAMED describe that argument. Once this is done, the variable CUM is
821 suitable for analyzing the *following* argument with `FUNCTION_ARG', etc.
823 This macro need not do anything if the argument in question was passed on
824 the stack. The compiler knows how to track the amount of stack space used
825 for arguments without any special help. */
827 fr30_function_arg_advance (cumulative_args_t cum
, machine_mode mode
,
828 const_tree type
, bool named
)
830 *get_cumulative_args (cum
) += named
* fr30_num_arg_regs (mode
, type
);
834 /*{{{ Operand predicates */
837 #define Mmode machine_mode
840 /* Returns true iff all the registers in the operands array
841 are in descending or ascending order. */
843 fr30_check_multiple_regs (rtx
*operands
, int num_operands
, int descending
)
847 unsigned int prev_regno
= 0;
849 while (num_operands
--)
851 if (GET_CODE (operands
[num_operands
]) != REG
)
854 if (REGNO (operands
[num_operands
]) < prev_regno
)
857 prev_regno
= REGNO (operands
[num_operands
]);
862 unsigned int prev_regno
= CONDITION_CODE_REGNUM
;
864 while (num_operands
--)
866 if (GET_CODE (operands
[num_operands
]) != REG
)
869 if (REGNO (operands
[num_operands
]) > prev_regno
)
872 prev_regno
= REGNO (operands
[num_operands
]);
880 fr30_const_double_is_zero (rtx operand
)
882 if (operand
== NULL
|| GET_CODE (operand
) != CONST_DOUBLE
)
885 return real_equal (CONST_DOUBLE_REAL_VALUE (operand
), &dconst0
);
889 /*{{{ Instruction Output Routines */
891 /* Output a double word move.
892 It must be REG<-REG, REG<-MEM, MEM<-REG or REG<-CONST.
893 On the FR30 we are constrained by the fact that it does not
894 support offsetable addresses, and so we have to load the
895 address of the secnd word into the second destination register
896 before we can use it. */
899 fr30_move_double (rtx
* operands
)
901 rtx src
= operands
[1];
902 rtx dest
= operands
[0];
903 enum rtx_code src_code
= GET_CODE (src
);
904 enum rtx_code dest_code
= GET_CODE (dest
);
905 machine_mode mode
= GET_MODE (dest
);
910 if (dest_code
== REG
)
914 int reverse
= (REGNO (dest
) == REGNO (src
) + 1);
916 /* We normally copy the low-numbered register first. However, if
917 the first register of operand 0 is the same as the second register
918 of operand 1, we must copy in the opposite order. */
919 emit_insn (gen_rtx_SET (operand_subword (dest
, reverse
, TRUE
, mode
),
920 operand_subword (src
, reverse
, TRUE
, mode
)));
923 (gen_rtx_SET (operand_subword (dest
, !reverse
, TRUE
, mode
),
924 operand_subword (src
, !reverse
, TRUE
, mode
)));
926 else if (src_code
== MEM
)
928 rtx addr
= XEXP (src
, 0);
929 rtx dest0
= operand_subword (dest
, 0, TRUE
, mode
);
930 rtx dest1
= operand_subword (dest
, 1, TRUE
, mode
);
933 gcc_assert (GET_CODE (addr
) == REG
);
935 /* Copy the address before clobbering it. See PR 34174. */
936 emit_insn (gen_rtx_SET (dest1
, addr
));
937 emit_insn (gen_rtx_SET (dest0
, adjust_address (src
, SImode
, 0)));
938 emit_insn (gen_rtx_SET (dest1
, plus_constant (SImode
, dest1
,
941 new_mem
= gen_rtx_MEM (SImode
, dest1
);
942 MEM_COPY_ATTRIBUTES (new_mem
, src
);
944 emit_insn (gen_rtx_SET (dest1
, new_mem
));
946 else if (src_code
== CONST_INT
|| src_code
== CONST_DOUBLE
)
949 split_double (src
, &words
[0], &words
[1]);
950 emit_insn (gen_rtx_SET (operand_subword (dest
, 0, TRUE
, mode
),
953 emit_insn (gen_rtx_SET (operand_subword (dest
, 1, TRUE
, mode
),
957 else if (src_code
== REG
&& dest_code
== MEM
)
959 rtx addr
= XEXP (dest
, 0);
963 gcc_assert (GET_CODE (addr
) == REG
);
965 src0
= operand_subword (src
, 0, TRUE
, mode
);
966 src1
= operand_subword (src
, 1, TRUE
, mode
);
968 emit_move_insn (adjust_address (dest
, SImode
, 0), src0
);
970 if (REGNO (addr
) == STACK_POINTER_REGNUM
971 || REGNO (addr
) == FRAME_POINTER_REGNUM
)
972 emit_insn (gen_rtx_SET (adjust_address (dest
, SImode
, UNITS_PER_WORD
),
977 rtx scratch_reg_r0
= gen_rtx_REG (SImode
, 0);
979 /* We need a scratch register to hold the value of 'address + 4'.
980 We use r0 for this purpose. It is used for example for long
981 jumps and is already marked to not be used by normal register
983 emit_insn (gen_movsi_internal (scratch_reg_r0
, addr
));
984 emit_insn (gen_addsi_small_int (scratch_reg_r0
, scratch_reg_r0
,
985 GEN_INT (UNITS_PER_WORD
)));
986 new_mem
= gen_rtx_MEM (SImode
, scratch_reg_r0
);
987 MEM_COPY_ATTRIBUTES (new_mem
, dest
);
988 emit_move_insn (new_mem
, src1
);
989 emit_insn (gen_blockage ());
993 /* This should have been prevented by the constraints on movdi_insn. */
1002 /* Implement TARGET_FRAME_POINTER_REQUIRED. */
1005 fr30_frame_pointer_required (void)
1007 return (flag_omit_frame_pointer
== 0 || crtl
->args
.pretend_args_size
> 0);
1011 /*{{{ Trampoline Output Routines */
1013 /* Implement TARGET_ASM_TRAMPOLINE_TEMPLATE.
1014 On the FR30, the trampoline is:
1022 The no-ops are to guarantee that the static chain and final
1023 target are 32 bit aligned within the trampoline. That allows us to
1024 initialize those locations with simple SImode stores. The alternative
1025 would be to use HImode stores. */
1028 fr30_asm_trampoline_template (FILE *f
)
1030 fprintf (f
, "\tnop\n");
1031 fprintf (f
, "\tldi:32\t#0, %s\n", reg_names
[STATIC_CHAIN_REGNUM
]);
1032 fprintf (f
, "\tnop\n");
1033 fprintf (f
, "\tldi:32\t#0, %s\n", reg_names
[COMPILER_SCRATCH_REGISTER
]);
1034 fprintf (f
, "\tjmp\t@%s\n", reg_names
[COMPILER_SCRATCH_REGISTER
]);
1037 /* Implement TARGET_TRAMPOLINE_INIT. */
1040 fr30_trampoline_init (rtx m_tramp
, tree fndecl
, rtx chain_value
)
1042 rtx fnaddr
= XEXP (DECL_RTL (fndecl
), 0);
1045 emit_block_move (m_tramp
, assemble_trampoline_template (),
1046 GEN_INT (TRAMPOLINE_SIZE
), BLOCK_OP_NORMAL
);
1048 mem
= adjust_address (m_tramp
, SImode
, 4);
1049 emit_move_insn (mem
, chain_value
);
1050 mem
= adjust_address (m_tramp
, SImode
, 12);
1051 emit_move_insn (mem
, fnaddr
);
1055 /* Local Variables: */
1056 /* folded-file: t */