1 /* FR30 specific functions.
2 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004, 2005, 2007, 2008, 2009,
3 2010, 2011 Free Software Foundation, Inc.
4 Contributed by Cygnus Solutions.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
26 #include "coretypes.h"
30 #include "hard-reg-set.h"
31 #include "insn-config.h"
32 #include "conditions.h"
33 #include "insn-attr.h"
43 #include "diagnostic-core.h"
46 #include "target-def.h"
49 /*{{{ Function Prologues & Epilogues */
51 /* The FR30 stack looks like this:
53 Before call After call
55 +-----------------------+ +-----------------------+ high
57 | local variables, | | local variables, |
58 | reg save area, etc. | | reg save area, etc. |
60 +-----------------------+ +-----------------------+
62 | args to the func that | | args to this func. |
63 | is being called that | | |
64 SP ->| do not fit in regs | | |
65 +-----------------------+ +-----------------------+
66 | args that used to be | \
67 | in regs; only created | | pretend_size
68 AP-> | for vararg funcs | /
69 +-----------------------+
71 | register save area | |
73 +-----------------------+ | reg_size
75 +-----------------------+ |
76 FP ->| previous frame ptr | /
77 +-----------------------+
79 | local variables | | var_size
81 +-----------------------+
83 low | room for args to | |
84 memory | other funcs called | | args_size
87 +-----------------------+
89 Note, AP is a fake hard register. It will be eliminated in favor of
90 SP or FP as appropriate.
92 Note, Some or all of the stack sections above may be omitted if they
95 /* Structure to be filled in by fr30_compute_frame_size() with register
96 save masks, and offsets for the current function. */
97 struct fr30_frame_info
99 unsigned int total_size
; /* # Bytes that the entire frame takes up. */
100 unsigned int pretend_size
; /* # Bytes we push and pretend caller did. */
101 unsigned int args_size
; /* # Bytes that outgoing arguments take up. */
102 unsigned int reg_size
; /* # Bytes needed to store regs. */
103 unsigned int var_size
; /* # Bytes that variables take up. */
104 unsigned int frame_size
; /* # Bytes in current frame. */
105 unsigned int gmask
; /* Mask of saved registers. */
106 unsigned int save_fp
; /* Nonzero if frame pointer must be saved. */
107 unsigned int save_rp
; /* Nonzero if return pointer must be saved. */
108 int initialised
; /* Nonzero if frame size already calculated. */
111 /* Current frame information calculated by fr30_compute_frame_size(). */
112 static struct fr30_frame_info current_frame_info
;
114 /* Zero structure to initialize current_frame_info. */
115 static struct fr30_frame_info zero_frame_info
;
117 static void fr30_setup_incoming_varargs (CUMULATIVE_ARGS
*, enum machine_mode
,
119 static bool fr30_must_pass_in_stack (enum machine_mode
, const_tree
);
120 static int fr30_arg_partial_bytes (CUMULATIVE_ARGS
*, enum machine_mode
,
122 static rtx
fr30_function_arg (CUMULATIVE_ARGS
*, enum machine_mode
,
124 static void fr30_function_arg_advance (CUMULATIVE_ARGS
*, enum machine_mode
,
126 static bool fr30_frame_pointer_required (void);
127 static rtx
fr30_function_value (const_tree
, const_tree
, bool);
128 static rtx
fr30_libcall_value (enum machine_mode
, const_rtx
);
129 static bool fr30_function_value_regno_p (const unsigned int);
130 static bool fr30_can_eliminate (const int, const int);
131 static void fr30_asm_trampoline_template (FILE *);
132 static void fr30_trampoline_init (rtx
, tree
, rtx
);
133 static int fr30_num_arg_regs (enum machine_mode
, const_tree
);
135 #define FRAME_POINTER_MASK (1 << (FRAME_POINTER_REGNUM))
136 #define RETURN_POINTER_MASK (1 << (RETURN_POINTER_REGNUM))
138 /* Tell prologue and epilogue if register REGNO should be saved / restored.
139 The return address and frame pointer are treated separately.
140 Don't consider them here. */
141 #define MUST_SAVE_REGISTER(regno) \
142 ( (regno) != RETURN_POINTER_REGNUM \
143 && (regno) != FRAME_POINTER_REGNUM \
144 && df_regs_ever_live_p (regno) \
145 && ! call_used_regs [regno] )
147 #define MUST_SAVE_FRAME_POINTER (df_regs_ever_live_p (FRAME_POINTER_REGNUM) || frame_pointer_needed)
148 #define MUST_SAVE_RETURN_POINTER (df_regs_ever_live_p (RETURN_POINTER_REGNUM) || crtl->profile)
150 #if UNITS_PER_WORD == 4
151 #define WORD_ALIGN(SIZE) (((SIZE) + 3) & ~3)
154 /* Initialize the GCC target structure. */
155 #undef TARGET_ASM_ALIGNED_HI_OP
156 #define TARGET_ASM_ALIGNED_HI_OP "\t.hword\t"
157 #undef TARGET_ASM_ALIGNED_SI_OP
158 #define TARGET_ASM_ALIGNED_SI_OP "\t.word\t"
160 #undef TARGET_PROMOTE_PROTOTYPES
161 #define TARGET_PROMOTE_PROTOTYPES hook_bool_const_tree_true
162 #undef TARGET_PASS_BY_REFERENCE
163 #define TARGET_PASS_BY_REFERENCE hook_pass_by_reference_must_pass_in_stack
164 #undef TARGET_ARG_PARTIAL_BYTES
165 #define TARGET_ARG_PARTIAL_BYTES fr30_arg_partial_bytes
166 #undef TARGET_FUNCTION_ARG
167 #define TARGET_FUNCTION_ARG fr30_function_arg
168 #undef TARGET_FUNCTION_ARG_ADVANCE
169 #define TARGET_FUNCTION_ARG_ADVANCE fr30_function_arg_advance
171 #undef TARGET_FUNCTION_VALUE
172 #define TARGET_FUNCTION_VALUE fr30_function_value
173 #undef TARGET_LIBCALL_VALUE
174 #define TARGET_LIBCALL_VALUE fr30_libcall_value
175 #undef TARGET_FUNCTION_VALUE_REGNO_P
176 #define TARGET_FUNCTION_VALUE_REGNO_P fr30_function_value_regno_p
178 #undef TARGET_SETUP_INCOMING_VARARGS
179 #define TARGET_SETUP_INCOMING_VARARGS fr30_setup_incoming_varargs
180 #undef TARGET_MUST_PASS_IN_STACK
181 #define TARGET_MUST_PASS_IN_STACK fr30_must_pass_in_stack
183 #undef TARGET_FRAME_POINTER_REQUIRED
184 #define TARGET_FRAME_POINTER_REQUIRED fr30_frame_pointer_required
186 #undef TARGET_CAN_ELIMINATE
187 #define TARGET_CAN_ELIMINATE fr30_can_eliminate
189 #undef TARGET_ASM_TRAMPOLINE_TEMPLATE
190 #define TARGET_ASM_TRAMPOLINE_TEMPLATE fr30_asm_trampoline_template
191 #undef TARGET_TRAMPOLINE_INIT
192 #define TARGET_TRAMPOLINE_INIT fr30_trampoline_init
194 struct gcc_target targetm
= TARGET_INITIALIZER
;
197 /* Worker function for TARGET_CAN_ELIMINATE. */
200 fr30_can_eliminate (const int from ATTRIBUTE_UNUSED
, const int to
)
202 return (to
== FRAME_POINTER_REGNUM
|| ! frame_pointer_needed
);
205 /* Returns the number of bytes offset between FROM_REG and TO_REG
206 for the current function. As a side effect it fills in the
207 current_frame_info structure, if the data is available. */
209 fr30_compute_frame_size (int from_reg
, int to_reg
)
212 unsigned int return_value
;
213 unsigned int var_size
;
214 unsigned int args_size
;
215 unsigned int pretend_size
;
216 unsigned int reg_size
;
219 var_size
= WORD_ALIGN (get_frame_size ());
220 args_size
= WORD_ALIGN (crtl
->outgoing_args_size
);
221 pretend_size
= crtl
->args
.pretend_args_size
;
226 /* Calculate space needed for registers. */
227 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
229 if (MUST_SAVE_REGISTER (regno
))
231 reg_size
+= UNITS_PER_WORD
;
236 current_frame_info
.save_fp
= MUST_SAVE_FRAME_POINTER
;
237 current_frame_info
.save_rp
= MUST_SAVE_RETURN_POINTER
;
239 reg_size
+= (current_frame_info
.save_fp
+ current_frame_info
.save_rp
)
242 /* Save computed information. */
243 current_frame_info
.pretend_size
= pretend_size
;
244 current_frame_info
.var_size
= var_size
;
245 current_frame_info
.args_size
= args_size
;
246 current_frame_info
.reg_size
= reg_size
;
247 current_frame_info
.frame_size
= args_size
+ var_size
;
248 current_frame_info
.total_size
= args_size
+ var_size
+ reg_size
+ pretend_size
;
249 current_frame_info
.gmask
= gmask
;
250 current_frame_info
.initialised
= reload_completed
;
252 /* Calculate the required distance. */
255 if (to_reg
== STACK_POINTER_REGNUM
)
256 return_value
+= args_size
+ var_size
;
258 if (from_reg
== ARG_POINTER_REGNUM
)
259 return_value
+= reg_size
;
264 /* Called after register allocation to add any instructions needed for the
265 prologue. Using a prologue insn is favored compared to putting all of the
266 instructions in output_function_prologue(), since it allows the scheduler
267 to intermix instructions with the saves of the caller saved registers. In
268 some cases, it might be necessary to emit a barrier instruction as the last
269 insn to prevent such scheduling. */
272 fr30_expand_prologue (void)
277 if (! current_frame_info
.initialised
)
278 fr30_compute_frame_size (0, 0);
280 /* This cases shouldn't happen. Catch it now. */
281 gcc_assert (current_frame_info
.total_size
|| !current_frame_info
.gmask
);
283 /* Allocate space for register arguments if this is a variadic function. */
284 if (current_frame_info
.pretend_size
)
286 int regs_to_save
= current_frame_info
.pretend_size
/ UNITS_PER_WORD
;
288 /* Push argument registers into the pretend arg area. */
289 for (regno
= FIRST_ARG_REGNUM
+ FR30_NUM_ARG_REGS
; regno
--, regs_to_save
--;)
291 insn
= emit_insn (gen_movsi_push (gen_rtx_REG (Pmode
, regno
)));
292 RTX_FRAME_RELATED_P (insn
) = 1;
296 if (current_frame_info
.gmask
)
298 /* Save any needed call-saved regs. */
299 for (regno
= STACK_POINTER_REGNUM
; regno
--;)
301 if ((current_frame_info
.gmask
& (1 << regno
)) != 0)
303 insn
= emit_insn (gen_movsi_push (gen_rtx_REG (Pmode
, regno
)));
304 RTX_FRAME_RELATED_P (insn
) = 1;
309 /* Save return address if necessary. */
310 if (current_frame_info
.save_rp
)
312 insn
= emit_insn (gen_movsi_push (gen_rtx_REG (Pmode
,
313 RETURN_POINTER_REGNUM
)));
314 RTX_FRAME_RELATED_P (insn
) = 1;
317 /* Save old frame pointer and create new one, if necessary. */
318 if (current_frame_info
.save_fp
)
320 if (current_frame_info
.frame_size
< ((1 << 10) - UNITS_PER_WORD
))
322 int enter_size
= current_frame_info
.frame_size
+ UNITS_PER_WORD
;
325 insn
= emit_insn (gen_enter_func (GEN_INT (enter_size
)));
326 RTX_FRAME_RELATED_P (insn
) = 1;
328 pattern
= PATTERN (insn
);
330 /* Also mark all 3 subexpressions as RTX_FRAME_RELATED_P. */
331 if (GET_CODE (pattern
) == PARALLEL
)
334 for (x
= XVECLEN (pattern
, 0); x
--;)
336 rtx part
= XVECEXP (pattern
, 0, x
);
338 /* One of the insns in the ENTER pattern updates the
339 frame pointer. If we do not actually need the frame
340 pointer in this function then this is a side effect
341 rather than a desired effect, so we do not mark that
342 insn as being related to the frame set up. Doing this
343 allows us to compile the crash66.C test file in the
345 if (! frame_pointer_needed
346 && GET_CODE (part
) == SET
347 && SET_DEST (part
) == hard_frame_pointer_rtx
)
348 RTX_FRAME_RELATED_P (part
) = 0;
350 RTX_FRAME_RELATED_P (part
) = 1;
356 insn
= emit_insn (gen_movsi_push (frame_pointer_rtx
));
357 RTX_FRAME_RELATED_P (insn
) = 1;
359 if (frame_pointer_needed
)
361 insn
= emit_insn (gen_movsi (frame_pointer_rtx
, stack_pointer_rtx
));
362 RTX_FRAME_RELATED_P (insn
) = 1;
367 /* Allocate the stack frame. */
368 if (current_frame_info
.frame_size
== 0)
369 ; /* Nothing to do. */
370 else if (current_frame_info
.save_fp
371 && current_frame_info
.frame_size
< ((1 << 10) - UNITS_PER_WORD
))
372 ; /* Nothing to do. */
373 else if (current_frame_info
.frame_size
<= 512)
375 insn
= emit_insn (gen_add_to_stack
376 (GEN_INT (- (signed) current_frame_info
.frame_size
)));
377 RTX_FRAME_RELATED_P (insn
) = 1;
381 rtx tmp
= gen_rtx_REG (Pmode
, PROLOGUE_TMP_REGNUM
);
382 insn
= emit_insn (gen_movsi (tmp
, GEN_INT (current_frame_info
.frame_size
)));
383 RTX_FRAME_RELATED_P (insn
) = 1;
384 insn
= emit_insn (gen_subsi3 (stack_pointer_rtx
, stack_pointer_rtx
, tmp
));
385 RTX_FRAME_RELATED_P (insn
) = 1;
389 emit_insn (gen_blockage ());
392 /* Called after register allocation to add any instructions needed for the
393 epilogue. Using an epilogue insn is favored compared to putting all of the
394 instructions in output_function_epilogue(), since it allows the scheduler
395 to intermix instructions with the restores of the caller saved registers.
396 In some cases, it might be necessary to emit a barrier instruction as the
397 first insn to prevent such scheduling. */
399 fr30_expand_epilogue (void)
403 /* Perform the inversion operations of the prologue. */
404 gcc_assert (current_frame_info
.initialised
);
406 /* Pop local variables and arguments off the stack.
407 If frame_pointer_needed is TRUE then the frame pointer register
408 has actually been used as a frame pointer, and we can recover
409 the stack pointer from it, otherwise we must unwind the stack
411 if (current_frame_info
.frame_size
> 0)
413 if (current_frame_info
.save_fp
&& frame_pointer_needed
)
415 emit_insn (gen_leave_func ());
416 current_frame_info
.save_fp
= 0;
418 else if (current_frame_info
.frame_size
<= 508)
419 emit_insn (gen_add_to_stack
420 (GEN_INT (current_frame_info
.frame_size
)));
423 rtx tmp
= gen_rtx_REG (Pmode
, PROLOGUE_TMP_REGNUM
);
424 emit_insn (gen_movsi (tmp
, GEN_INT (current_frame_info
.frame_size
)));
425 emit_insn (gen_addsi3 (stack_pointer_rtx
, stack_pointer_rtx
, tmp
));
429 if (current_frame_info
.save_fp
)
430 emit_insn (gen_movsi_pop (frame_pointer_rtx
));
432 /* Pop all the registers that were pushed. */
433 if (current_frame_info
.save_rp
)
434 emit_insn (gen_movsi_pop (gen_rtx_REG (Pmode
, RETURN_POINTER_REGNUM
)));
436 for (regno
= 0; regno
< STACK_POINTER_REGNUM
; regno
++)
437 if (current_frame_info
.gmask
& (1 << regno
))
438 emit_insn (gen_movsi_pop (gen_rtx_REG (Pmode
, regno
)));
440 if (current_frame_info
.pretend_size
)
441 emit_insn (gen_add_to_stack (GEN_INT (current_frame_info
.pretend_size
)));
443 /* Reset state info for each function. */
444 current_frame_info
= zero_frame_info
;
446 emit_jump_insn (gen_return_from_func ());
449 /* Do any needed setup for a variadic function. We must create a register
450 parameter block, and then copy any anonymous arguments, plus the last
451 named argument, from registers into memory. * copying actually done in
452 fr30_expand_prologue().
454 ARG_REGS_USED_SO_FAR has *not* been updated for the last named argument
455 which has type TYPE and mode MODE, and we rely on this fact. */
457 fr30_setup_incoming_varargs (CUMULATIVE_ARGS
*arg_regs_used_so_far
,
458 enum machine_mode mode
,
459 tree type ATTRIBUTE_UNUSED
,
461 int second_time ATTRIBUTE_UNUSED
)
465 /* All BLKmode values are passed by reference. */
466 gcc_assert (mode
!= BLKmode
);
468 /* ??? This run-time test as well as the code inside the if
469 statement is probably unnecessary. */
470 if (targetm
.calls
.strict_argument_naming (arg_regs_used_so_far
))
471 /* If TARGET_STRICT_ARGUMENT_NAMING returns true, then the last named
472 arg must not be treated as an anonymous arg. */
473 arg_regs_used_so_far
+= fr30_num_arg_regs (mode
, type
);
475 size
= FR30_NUM_ARG_REGS
- (* arg_regs_used_so_far
);
480 * pretend_size
= (size
* UNITS_PER_WORD
);
484 /*{{{ Printing operands */
486 /* Print a memory address as an operand to reference that memory location. */
489 fr30_print_operand_address (FILE *stream
, rtx address
)
491 switch (GET_CODE (address
))
494 output_addr_const (stream
, address
);
498 fprintf (stderr
, "code = %x\n", GET_CODE (address
));
500 output_operand_lossage ("fr30_print_operand_address: unhandled address");
505 /* Print an operand. */
508 fr30_print_operand (FILE *file
, rtx x
, int code
)
515 /* Output a :D if this instruction is delayed. */
516 if (dbr_sequence_length () != 0)
521 /* Compute the register name of the second register in a hi/lo
523 if (GET_CODE (x
) != REG
)
524 output_operand_lossage ("fr30_print_operand: unrecognized %%p code");
526 fprintf (file
, "r%d", REGNO (x
) + 1);
530 /* Convert GCC's comparison operators into FR30 comparison codes. */
531 switch (GET_CODE (x
))
533 case EQ
: fprintf (file
, "eq"); break;
534 case NE
: fprintf (file
, "ne"); break;
535 case LT
: fprintf (file
, "lt"); break;
536 case LE
: fprintf (file
, "le"); break;
537 case GT
: fprintf (file
, "gt"); break;
538 case GE
: fprintf (file
, "ge"); break;
539 case LTU
: fprintf (file
, "c"); break;
540 case LEU
: fprintf (file
, "ls"); break;
541 case GTU
: fprintf (file
, "hi"); break;
542 case GEU
: fprintf (file
, "nc"); break;
544 output_operand_lossage ("fr30_print_operand: unrecognized %%b code");
550 /* Convert GCC's comparison operators into the complimentary FR30
552 switch (GET_CODE (x
))
554 case EQ
: fprintf (file
, "ne"); break;
555 case NE
: fprintf (file
, "eq"); break;
556 case LT
: fprintf (file
, "ge"); break;
557 case LE
: fprintf (file
, "gt"); break;
558 case GT
: fprintf (file
, "le"); break;
559 case GE
: fprintf (file
, "lt"); break;
560 case LTU
: fprintf (file
, "nc"); break;
561 case LEU
: fprintf (file
, "hi"); break;
562 case GTU
: fprintf (file
, "ls"); break;
563 case GEU
: fprintf (file
, "c"); break;
565 output_operand_lossage ("fr30_print_operand: unrecognized %%B code");
571 /* Print a signed byte value as an unsigned value. */
572 if (GET_CODE (x
) != CONST_INT
)
573 output_operand_lossage ("fr30_print_operand: invalid operand to %%A code");
582 fprintf (file
, HOST_WIDE_INT_PRINT_DEC
, val
);
587 if (GET_CODE (x
) != CONST_INT
590 output_operand_lossage ("fr30_print_operand: invalid %%x code");
592 fprintf (file
, HOST_WIDE_INT_PRINT_DEC
, INTVAL (x
) - 16);
596 if (GET_CODE (x
) != CONST_DOUBLE
)
597 output_operand_lossage ("fr30_print_operand: invalid %%F code");
602 real_to_decimal (str
, CONST_DOUBLE_REAL_VALUE (x
),
613 fprintf (stderr
, "unknown code = %x\n", code
);
614 output_operand_lossage ("fr30_print_operand: unknown code");
618 switch (GET_CODE (x
))
621 fputs (reg_names
[REGNO (x
)], file
);
627 switch (GET_CODE (x0
))
630 gcc_assert ((unsigned) REGNO (x0
) < ARRAY_SIZE (reg_names
));
631 fprintf (file
, "@%s", reg_names
[REGNO (x0
)]);
635 if (GET_CODE (XEXP (x0
, 0)) != REG
636 || REGNO (XEXP (x0
, 0)) < FRAME_POINTER_REGNUM
637 || REGNO (XEXP (x0
, 0)) > STACK_POINTER_REGNUM
638 || GET_CODE (XEXP (x0
, 1)) != CONST_INT
)
640 fprintf (stderr
, "bad INDEXed address:");
642 output_operand_lossage ("fr30_print_operand: unhandled MEM");
644 else if (REGNO (XEXP (x0
, 0)) == FRAME_POINTER_REGNUM
)
646 HOST_WIDE_INT val
= INTVAL (XEXP (x0
, 1));
647 if (val
< -(1 << 9) || val
> ((1 << 9) - 4))
649 fprintf (stderr
, "frame INDEX out of range:");
651 output_operand_lossage ("fr30_print_operand: unhandled MEM");
653 fprintf (file
, "@(r14, #" HOST_WIDE_INT_PRINT_DEC
")", val
);
657 HOST_WIDE_INT val
= INTVAL (XEXP (x0
, 1));
658 if (val
< 0 || val
> ((1 << 6) - 4))
660 fprintf (stderr
, "stack INDEX out of range:");
662 output_operand_lossage ("fr30_print_operand: unhandled MEM");
664 fprintf (file
, "@(r15, #" HOST_WIDE_INT_PRINT_DEC
")", val
);
673 fprintf (stderr
, "bad MEM code = %x\n", GET_CODE (x0
));
675 output_operand_lossage ("fr30_print_operand: unhandled MEM");
681 /* We handle SFmode constants here as output_addr_const doesn't. */
682 if (GET_MODE (x
) == SFmode
)
687 REAL_VALUE_FROM_CONST_DOUBLE (d
, x
);
688 REAL_VALUE_TO_TARGET_SINGLE (d
, l
);
689 fprintf (file
, "0x%08lx", l
);
693 /* Fall through. Let output_addr_const deal with it. */
695 output_addr_const (file
, x
);
704 /* Implements TARGET_FUNCTION_VALUE. */
707 fr30_function_value (const_tree valtype
,
708 const_tree fntype_or_decli ATTRIBUTE_UNUSED
,
709 bool outgoing ATTRIBUTE_UNUSED
)
711 return gen_rtx_REG (TYPE_MODE (valtype
), RETURN_VALUE_REGNUM
);
714 /* Implements TARGET_LIBCALL_VALUE. */
717 fr30_libcall_value (enum machine_mode mode
,
718 const_rtx fun ATTRIBUTE_UNUSED
)
720 return gen_rtx_REG (mode
, RETURN_VALUE_REGNUM
);
723 /* Implements TARGET_FUNCTION_VALUE_REGNO_P. */
726 fr30_function_value_regno_p (const unsigned int regno
)
728 return (regno
== RETURN_VALUE_REGNUM
);
731 /*{{{ Function arguments */
733 /* Return true if we should pass an argument on the stack rather than
737 fr30_must_pass_in_stack (enum machine_mode mode
, const_tree type
)
743 return AGGREGATE_TYPE_P (type
);
746 /* Compute the number of word sized registers needed to hold a
747 function argument of mode INT_MODE and tree type TYPE. */
749 fr30_num_arg_regs (enum machine_mode mode
, const_tree type
)
753 if (targetm
.calls
.must_pass_in_stack (mode
, type
))
756 if (type
&& mode
== BLKmode
)
757 size
= int_size_in_bytes (type
);
759 size
= GET_MODE_SIZE (mode
);
761 return (size
+ UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
764 /* Returns the number of bytes in which *part* of a parameter of machine
765 mode MODE and tree type TYPE (which may be NULL if the type is not known).
766 If the argument fits entirely in the argument registers, or entirely on
767 the stack, then 0 is returned.
768 CUM is the number of argument registers already used by earlier
769 parameters to the function. */
772 fr30_arg_partial_bytes (CUMULATIVE_ARGS
*cum
, enum machine_mode mode
,
773 tree type
, bool named
)
775 /* Unnamed arguments, i.e. those that are prototyped as ...
776 are always passed on the stack.
777 Also check here to see if all the argument registers are full. */
778 if (named
== 0 || *cum
>= FR30_NUM_ARG_REGS
)
781 /* Work out how many argument registers would be needed if this
782 parameter were to be passed entirely in registers. If there
783 are sufficient argument registers available (or if no registers
784 are needed because the parameter must be passed on the stack)
785 then return zero, as this parameter does not require partial
786 register, partial stack stack space. */
787 if (*cum
+ fr30_num_arg_regs (mode
, type
) <= FR30_NUM_ARG_REGS
)
790 return (FR30_NUM_ARG_REGS
- *cum
) * UNITS_PER_WORD
;
794 fr30_function_arg (CUMULATIVE_ARGS
*cum
, enum machine_mode mode
,
795 const_tree type
, bool named
)
798 || fr30_must_pass_in_stack (mode
, type
)
799 || *cum
>= FR30_NUM_ARG_REGS
)
802 return gen_rtx_REG (mode
, *cum
+ FIRST_ARG_REGNUM
);
805 /* A C statement (sans semicolon) to update the summarizer variable CUM to
806 advance past an argument in the argument list. The values MODE, TYPE and
807 NAMED describe that argument. Once this is done, the variable CUM is
808 suitable for analyzing the *following* argument with `FUNCTION_ARG', etc.
810 This macro need not do anything if the argument in question was passed on
811 the stack. The compiler knows how to track the amount of stack space used
812 for arguments without any special help. */
814 fr30_function_arg_advance (CUMULATIVE_ARGS
*cum
, enum machine_mode mode
,
815 const_tree type
, bool named
)
817 *cum
+= named
* fr30_num_arg_regs (mode
, type
);
821 /*{{{ Operand predicates */
824 #define Mmode enum machine_mode
827 /* Returns true iff all the registers in the operands array
828 are in descending or ascending order. */
830 fr30_check_multiple_regs (rtx
*operands
, int num_operands
, int descending
)
834 unsigned int prev_regno
= 0;
836 while (num_operands
--)
838 if (GET_CODE (operands
[num_operands
]) != REG
)
841 if (REGNO (operands
[num_operands
]) < prev_regno
)
844 prev_regno
= REGNO (operands
[num_operands
]);
849 unsigned int prev_regno
= CONDITION_CODE_REGNUM
;
851 while (num_operands
--)
853 if (GET_CODE (operands
[num_operands
]) != REG
)
856 if (REGNO (operands
[num_operands
]) > prev_regno
)
859 prev_regno
= REGNO (operands
[num_operands
]);
867 fr30_const_double_is_zero (rtx operand
)
871 if (operand
== NULL
|| GET_CODE (operand
) != CONST_DOUBLE
)
874 REAL_VALUE_FROM_CONST_DOUBLE (d
, operand
);
876 return REAL_VALUES_EQUAL (d
, dconst0
);
880 /*{{{ Instruction Output Routines */
882 /* Output a double word move.
883 It must be REG<-REG, REG<-MEM, MEM<-REG or REG<-CONST.
884 On the FR30 we are constrained by the fact that it does not
885 support offsetable addresses, and so we have to load the
886 address of the secnd word into the second destination register
887 before we can use it. */
890 fr30_move_double (rtx
* operands
)
892 rtx src
= operands
[1];
893 rtx dest
= operands
[0];
894 enum rtx_code src_code
= GET_CODE (src
);
895 enum rtx_code dest_code
= GET_CODE (dest
);
896 enum machine_mode mode
= GET_MODE (dest
);
901 if (dest_code
== REG
)
905 int reverse
= (REGNO (dest
) == REGNO (src
) + 1);
907 /* We normally copy the low-numbered register first. However, if
908 the first register of operand 0 is the same as the second register
909 of operand 1, we must copy in the opposite order. */
910 emit_insn (gen_rtx_SET (VOIDmode
,
911 operand_subword (dest
, reverse
, TRUE
, mode
),
912 operand_subword (src
, reverse
, TRUE
, mode
)));
914 emit_insn (gen_rtx_SET (VOIDmode
,
915 operand_subword (dest
, !reverse
, TRUE
, mode
),
916 operand_subword (src
, !reverse
, TRUE
, mode
)));
918 else if (src_code
== MEM
)
920 rtx addr
= XEXP (src
, 0);
921 rtx dest0
= operand_subword (dest
, 0, TRUE
, mode
);
922 rtx dest1
= operand_subword (dest
, 1, TRUE
, mode
);
925 gcc_assert (GET_CODE (addr
) == REG
);
927 /* Copy the address before clobbering it. See PR 34174. */
928 emit_insn (gen_rtx_SET (SImode
, dest1
, addr
));
929 emit_insn (gen_rtx_SET (VOIDmode
, dest0
,
930 adjust_address (src
, SImode
, 0)));
931 emit_insn (gen_rtx_SET (SImode
, dest1
,
932 plus_constant (dest1
, UNITS_PER_WORD
)));
934 new_mem
= gen_rtx_MEM (SImode
, dest1
);
935 MEM_COPY_ATTRIBUTES (new_mem
, src
);
937 emit_insn (gen_rtx_SET (VOIDmode
, dest1
, new_mem
));
939 else if (src_code
== CONST_INT
|| src_code
== CONST_DOUBLE
)
942 split_double (src
, &words
[0], &words
[1]);
943 emit_insn (gen_rtx_SET (VOIDmode
,
944 operand_subword (dest
, 0, TRUE
, mode
),
947 emit_insn (gen_rtx_SET (VOIDmode
,
948 operand_subword (dest
, 1, TRUE
, mode
),
952 else if (src_code
== REG
&& dest_code
== MEM
)
954 rtx addr
= XEXP (dest
, 0);
958 gcc_assert (GET_CODE (addr
) == REG
);
960 src0
= operand_subword (src
, 0, TRUE
, mode
);
961 src1
= operand_subword (src
, 1, TRUE
, mode
);
963 emit_move_insn (adjust_address (dest
, SImode
, 0), src0
);
965 if (REGNO (addr
) == STACK_POINTER_REGNUM
966 || REGNO (addr
) == FRAME_POINTER_REGNUM
)
967 emit_insn (gen_rtx_SET (VOIDmode
,
968 adjust_address (dest
, SImode
, UNITS_PER_WORD
),
973 rtx scratch_reg_r0
= gen_rtx_REG (SImode
, 0);
975 /* We need a scratch register to hold the value of 'address + 4'.
976 We use r0 for this purpose. It is used for example for long
977 jumps and is already marked to not be used by normal register
979 emit_insn (gen_movsi_internal (scratch_reg_r0
, addr
));
980 emit_insn (gen_addsi_small_int (scratch_reg_r0
, scratch_reg_r0
,
981 GEN_INT (UNITS_PER_WORD
)));
982 new_mem
= gen_rtx_MEM (SImode
, scratch_reg_r0
);
983 MEM_COPY_ATTRIBUTES (new_mem
, dest
);
984 emit_move_insn (new_mem
, src1
);
985 emit_insn (gen_blockage ());
989 /* This should have been prevented by the constraints on movdi_insn. */
998 /* Implement TARGET_FRAME_POINTER_REQUIRED. */
1001 fr30_frame_pointer_required (void)
1003 return (flag_omit_frame_pointer
== 0 || crtl
->args
.pretend_args_size
> 0);
1007 /*{{{ Trampoline Output Routines */
1009 /* Implement TARGET_ASM_TRAMPOLINE_TEMPLATE.
1010 On the FR30, the trampoline is:
1018 The no-ops are to guarantee that the static chain and final
1019 target are 32 bit aligned within the trampoline. That allows us to
1020 initialize those locations with simple SImode stores. The alternative
1021 would be to use HImode stores. */
1024 fr30_asm_trampoline_template (FILE *f
)
1026 fprintf (f
, "\tnop\n");
1027 fprintf (f
, "\tldi:32\t#0, %s\n", reg_names
[STATIC_CHAIN_REGNUM
]);
1028 fprintf (f
, "\tnop\n");
1029 fprintf (f
, "\tldi:32\t#0, %s\n", reg_names
[COMPILER_SCRATCH_REGISTER
]);
1030 fprintf (f
, "\tjmp\t@%s\n", reg_names
[COMPILER_SCRATCH_REGISTER
]);
1033 /* Implement TARGET_TRAMPOLINE_INIT. */
1036 fr30_trampoline_init (rtx m_tramp
, tree fndecl
, rtx chain_value
)
1038 rtx fnaddr
= XEXP (DECL_RTL (fndecl
), 0);
1041 emit_block_move (m_tramp
, assemble_trampoline_template (),
1042 GEN_INT (TRAMPOLINE_SIZE
), BLOCK_OP_NORMAL
);
1044 mem
= adjust_address (m_tramp
, SImode
, 4);
1045 emit_move_insn (mem
, chain_value
);
1046 mem
= adjust_address (m_tramp
, SImode
, 12);
1047 emit_move_insn (mem
, fnaddr
);
1051 /* Local Variables: */
1052 /* folded-file: t */