1 /* FR30 specific functions.
2 Copyright (C) 1998-2013 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/>. */
25 #include "coretypes.h"
29 #include "hard-reg-set.h"
30 #include "insn-config.h"
31 #include "conditions.h"
32 #include "insn-attr.h"
36 #include "stor-layout.h"
44 #include "diagnostic-core.h"
47 #include "target-def.h"
50 /*{{{ Function Prologues & Epilogues */
52 /* The FR30 stack looks like this:
54 Before call After call
56 +-----------------------+ +-----------------------+ high
58 | local variables, | | local variables, |
59 | reg save area, etc. | | reg save area, etc. |
61 +-----------------------+ +-----------------------+
63 | args to the func that | | args to this func. |
64 | is being called that | | |
65 SP ->| do not fit in regs | | |
66 +-----------------------+ +-----------------------+
67 | args that used to be | \
68 | in regs; only created | | pretend_size
69 AP-> | for vararg funcs | /
70 +-----------------------+
72 | register save area | |
74 +-----------------------+ | reg_size
76 +-----------------------+ |
77 FP ->| previous frame ptr | /
78 +-----------------------+
80 | local variables | | var_size
82 +-----------------------+
84 low | room for args to | |
85 memory | other funcs called | | args_size
88 +-----------------------+
90 Note, AP is a fake hard register. It will be eliminated in favor of
91 SP or FP as appropriate.
93 Note, Some or all of the stack sections above may be omitted if they
96 /* Structure to be filled in by fr30_compute_frame_size() with register
97 save masks, and offsets for the current function. */
98 struct fr30_frame_info
100 unsigned int total_size
; /* # Bytes that the entire frame takes up. */
101 unsigned int pretend_size
; /* # Bytes we push and pretend caller did. */
102 unsigned int args_size
; /* # Bytes that outgoing arguments take up. */
103 unsigned int reg_size
; /* # Bytes needed to store regs. */
104 unsigned int var_size
; /* # Bytes that variables take up. */
105 unsigned int frame_size
; /* # Bytes in current frame. */
106 unsigned int gmask
; /* Mask of saved registers. */
107 unsigned int save_fp
; /* Nonzero if frame pointer must be saved. */
108 unsigned int save_rp
; /* Nonzero if return pointer must be saved. */
109 int initialised
; /* Nonzero if frame size already calculated. */
112 /* Current frame information calculated by fr30_compute_frame_size(). */
113 static struct fr30_frame_info current_frame_info
;
115 /* Zero structure to initialize current_frame_info. */
116 static struct fr30_frame_info zero_frame_info
;
118 static void fr30_setup_incoming_varargs (cumulative_args_t
, enum machine_mode
,
120 static bool fr30_must_pass_in_stack (enum machine_mode
, const_tree
);
121 static int fr30_arg_partial_bytes (cumulative_args_t
, enum machine_mode
,
123 static rtx
fr30_function_arg (cumulative_args_t
, enum machine_mode
,
125 static void fr30_function_arg_advance (cumulative_args_t
, enum machine_mode
,
127 static bool fr30_frame_pointer_required (void);
128 static rtx
fr30_function_value (const_tree
, const_tree
, bool);
129 static rtx
fr30_libcall_value (enum machine_mode
, const_rtx
);
130 static bool fr30_function_value_regno_p (const unsigned int);
131 static bool fr30_can_eliminate (const int, const int);
132 static void fr30_asm_trampoline_template (FILE *);
133 static void fr30_trampoline_init (rtx
, tree
, rtx
);
134 static int fr30_num_arg_regs (enum machine_mode
, const_tree
);
136 #define FRAME_POINTER_MASK (1 << (FRAME_POINTER_REGNUM))
137 #define RETURN_POINTER_MASK (1 << (RETURN_POINTER_REGNUM))
139 /* Tell prologue and epilogue if register REGNO should be saved / restored.
140 The return address and frame pointer are treated separately.
141 Don't consider them here. */
142 #define MUST_SAVE_REGISTER(regno) \
143 ( (regno) != RETURN_POINTER_REGNUM \
144 && (regno) != FRAME_POINTER_REGNUM \
145 && df_regs_ever_live_p (regno) \
146 && ! call_used_regs [regno] )
148 #define MUST_SAVE_FRAME_POINTER (df_regs_ever_live_p (FRAME_POINTER_REGNUM) || frame_pointer_needed)
149 #define MUST_SAVE_RETURN_POINTER (df_regs_ever_live_p (RETURN_POINTER_REGNUM) || crtl->profile)
151 #if UNITS_PER_WORD == 4
152 #define WORD_ALIGN(SIZE) (((SIZE) + 3) & ~3)
155 /* Initialize the GCC target structure. */
156 #undef TARGET_ASM_ALIGNED_HI_OP
157 #define TARGET_ASM_ALIGNED_HI_OP "\t.hword\t"
158 #undef TARGET_ASM_ALIGNED_SI_OP
159 #define TARGET_ASM_ALIGNED_SI_OP "\t.word\t"
161 #undef TARGET_PROMOTE_PROTOTYPES
162 #define TARGET_PROMOTE_PROTOTYPES hook_bool_const_tree_true
163 #undef TARGET_PASS_BY_REFERENCE
164 #define TARGET_PASS_BY_REFERENCE hook_pass_by_reference_must_pass_in_stack
165 #undef TARGET_ARG_PARTIAL_BYTES
166 #define TARGET_ARG_PARTIAL_BYTES fr30_arg_partial_bytes
167 #undef TARGET_FUNCTION_ARG
168 #define TARGET_FUNCTION_ARG fr30_function_arg
169 #undef TARGET_FUNCTION_ARG_ADVANCE
170 #define TARGET_FUNCTION_ARG_ADVANCE fr30_function_arg_advance
172 #undef TARGET_FUNCTION_VALUE
173 #define TARGET_FUNCTION_VALUE fr30_function_value
174 #undef TARGET_LIBCALL_VALUE
175 #define TARGET_LIBCALL_VALUE fr30_libcall_value
176 #undef TARGET_FUNCTION_VALUE_REGNO_P
177 #define TARGET_FUNCTION_VALUE_REGNO_P fr30_function_value_regno_p
179 #undef TARGET_SETUP_INCOMING_VARARGS
180 #define TARGET_SETUP_INCOMING_VARARGS fr30_setup_incoming_varargs
181 #undef TARGET_MUST_PASS_IN_STACK
182 #define TARGET_MUST_PASS_IN_STACK fr30_must_pass_in_stack
184 #undef TARGET_FRAME_POINTER_REQUIRED
185 #define TARGET_FRAME_POINTER_REQUIRED fr30_frame_pointer_required
187 #undef TARGET_CAN_ELIMINATE
188 #define TARGET_CAN_ELIMINATE fr30_can_eliminate
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 struct gcc_target targetm
= TARGET_INITIALIZER
;
198 /* Worker function for TARGET_CAN_ELIMINATE. */
201 fr30_can_eliminate (const int from ATTRIBUTE_UNUSED
, const int to
)
203 return (to
== FRAME_POINTER_REGNUM
|| ! frame_pointer_needed
);
206 /* Returns the number of bytes offset between FROM_REG and TO_REG
207 for the current function. As a side effect it fills in the
208 current_frame_info structure, if the data is available. */
210 fr30_compute_frame_size (int from_reg
, int to_reg
)
213 unsigned int return_value
;
214 unsigned int var_size
;
215 unsigned int args_size
;
216 unsigned int pretend_size
;
217 unsigned int reg_size
;
220 var_size
= WORD_ALIGN (get_frame_size ());
221 args_size
= WORD_ALIGN (crtl
->outgoing_args_size
);
222 pretend_size
= crtl
->args
.pretend_args_size
;
227 /* Calculate space needed for registers. */
228 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
230 if (MUST_SAVE_REGISTER (regno
))
232 reg_size
+= UNITS_PER_WORD
;
237 current_frame_info
.save_fp
= MUST_SAVE_FRAME_POINTER
;
238 current_frame_info
.save_rp
= MUST_SAVE_RETURN_POINTER
;
240 reg_size
+= (current_frame_info
.save_fp
+ current_frame_info
.save_rp
)
243 /* Save computed information. */
244 current_frame_info
.pretend_size
= pretend_size
;
245 current_frame_info
.var_size
= var_size
;
246 current_frame_info
.args_size
= args_size
;
247 current_frame_info
.reg_size
= reg_size
;
248 current_frame_info
.frame_size
= args_size
+ var_size
;
249 current_frame_info
.total_size
= args_size
+ var_size
+ reg_size
+ pretend_size
;
250 current_frame_info
.gmask
= gmask
;
251 current_frame_info
.initialised
= reload_completed
;
253 /* Calculate the required distance. */
256 if (to_reg
== STACK_POINTER_REGNUM
)
257 return_value
+= args_size
+ var_size
;
259 if (from_reg
== ARG_POINTER_REGNUM
)
260 return_value
+= reg_size
;
265 /* Called after register allocation to add any instructions needed for the
266 prologue. Using a prologue insn is favored compared to putting all of the
267 instructions in output_function_prologue(), since it allows the scheduler
268 to intermix instructions with the saves of the caller saved registers. In
269 some cases, it might be necessary to emit a barrier instruction as the last
270 insn to prevent such scheduling. */
273 fr30_expand_prologue (void)
278 if (! current_frame_info
.initialised
)
279 fr30_compute_frame_size (0, 0);
281 /* This cases shouldn't happen. Catch it now. */
282 gcc_assert (current_frame_info
.total_size
|| !current_frame_info
.gmask
);
284 /* Allocate space for register arguments if this is a variadic function. */
285 if (current_frame_info
.pretend_size
)
287 int regs_to_save
= current_frame_info
.pretend_size
/ UNITS_PER_WORD
;
289 /* Push argument registers into the pretend arg area. */
290 for (regno
= FIRST_ARG_REGNUM
+ FR30_NUM_ARG_REGS
; regno
--, regs_to_save
--;)
292 insn
= emit_insn (gen_movsi_push (gen_rtx_REG (Pmode
, regno
)));
293 RTX_FRAME_RELATED_P (insn
) = 1;
297 if (current_frame_info
.gmask
)
299 /* Save any needed call-saved regs. */
300 for (regno
= STACK_POINTER_REGNUM
; regno
--;)
302 if ((current_frame_info
.gmask
& (1 << regno
)) != 0)
304 insn
= emit_insn (gen_movsi_push (gen_rtx_REG (Pmode
, regno
)));
305 RTX_FRAME_RELATED_P (insn
) = 1;
310 /* Save return address if necessary. */
311 if (current_frame_info
.save_rp
)
313 insn
= emit_insn (gen_movsi_push (gen_rtx_REG (Pmode
,
314 RETURN_POINTER_REGNUM
)));
315 RTX_FRAME_RELATED_P (insn
) = 1;
318 /* Save old frame pointer and create new one, if necessary. */
319 if (current_frame_info
.save_fp
)
321 if (current_frame_info
.frame_size
< ((1 << 10) - UNITS_PER_WORD
))
323 int enter_size
= current_frame_info
.frame_size
+ UNITS_PER_WORD
;
326 insn
= emit_insn (gen_enter_func (GEN_INT (enter_size
)));
327 RTX_FRAME_RELATED_P (insn
) = 1;
329 pattern
= PATTERN (insn
);
331 /* Also mark all 3 subexpressions as RTX_FRAME_RELATED_P. */
332 if (GET_CODE (pattern
) == PARALLEL
)
335 for (x
= XVECLEN (pattern
, 0); x
--;)
337 rtx part
= XVECEXP (pattern
, 0, x
);
339 /* One of the insns in the ENTER pattern updates the
340 frame pointer. If we do not actually need the frame
341 pointer in this function then this is a side effect
342 rather than a desired effect, so we do not mark that
343 insn as being related to the frame set up. Doing this
344 allows us to compile the crash66.C test file in the
346 if (! frame_pointer_needed
347 && GET_CODE (part
) == SET
348 && SET_DEST (part
) == hard_frame_pointer_rtx
)
349 RTX_FRAME_RELATED_P (part
) = 0;
351 RTX_FRAME_RELATED_P (part
) = 1;
357 insn
= emit_insn (gen_movsi_push (frame_pointer_rtx
));
358 RTX_FRAME_RELATED_P (insn
) = 1;
360 if (frame_pointer_needed
)
362 insn
= emit_insn (gen_movsi (frame_pointer_rtx
, stack_pointer_rtx
));
363 RTX_FRAME_RELATED_P (insn
) = 1;
368 /* Allocate the stack frame. */
369 if (current_frame_info
.frame_size
== 0)
370 ; /* Nothing to do. */
371 else if (current_frame_info
.save_fp
372 && current_frame_info
.frame_size
< ((1 << 10) - UNITS_PER_WORD
))
373 ; /* Nothing to do. */
374 else if (current_frame_info
.frame_size
<= 512)
376 insn
= emit_insn (gen_add_to_stack
377 (GEN_INT (- (signed) current_frame_info
.frame_size
)));
378 RTX_FRAME_RELATED_P (insn
) = 1;
382 rtx tmp
= gen_rtx_REG (Pmode
, PROLOGUE_TMP_REGNUM
);
383 insn
= emit_insn (gen_movsi (tmp
, GEN_INT (current_frame_info
.frame_size
)));
384 RTX_FRAME_RELATED_P (insn
) = 1;
385 insn
= emit_insn (gen_subsi3 (stack_pointer_rtx
, stack_pointer_rtx
, tmp
));
386 RTX_FRAME_RELATED_P (insn
) = 1;
390 emit_insn (gen_blockage ());
393 /* Called after register allocation to add any instructions needed for the
394 epilogue. Using an epilogue insn is favored compared to putting all of the
395 instructions in output_function_epilogue(), since it allows the scheduler
396 to intermix instructions with the restores of the caller saved registers.
397 In some cases, it might be necessary to emit a barrier instruction as the
398 first insn to prevent such scheduling. */
400 fr30_expand_epilogue (void)
404 /* Perform the inversion operations of the prologue. */
405 gcc_assert (current_frame_info
.initialised
);
407 /* Pop local variables and arguments off the stack.
408 If frame_pointer_needed is TRUE then the frame pointer register
409 has actually been used as a frame pointer, and we can recover
410 the stack pointer from it, otherwise we must unwind the stack
412 if (current_frame_info
.frame_size
> 0)
414 if (current_frame_info
.save_fp
&& frame_pointer_needed
)
416 emit_insn (gen_leave_func ());
417 current_frame_info
.save_fp
= 0;
419 else if (current_frame_info
.frame_size
<= 508)
420 emit_insn (gen_add_to_stack
421 (GEN_INT (current_frame_info
.frame_size
)));
424 rtx tmp
= gen_rtx_REG (Pmode
, PROLOGUE_TMP_REGNUM
);
425 emit_insn (gen_movsi (tmp
, GEN_INT (current_frame_info
.frame_size
)));
426 emit_insn (gen_addsi3 (stack_pointer_rtx
, stack_pointer_rtx
, tmp
));
430 if (current_frame_info
.save_fp
)
431 emit_insn (gen_movsi_pop (frame_pointer_rtx
));
433 /* Pop all the registers that were pushed. */
434 if (current_frame_info
.save_rp
)
435 emit_insn (gen_movsi_pop (gen_rtx_REG (Pmode
, RETURN_POINTER_REGNUM
)));
437 for (regno
= 0; regno
< STACK_POINTER_REGNUM
; regno
++)
438 if (current_frame_info
.gmask
& (1 << regno
))
439 emit_insn (gen_movsi_pop (gen_rtx_REG (Pmode
, regno
)));
441 if (current_frame_info
.pretend_size
)
442 emit_insn (gen_add_to_stack (GEN_INT (current_frame_info
.pretend_size
)));
444 /* Reset state info for each function. */
445 current_frame_info
= zero_frame_info
;
447 emit_jump_insn (gen_return_from_func ());
450 /* Do any needed setup for a variadic function. We must create a register
451 parameter block, and then copy any anonymous arguments, plus the last
452 named argument, from registers into memory. * copying actually done in
453 fr30_expand_prologue().
455 ARG_REGS_USED_SO_FAR has *not* been updated for the last named argument
456 which has type TYPE and mode MODE, and we rely on this fact. */
458 fr30_setup_incoming_varargs (cumulative_args_t arg_regs_used_so_far_v
,
459 enum machine_mode mode
,
460 tree type ATTRIBUTE_UNUSED
,
462 int second_time ATTRIBUTE_UNUSED
)
464 CUMULATIVE_ARGS
*arg_regs_used_so_far
465 = get_cumulative_args (arg_regs_used_so_far_v
);
468 /* All BLKmode values are passed by reference. */
469 gcc_assert (mode
!= BLKmode
);
471 /* ??? This run-time test as well as the code inside the if
472 statement is probably unnecessary. */
473 if (targetm
.calls
.strict_argument_naming (arg_regs_used_so_far_v
))
474 /* If TARGET_STRICT_ARGUMENT_NAMING returns true, then the last named
475 arg must not be treated as an anonymous arg. */
476 /* ??? This is a pointer increment, which makes no sense. */
477 arg_regs_used_so_far
+= fr30_num_arg_regs (mode
, type
);
479 size
= FR30_NUM_ARG_REGS
- (* arg_regs_used_so_far
);
484 * pretend_size
= (size
* UNITS_PER_WORD
);
488 /*{{{ Printing operands */
490 /* Print a memory address as an operand to reference that memory location. */
493 fr30_print_operand_address (FILE *stream
, rtx address
)
495 switch (GET_CODE (address
))
498 output_addr_const (stream
, address
);
502 fprintf (stderr
, "code = %x\n", GET_CODE (address
));
504 output_operand_lossage ("fr30_print_operand_address: unhandled address");
509 /* Print an operand. */
512 fr30_print_operand (FILE *file
, rtx x
, int code
)
519 /* Output a :D if this instruction is delayed. */
520 if (dbr_sequence_length () != 0)
525 /* Compute the register name of the second register in a hi/lo
527 if (GET_CODE (x
) != REG
)
528 output_operand_lossage ("fr30_print_operand: unrecognized %%p code");
530 fprintf (file
, "r%d", REGNO (x
) + 1);
534 /* Convert GCC's comparison operators into FR30 comparison codes. */
535 switch (GET_CODE (x
))
537 case EQ
: fprintf (file
, "eq"); break;
538 case NE
: fprintf (file
, "ne"); break;
539 case LT
: fprintf (file
, "lt"); break;
540 case LE
: fprintf (file
, "le"); break;
541 case GT
: fprintf (file
, "gt"); break;
542 case GE
: fprintf (file
, "ge"); break;
543 case LTU
: fprintf (file
, "c"); break;
544 case LEU
: fprintf (file
, "ls"); break;
545 case GTU
: fprintf (file
, "hi"); break;
546 case GEU
: fprintf (file
, "nc"); break;
548 output_operand_lossage ("fr30_print_operand: unrecognized %%b code");
554 /* Convert GCC's comparison operators into the complimentary FR30
556 switch (GET_CODE (x
))
558 case EQ
: fprintf (file
, "ne"); break;
559 case NE
: fprintf (file
, "eq"); break;
560 case LT
: fprintf (file
, "ge"); break;
561 case LE
: fprintf (file
, "gt"); break;
562 case GT
: fprintf (file
, "le"); break;
563 case GE
: fprintf (file
, "lt"); break;
564 case LTU
: fprintf (file
, "nc"); break;
565 case LEU
: fprintf (file
, "hi"); break;
566 case GTU
: fprintf (file
, "ls"); break;
567 case GEU
: fprintf (file
, "c"); break;
569 output_operand_lossage ("fr30_print_operand: unrecognized %%B code");
575 /* Print a signed byte value as an unsigned value. */
576 if (GET_CODE (x
) != CONST_INT
)
577 output_operand_lossage ("fr30_print_operand: invalid operand to %%A code");
586 fprintf (file
, HOST_WIDE_INT_PRINT_DEC
, val
);
591 if (GET_CODE (x
) != CONST_INT
594 output_operand_lossage ("fr30_print_operand: invalid %%x code");
596 fprintf (file
, HOST_WIDE_INT_PRINT_DEC
, INTVAL (x
) - 16);
600 if (GET_CODE (x
) != CONST_DOUBLE
)
601 output_operand_lossage ("fr30_print_operand: invalid %%F code");
606 real_to_decimal (str
, CONST_DOUBLE_REAL_VALUE (x
),
617 fprintf (stderr
, "unknown code = %x\n", code
);
618 output_operand_lossage ("fr30_print_operand: unknown code");
622 switch (GET_CODE (x
))
625 fputs (reg_names
[REGNO (x
)], file
);
631 switch (GET_CODE (x0
))
634 gcc_assert ((unsigned) REGNO (x0
) < ARRAY_SIZE (reg_names
));
635 fprintf (file
, "@%s", reg_names
[REGNO (x0
)]);
639 if (GET_CODE (XEXP (x0
, 0)) != REG
640 || REGNO (XEXP (x0
, 0)) < FRAME_POINTER_REGNUM
641 || REGNO (XEXP (x0
, 0)) > STACK_POINTER_REGNUM
642 || GET_CODE (XEXP (x0
, 1)) != CONST_INT
)
644 fprintf (stderr
, "bad INDEXed address:");
646 output_operand_lossage ("fr30_print_operand: unhandled MEM");
648 else if (REGNO (XEXP (x0
, 0)) == FRAME_POINTER_REGNUM
)
650 HOST_WIDE_INT val
= INTVAL (XEXP (x0
, 1));
651 if (val
< -(1 << 9) || val
> ((1 << 9) - 4))
653 fprintf (stderr
, "frame INDEX out of range:");
655 output_operand_lossage ("fr30_print_operand: unhandled MEM");
657 fprintf (file
, "@(r14, #" HOST_WIDE_INT_PRINT_DEC
")", val
);
661 HOST_WIDE_INT val
= INTVAL (XEXP (x0
, 1));
662 if (val
< 0 || val
> ((1 << 6) - 4))
664 fprintf (stderr
, "stack INDEX out of range:");
666 output_operand_lossage ("fr30_print_operand: unhandled MEM");
668 fprintf (file
, "@(r15, #" HOST_WIDE_INT_PRINT_DEC
")", val
);
677 fprintf (stderr
, "bad MEM code = %x\n", GET_CODE (x0
));
679 output_operand_lossage ("fr30_print_operand: unhandled MEM");
685 /* We handle SFmode constants here as output_addr_const doesn't. */
686 if (GET_MODE (x
) == SFmode
)
691 REAL_VALUE_FROM_CONST_DOUBLE (d
, x
);
692 REAL_VALUE_TO_TARGET_SINGLE (d
, l
);
693 fprintf (file
, "0x%08lx", l
);
697 /* Fall through. Let output_addr_const deal with it. */
699 output_addr_const (file
, x
);
708 /* Implements TARGET_FUNCTION_VALUE. */
711 fr30_function_value (const_tree valtype
,
712 const_tree fntype_or_decli ATTRIBUTE_UNUSED
,
713 bool outgoing ATTRIBUTE_UNUSED
)
715 return gen_rtx_REG (TYPE_MODE (valtype
), RETURN_VALUE_REGNUM
);
718 /* Implements TARGET_LIBCALL_VALUE. */
721 fr30_libcall_value (enum machine_mode mode
,
722 const_rtx fun ATTRIBUTE_UNUSED
)
724 return gen_rtx_REG (mode
, RETURN_VALUE_REGNUM
);
727 /* Implements TARGET_FUNCTION_VALUE_REGNO_P. */
730 fr30_function_value_regno_p (const unsigned int regno
)
732 return (regno
== RETURN_VALUE_REGNUM
);
735 /*{{{ Function arguments */
737 /* Return true if we should pass an argument on the stack rather than
741 fr30_must_pass_in_stack (enum machine_mode mode
, const_tree type
)
747 return AGGREGATE_TYPE_P (type
);
750 /* Compute the number of word sized registers needed to hold a
751 function argument of mode INT_MODE and tree type TYPE. */
753 fr30_num_arg_regs (enum machine_mode mode
, const_tree type
)
757 if (targetm
.calls
.must_pass_in_stack (mode
, type
))
760 if (type
&& mode
== BLKmode
)
761 size
= int_size_in_bytes (type
);
763 size
= GET_MODE_SIZE (mode
);
765 return (size
+ UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
768 /* Returns the number of bytes in which *part* of a parameter of machine
769 mode MODE and tree type TYPE (which may be NULL if the type is not known).
770 If the argument fits entirely in the argument registers, or entirely on
771 the stack, then 0 is returned.
772 CUM is the number of argument registers already used by earlier
773 parameters to the function. */
776 fr30_arg_partial_bytes (cumulative_args_t cum_v
, enum machine_mode mode
,
777 tree type
, bool named
)
779 CUMULATIVE_ARGS
*cum
= get_cumulative_args (cum_v
);
781 /* Unnamed arguments, i.e. those that are prototyped as ...
782 are always passed on the stack.
783 Also check here to see if all the argument registers are full. */
784 if (named
== 0 || *cum
>= FR30_NUM_ARG_REGS
)
787 /* Work out how many argument registers would be needed if this
788 parameter were to be passed entirely in registers. If there
789 are sufficient argument registers available (or if no registers
790 are needed because the parameter must be passed on the stack)
791 then return zero, as this parameter does not require partial
792 register, partial stack stack space. */
793 if (*cum
+ fr30_num_arg_regs (mode
, type
) <= FR30_NUM_ARG_REGS
)
796 return (FR30_NUM_ARG_REGS
- *cum
) * UNITS_PER_WORD
;
800 fr30_function_arg (cumulative_args_t cum_v
, enum machine_mode mode
,
801 const_tree type
, bool named
)
803 CUMULATIVE_ARGS
*cum
= get_cumulative_args (cum_v
);
806 || fr30_must_pass_in_stack (mode
, type
)
807 || *cum
>= FR30_NUM_ARG_REGS
)
810 return gen_rtx_REG (mode
, *cum
+ FIRST_ARG_REGNUM
);
813 /* A C statement (sans semicolon) to update the summarizer variable CUM to
814 advance past an argument in the argument list. The values MODE, TYPE and
815 NAMED describe that argument. Once this is done, the variable CUM is
816 suitable for analyzing the *following* argument with `FUNCTION_ARG', etc.
818 This macro need not do anything if the argument in question was passed on
819 the stack. The compiler knows how to track the amount of stack space used
820 for arguments without any special help. */
822 fr30_function_arg_advance (cumulative_args_t cum
, enum machine_mode mode
,
823 const_tree type
, bool named
)
825 *get_cumulative_args (cum
) += named
* fr30_num_arg_regs (mode
, type
);
829 /*{{{ Operand predicates */
832 #define Mmode enum machine_mode
835 /* Returns true iff all the registers in the operands array
836 are in descending or ascending order. */
838 fr30_check_multiple_regs (rtx
*operands
, int num_operands
, int descending
)
842 unsigned int prev_regno
= 0;
844 while (num_operands
--)
846 if (GET_CODE (operands
[num_operands
]) != REG
)
849 if (REGNO (operands
[num_operands
]) < prev_regno
)
852 prev_regno
= REGNO (operands
[num_operands
]);
857 unsigned int prev_regno
= CONDITION_CODE_REGNUM
;
859 while (num_operands
--)
861 if (GET_CODE (operands
[num_operands
]) != REG
)
864 if (REGNO (operands
[num_operands
]) > prev_regno
)
867 prev_regno
= REGNO (operands
[num_operands
]);
875 fr30_const_double_is_zero (rtx operand
)
879 if (operand
== NULL
|| GET_CODE (operand
) != CONST_DOUBLE
)
882 REAL_VALUE_FROM_CONST_DOUBLE (d
, operand
);
884 return REAL_VALUES_EQUAL (d
, dconst0
);
888 /*{{{ Instruction Output Routines */
890 /* Output a double word move.
891 It must be REG<-REG, REG<-MEM, MEM<-REG or REG<-CONST.
892 On the FR30 we are constrained by the fact that it does not
893 support offsetable addresses, and so we have to load the
894 address of the secnd word into the second destination register
895 before we can use it. */
898 fr30_move_double (rtx
* operands
)
900 rtx src
= operands
[1];
901 rtx dest
= operands
[0];
902 enum rtx_code src_code
= GET_CODE (src
);
903 enum rtx_code dest_code
= GET_CODE (dest
);
904 enum machine_mode mode
= GET_MODE (dest
);
909 if (dest_code
== REG
)
913 int reverse
= (REGNO (dest
) == REGNO (src
) + 1);
915 /* We normally copy the low-numbered register first. However, if
916 the first register of operand 0 is the same as the second register
917 of operand 1, we must copy in the opposite order. */
918 emit_insn (gen_rtx_SET (VOIDmode
,
919 operand_subword (dest
, reverse
, TRUE
, mode
),
920 operand_subword (src
, reverse
, TRUE
, mode
)));
922 emit_insn (gen_rtx_SET (VOIDmode
,
923 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 (SImode
, dest1
, addr
));
937 emit_insn (gen_rtx_SET (VOIDmode
, dest0
,
938 adjust_address (src
, SImode
, 0)));
939 emit_insn (gen_rtx_SET (SImode
, dest1
,
940 plus_constant (SImode
, dest1
,
943 new_mem
= gen_rtx_MEM (SImode
, dest1
);
944 MEM_COPY_ATTRIBUTES (new_mem
, src
);
946 emit_insn (gen_rtx_SET (VOIDmode
, dest1
, new_mem
));
948 else if (src_code
== CONST_INT
|| src_code
== CONST_DOUBLE
)
951 split_double (src
, &words
[0], &words
[1]);
952 emit_insn (gen_rtx_SET (VOIDmode
,
953 operand_subword (dest
, 0, TRUE
, mode
),
956 emit_insn (gen_rtx_SET (VOIDmode
,
957 operand_subword (dest
, 1, TRUE
, mode
),
961 else if (src_code
== REG
&& dest_code
== MEM
)
963 rtx addr
= XEXP (dest
, 0);
967 gcc_assert (GET_CODE (addr
) == REG
);
969 src0
= operand_subword (src
, 0, TRUE
, mode
);
970 src1
= operand_subword (src
, 1, TRUE
, mode
);
972 emit_move_insn (adjust_address (dest
, SImode
, 0), src0
);
974 if (REGNO (addr
) == STACK_POINTER_REGNUM
975 || REGNO (addr
) == FRAME_POINTER_REGNUM
)
976 emit_insn (gen_rtx_SET (VOIDmode
,
977 adjust_address (dest
, SImode
, UNITS_PER_WORD
),
982 rtx scratch_reg_r0
= gen_rtx_REG (SImode
, 0);
984 /* We need a scratch register to hold the value of 'address + 4'.
985 We use r0 for this purpose. It is used for example for long
986 jumps and is already marked to not be used by normal register
988 emit_insn (gen_movsi_internal (scratch_reg_r0
, addr
));
989 emit_insn (gen_addsi_small_int (scratch_reg_r0
, scratch_reg_r0
,
990 GEN_INT (UNITS_PER_WORD
)));
991 new_mem
= gen_rtx_MEM (SImode
, scratch_reg_r0
);
992 MEM_COPY_ATTRIBUTES (new_mem
, dest
);
993 emit_move_insn (new_mem
, src1
);
994 emit_insn (gen_blockage ());
998 /* This should have been prevented by the constraints on movdi_insn. */
1007 /* Implement TARGET_FRAME_POINTER_REQUIRED. */
1010 fr30_frame_pointer_required (void)
1012 return (flag_omit_frame_pointer
== 0 || crtl
->args
.pretend_args_size
> 0);
1016 /*{{{ Trampoline Output Routines */
1018 /* Implement TARGET_ASM_TRAMPOLINE_TEMPLATE.
1019 On the FR30, the trampoline is:
1027 The no-ops are to guarantee that the static chain and final
1028 target are 32 bit aligned within the trampoline. That allows us to
1029 initialize those locations with simple SImode stores. The alternative
1030 would be to use HImode stores. */
1033 fr30_asm_trampoline_template (FILE *f
)
1035 fprintf (f
, "\tnop\n");
1036 fprintf (f
, "\tldi:32\t#0, %s\n", reg_names
[STATIC_CHAIN_REGNUM
]);
1037 fprintf (f
, "\tnop\n");
1038 fprintf (f
, "\tldi:32\t#0, %s\n", reg_names
[COMPILER_SCRATCH_REGISTER
]);
1039 fprintf (f
, "\tjmp\t@%s\n", reg_names
[COMPILER_SCRATCH_REGISTER
]);
1042 /* Implement TARGET_TRAMPOLINE_INIT. */
1045 fr30_trampoline_init (rtx m_tramp
, tree fndecl
, rtx chain_value
)
1047 rtx fnaddr
= XEXP (DECL_RTL (fndecl
), 0);
1050 emit_block_move (m_tramp
, assemble_trampoline_template (),
1051 GEN_INT (TRAMPOLINE_SIZE
), BLOCK_OP_NORMAL
);
1053 mem
= adjust_address (m_tramp
, SImode
, 4);
1054 emit_move_insn (mem
, chain_value
);
1055 mem
= adjust_address (m_tramp
, SImode
, 12);
1056 emit_move_insn (mem
, fnaddr
);
1060 /* Local Variables: */
1061 /* folded-file: t */