1 /* FR30 specific functions.
2 Copyright (C) 1998-2018 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 struct gcc_target targetm
= TARGET_INITIALIZER
;
201 /* Worker function for TARGET_CAN_ELIMINATE. */
204 fr30_can_eliminate (const int from ATTRIBUTE_UNUSED
, const int to
)
206 return (to
== FRAME_POINTER_REGNUM
|| ! frame_pointer_needed
);
209 /* Returns the number of bytes offset between FROM_REG and TO_REG
210 for the current function. As a side effect it fills in the
211 current_frame_info structure, if the data is available. */
213 fr30_compute_frame_size (int from_reg
, int to_reg
)
216 unsigned int return_value
;
217 unsigned int var_size
;
218 unsigned int args_size
;
219 unsigned int pretend_size
;
220 unsigned int reg_size
;
223 var_size
= WORD_ALIGN (get_frame_size ());
224 args_size
= WORD_ALIGN (crtl
->outgoing_args_size
);
225 pretend_size
= crtl
->args
.pretend_args_size
;
230 /* Calculate space needed for registers. */
231 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
233 if (MUST_SAVE_REGISTER (regno
))
235 reg_size
+= UNITS_PER_WORD
;
240 current_frame_info
.save_fp
= MUST_SAVE_FRAME_POINTER
;
241 current_frame_info
.save_rp
= MUST_SAVE_RETURN_POINTER
;
243 reg_size
+= (current_frame_info
.save_fp
+ current_frame_info
.save_rp
)
246 /* Save computed information. */
247 current_frame_info
.pretend_size
= pretend_size
;
248 current_frame_info
.var_size
= var_size
;
249 current_frame_info
.args_size
= args_size
;
250 current_frame_info
.reg_size
= reg_size
;
251 current_frame_info
.frame_size
= args_size
+ var_size
;
252 current_frame_info
.total_size
= args_size
+ var_size
+ reg_size
+ pretend_size
;
253 current_frame_info
.gmask
= gmask
;
254 current_frame_info
.initialised
= reload_completed
;
256 /* Calculate the required distance. */
259 if (to_reg
== STACK_POINTER_REGNUM
)
260 return_value
+= args_size
+ var_size
;
262 if (from_reg
== ARG_POINTER_REGNUM
)
263 return_value
+= reg_size
;
268 /* Called after register allocation to add any instructions needed for the
269 prologue. Using a prologue insn is favored compared to putting all of the
270 instructions in output_function_prologue(), since it allows the scheduler
271 to intermix instructions with the saves of the caller saved registers. In
272 some cases, it might be necessary to emit a barrier instruction as the last
273 insn to prevent such scheduling. */
276 fr30_expand_prologue (void)
281 if (! current_frame_info
.initialised
)
282 fr30_compute_frame_size (0, 0);
284 /* This cases shouldn't happen. Catch it now. */
285 gcc_assert (current_frame_info
.total_size
|| !current_frame_info
.gmask
);
287 /* Allocate space for register arguments if this is a variadic function. */
288 if (current_frame_info
.pretend_size
)
290 int regs_to_save
= current_frame_info
.pretend_size
/ UNITS_PER_WORD
;
292 /* Push argument registers into the pretend arg area. */
293 for (regno
= FIRST_ARG_REGNUM
+ FR30_NUM_ARG_REGS
; regno
--, regs_to_save
--;)
295 insn
= emit_insn (gen_movsi_push (gen_rtx_REG (Pmode
, regno
)));
296 RTX_FRAME_RELATED_P (insn
) = 1;
300 if (current_frame_info
.gmask
)
302 /* Save any needed call-saved regs. */
303 for (regno
= STACK_POINTER_REGNUM
; regno
--;)
305 if ((current_frame_info
.gmask
& (1 << regno
)) != 0)
307 insn
= emit_insn (gen_movsi_push (gen_rtx_REG (Pmode
, regno
)));
308 RTX_FRAME_RELATED_P (insn
) = 1;
313 /* Save return address if necessary. */
314 if (current_frame_info
.save_rp
)
316 insn
= emit_insn (gen_movsi_push (gen_rtx_REG (Pmode
,
317 RETURN_POINTER_REGNUM
)));
318 RTX_FRAME_RELATED_P (insn
) = 1;
321 /* Save old frame pointer and create new one, if necessary. */
322 if (current_frame_info
.save_fp
)
324 if (current_frame_info
.frame_size
< ((1 << 10) - UNITS_PER_WORD
))
326 int enter_size
= current_frame_info
.frame_size
+ UNITS_PER_WORD
;
329 insn
= emit_insn (gen_enter_func (GEN_INT (enter_size
)));
330 RTX_FRAME_RELATED_P (insn
) = 1;
332 pattern
= PATTERN (insn
);
334 /* Also mark all 3 subexpressions as RTX_FRAME_RELATED_P. */
335 if (GET_CODE (pattern
) == PARALLEL
)
338 for (x
= XVECLEN (pattern
, 0); x
--;)
340 rtx part
= XVECEXP (pattern
, 0, x
);
342 /* One of the insns in the ENTER pattern updates the
343 frame pointer. If we do not actually need the frame
344 pointer in this function then this is a side effect
345 rather than a desired effect, so we do not mark that
346 insn as being related to the frame set up. Doing this
347 allows us to compile the crash66.C test file in the
349 if (! frame_pointer_needed
350 && GET_CODE (part
) == SET
351 && SET_DEST (part
) == hard_frame_pointer_rtx
)
352 RTX_FRAME_RELATED_P (part
) = 0;
354 RTX_FRAME_RELATED_P (part
) = 1;
360 insn
= emit_insn (gen_movsi_push (frame_pointer_rtx
));
361 RTX_FRAME_RELATED_P (insn
) = 1;
363 if (frame_pointer_needed
)
365 insn
= emit_insn (gen_movsi (frame_pointer_rtx
, stack_pointer_rtx
));
366 RTX_FRAME_RELATED_P (insn
) = 1;
371 /* Allocate the stack frame. */
372 if (current_frame_info
.frame_size
== 0)
373 ; /* Nothing to do. */
374 else if (current_frame_info
.save_fp
375 && current_frame_info
.frame_size
< ((1 << 10) - UNITS_PER_WORD
))
376 ; /* Nothing to do. */
377 else if (current_frame_info
.frame_size
<= 512)
379 insn
= emit_insn (gen_add_to_stack
380 (GEN_INT (- (signed) current_frame_info
.frame_size
)));
381 RTX_FRAME_RELATED_P (insn
) = 1;
385 rtx tmp
= gen_rtx_REG (Pmode
, PROLOGUE_TMP_REGNUM
);
386 insn
= emit_insn (gen_movsi (tmp
, GEN_INT (current_frame_info
.frame_size
)));
387 RTX_FRAME_RELATED_P (insn
) = 1;
388 insn
= emit_insn (gen_subsi3 (stack_pointer_rtx
, stack_pointer_rtx
, tmp
));
389 RTX_FRAME_RELATED_P (insn
) = 1;
393 emit_insn (gen_blockage ());
396 /* Called after register allocation to add any instructions needed for the
397 epilogue. Using an epilogue insn is favored compared to putting all of the
398 instructions in output_function_epilogue(), since it allows the scheduler
399 to intermix instructions with the restores of the caller saved registers.
400 In some cases, it might be necessary to emit a barrier instruction as the
401 first insn to prevent such scheduling. */
403 fr30_expand_epilogue (void)
407 /* Perform the inversion operations of the prologue. */
408 gcc_assert (current_frame_info
.initialised
);
410 /* Pop local variables and arguments off the stack.
411 If frame_pointer_needed is TRUE then the frame pointer register
412 has actually been used as a frame pointer, and we can recover
413 the stack pointer from it, otherwise we must unwind the stack
415 if (current_frame_info
.frame_size
> 0)
417 if (current_frame_info
.save_fp
&& frame_pointer_needed
)
419 emit_insn (gen_leave_func ());
420 current_frame_info
.save_fp
= 0;
422 else if (current_frame_info
.frame_size
<= 508)
423 emit_insn (gen_add_to_stack
424 (GEN_INT (current_frame_info
.frame_size
)));
427 rtx tmp
= gen_rtx_REG (Pmode
, PROLOGUE_TMP_REGNUM
);
428 emit_insn (gen_movsi (tmp
, GEN_INT (current_frame_info
.frame_size
)));
429 emit_insn (gen_addsi3 (stack_pointer_rtx
, stack_pointer_rtx
, tmp
));
433 if (current_frame_info
.save_fp
)
434 emit_insn (gen_movsi_pop (frame_pointer_rtx
));
436 /* Pop all the registers that were pushed. */
437 if (current_frame_info
.save_rp
)
438 emit_insn (gen_movsi_pop (gen_rtx_REG (Pmode
, RETURN_POINTER_REGNUM
)));
440 for (regno
= 0; regno
< STACK_POINTER_REGNUM
; regno
++)
441 if (current_frame_info
.gmask
& (1 << regno
))
442 emit_insn (gen_movsi_pop (gen_rtx_REG (Pmode
, regno
)));
444 if (current_frame_info
.pretend_size
)
445 emit_insn (gen_add_to_stack (GEN_INT (current_frame_info
.pretend_size
)));
447 /* Reset state info for each function. */
448 current_frame_info
= zero_frame_info
;
450 emit_jump_insn (gen_return_from_func ());
453 /* Do any needed setup for a variadic function. We must create a register
454 parameter block, and then copy any anonymous arguments, plus the last
455 named argument, from registers into memory. * copying actually done in
456 fr30_expand_prologue().
458 ARG_REGS_USED_SO_FAR has *not* been updated for the last named argument
459 which has type TYPE and mode MODE, and we rely on this fact. */
461 fr30_setup_incoming_varargs (cumulative_args_t arg_regs_used_so_far_v
,
463 tree type ATTRIBUTE_UNUSED
,
465 int second_time ATTRIBUTE_UNUSED
)
467 CUMULATIVE_ARGS
*arg_regs_used_so_far
468 = get_cumulative_args (arg_regs_used_so_far_v
);
471 /* All BLKmode values are passed by reference. */
472 gcc_assert (mode
!= BLKmode
);
474 /* ??? This run-time test as well as the code inside the if
475 statement is probably unnecessary. */
476 if (targetm
.calls
.strict_argument_naming (arg_regs_used_so_far_v
))
477 /* If TARGET_STRICT_ARGUMENT_NAMING returns true, then the last named
478 arg must not be treated as an anonymous arg. */
479 /* ??? This is a pointer increment, which makes no sense. */
480 arg_regs_used_so_far
+= fr30_num_arg_regs (mode
, type
);
482 size
= FR30_NUM_ARG_REGS
- (* arg_regs_used_so_far
);
487 * pretend_size
= (size
* UNITS_PER_WORD
);
491 /*{{{ Printing operands */
493 /* Print a memory address as an operand to reference that memory location. */
496 fr30_print_operand_address (FILE *stream
, rtx address
)
498 switch (GET_CODE (address
))
501 output_addr_const (stream
, address
);
505 fprintf (stderr
, "code = %x\n", GET_CODE (address
));
507 output_operand_lossage ("fr30_print_operand_address: unhandled address");
512 /* Print an operand. */
515 fr30_print_operand (FILE *file
, rtx x
, int code
)
522 /* Output a :D if this instruction is delayed. */
523 if (dbr_sequence_length () != 0)
528 /* Compute the register name of the second register in a hi/lo
530 if (GET_CODE (x
) != REG
)
531 output_operand_lossage ("fr30_print_operand: unrecognized %%p code");
533 fprintf (file
, "r%d", REGNO (x
) + 1);
537 /* Convert GCC's comparison operators into FR30 comparison codes. */
538 switch (GET_CODE (x
))
540 case EQ
: fprintf (file
, "eq"); break;
541 case NE
: fprintf (file
, "ne"); break;
542 case LT
: fprintf (file
, "lt"); break;
543 case LE
: fprintf (file
, "le"); break;
544 case GT
: fprintf (file
, "gt"); break;
545 case GE
: fprintf (file
, "ge"); break;
546 case LTU
: fprintf (file
, "c"); break;
547 case LEU
: fprintf (file
, "ls"); break;
548 case GTU
: fprintf (file
, "hi"); break;
549 case GEU
: fprintf (file
, "nc"); break;
551 output_operand_lossage ("fr30_print_operand: unrecognized %%b code");
557 /* Convert GCC's comparison operators into the complimentary FR30
559 switch (GET_CODE (x
))
561 case EQ
: fprintf (file
, "ne"); break;
562 case NE
: fprintf (file
, "eq"); break;
563 case LT
: fprintf (file
, "ge"); break;
564 case LE
: fprintf (file
, "gt"); break;
565 case GT
: fprintf (file
, "le"); break;
566 case GE
: fprintf (file
, "lt"); break;
567 case LTU
: fprintf (file
, "nc"); break;
568 case LEU
: fprintf (file
, "hi"); break;
569 case GTU
: fprintf (file
, "ls"); break;
570 case GEU
: fprintf (file
, "c"); break;
572 output_operand_lossage ("fr30_print_operand: unrecognized %%B code");
578 /* Print a signed byte value as an unsigned value. */
579 if (GET_CODE (x
) != CONST_INT
)
580 output_operand_lossage ("fr30_print_operand: invalid operand to %%A code");
589 fprintf (file
, HOST_WIDE_INT_PRINT_DEC
, val
);
594 if (GET_CODE (x
) != CONST_INT
597 output_operand_lossage ("fr30_print_operand: invalid %%x code");
599 fprintf (file
, HOST_WIDE_INT_PRINT_DEC
, INTVAL (x
) - 16);
603 if (GET_CODE (x
) != CONST_DOUBLE
)
604 output_operand_lossage ("fr30_print_operand: invalid %%F code");
609 real_to_decimal (str
, CONST_DOUBLE_REAL_VALUE (x
),
620 fprintf (stderr
, "unknown code = %x\n", code
);
621 output_operand_lossage ("fr30_print_operand: unknown code");
625 switch (GET_CODE (x
))
628 fputs (reg_names
[REGNO (x
)], file
);
634 switch (GET_CODE (x0
))
637 gcc_assert ((unsigned) REGNO (x0
) < ARRAY_SIZE (reg_names
));
638 fprintf (file
, "@%s", reg_names
[REGNO (x0
)]);
642 if (GET_CODE (XEXP (x0
, 0)) != REG
643 || REGNO (XEXP (x0
, 0)) < FRAME_POINTER_REGNUM
644 || REGNO (XEXP (x0
, 0)) > STACK_POINTER_REGNUM
645 || GET_CODE (XEXP (x0
, 1)) != CONST_INT
)
647 fprintf (stderr
, "bad INDEXed address:");
649 output_operand_lossage ("fr30_print_operand: unhandled MEM");
651 else if (REGNO (XEXP (x0
, 0)) == FRAME_POINTER_REGNUM
)
653 HOST_WIDE_INT val
= INTVAL (XEXP (x0
, 1));
654 if (val
< -(1 << 9) || val
> ((1 << 9) - 4))
656 fprintf (stderr
, "frame INDEX out of range:");
658 output_operand_lossage ("fr30_print_operand: unhandled MEM");
660 fprintf (file
, "@(r14, #" HOST_WIDE_INT_PRINT_DEC
")", val
);
664 HOST_WIDE_INT val
= INTVAL (XEXP (x0
, 1));
665 if (val
< 0 || val
> ((1 << 6) - 4))
667 fprintf (stderr
, "stack INDEX out of range:");
669 output_operand_lossage ("fr30_print_operand: unhandled MEM");
671 fprintf (file
, "@(r15, #" HOST_WIDE_INT_PRINT_DEC
")", val
);
676 output_address (VOIDmode
, x0
);
680 fprintf (stderr
, "bad MEM code = %x\n", GET_CODE (x0
));
682 output_operand_lossage ("fr30_print_operand: unhandled MEM");
688 /* We handle SFmode constants here as output_addr_const doesn't. */
689 if (GET_MODE (x
) == SFmode
)
693 REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (x
), l
);
694 fprintf (file
, "0x%08lx", l
);
699 /* Let output_addr_const deal with it. */
701 output_addr_const (file
, x
);
710 /* Implements TARGET_FUNCTION_VALUE. */
713 fr30_function_value (const_tree valtype
,
714 const_tree fntype_or_decli ATTRIBUTE_UNUSED
,
715 bool outgoing ATTRIBUTE_UNUSED
)
717 return gen_rtx_REG (TYPE_MODE (valtype
), RETURN_VALUE_REGNUM
);
720 /* Implements TARGET_LIBCALL_VALUE. */
723 fr30_libcall_value (machine_mode mode
,
724 const_rtx fun ATTRIBUTE_UNUSED
)
726 return gen_rtx_REG (mode
, RETURN_VALUE_REGNUM
);
729 /* Implements TARGET_FUNCTION_VALUE_REGNO_P. */
732 fr30_function_value_regno_p (const unsigned int regno
)
734 return (regno
== RETURN_VALUE_REGNUM
);
737 /*{{{ Function arguments */
739 /* Return true if we should pass an argument on the stack rather than
743 fr30_must_pass_in_stack (machine_mode mode
, const_tree type
)
749 return AGGREGATE_TYPE_P (type
);
752 /* Compute the number of word sized registers needed to hold a
753 function argument of mode INT_MODE and tree type TYPE. */
755 fr30_num_arg_regs (machine_mode mode
, const_tree type
)
759 if (targetm
.calls
.must_pass_in_stack (mode
, type
))
762 if (type
&& mode
== BLKmode
)
763 size
= int_size_in_bytes (type
);
765 size
= GET_MODE_SIZE (mode
);
767 return (size
+ UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
770 /* Returns the number of bytes in which *part* of a parameter of machine
771 mode MODE and tree type TYPE (which may be NULL if the type is not known).
772 If the argument fits entirely in the argument registers, or entirely on
773 the stack, then 0 is returned.
774 CUM is the number of argument registers already used by earlier
775 parameters to the function. */
778 fr30_arg_partial_bytes (cumulative_args_t cum_v
, machine_mode mode
,
779 tree type
, bool named
)
781 CUMULATIVE_ARGS
*cum
= get_cumulative_args (cum_v
);
783 /* Unnamed arguments, i.e. those that are prototyped as ...
784 are always passed on the stack.
785 Also check here to see if all the argument registers are full. */
786 if (named
== 0 || *cum
>= FR30_NUM_ARG_REGS
)
789 /* Work out how many argument registers would be needed if this
790 parameter were to be passed entirely in registers. If there
791 are sufficient argument registers available (or if no registers
792 are needed because the parameter must be passed on the stack)
793 then return zero, as this parameter does not require partial
794 register, partial stack stack space. */
795 if (*cum
+ fr30_num_arg_regs (mode
, type
) <= FR30_NUM_ARG_REGS
)
798 return (FR30_NUM_ARG_REGS
- *cum
) * UNITS_PER_WORD
;
802 fr30_function_arg (cumulative_args_t cum_v
, machine_mode mode
,
803 const_tree type
, bool named
)
805 CUMULATIVE_ARGS
*cum
= get_cumulative_args (cum_v
);
808 || fr30_must_pass_in_stack (mode
, type
)
809 || *cum
>= FR30_NUM_ARG_REGS
)
812 return gen_rtx_REG (mode
, *cum
+ FIRST_ARG_REGNUM
);
815 /* A C statement (sans semicolon) to update the summarizer variable CUM to
816 advance past an argument in the argument list. The values MODE, TYPE and
817 NAMED describe that argument. Once this is done, the variable CUM is
818 suitable for analyzing the *following* argument with `FUNCTION_ARG', etc.
820 This macro need not do anything if the argument in question was passed on
821 the stack. The compiler knows how to track the amount of stack space used
822 for arguments without any special help. */
824 fr30_function_arg_advance (cumulative_args_t cum
, machine_mode mode
,
825 const_tree type
, bool named
)
827 *get_cumulative_args (cum
) += named
* fr30_num_arg_regs (mode
, type
);
831 /*{{{ Operand predicates */
834 #define Mmode machine_mode
837 /* Returns true iff all the registers in the operands array
838 are in descending or ascending order. */
840 fr30_check_multiple_regs (rtx
*operands
, int num_operands
, int descending
)
844 unsigned int prev_regno
= 0;
846 while (num_operands
--)
848 if (GET_CODE (operands
[num_operands
]) != REG
)
851 if (REGNO (operands
[num_operands
]) < prev_regno
)
854 prev_regno
= REGNO (operands
[num_operands
]);
859 unsigned int prev_regno
= CONDITION_CODE_REGNUM
;
861 while (num_operands
--)
863 if (GET_CODE (operands
[num_operands
]) != REG
)
866 if (REGNO (operands
[num_operands
]) > prev_regno
)
869 prev_regno
= REGNO (operands
[num_operands
]);
877 fr30_const_double_is_zero (rtx operand
)
879 if (operand
== NULL
|| GET_CODE (operand
) != CONST_DOUBLE
)
882 return real_equal (CONST_DOUBLE_REAL_VALUE (operand
), &dconst0
);
886 /*{{{ Instruction Output Routines */
888 /* Output a double word move.
889 It must be REG<-REG, REG<-MEM, MEM<-REG or REG<-CONST.
890 On the FR30 we are constrained by the fact that it does not
891 support offsetable addresses, and so we have to load the
892 address of the secnd word into the second destination register
893 before we can use it. */
896 fr30_move_double (rtx
* operands
)
898 rtx src
= operands
[1];
899 rtx dest
= operands
[0];
900 enum rtx_code src_code
= GET_CODE (src
);
901 enum rtx_code dest_code
= GET_CODE (dest
);
902 machine_mode mode
= GET_MODE (dest
);
907 if (dest_code
== REG
)
911 int reverse
= (REGNO (dest
) == REGNO (src
) + 1);
913 /* We normally copy the low-numbered register first. However, if
914 the first register of operand 0 is the same as the second register
915 of operand 1, we must copy in the opposite order. */
916 emit_insn (gen_rtx_SET (operand_subword (dest
, reverse
, TRUE
, mode
),
917 operand_subword (src
, reverse
, TRUE
, mode
)));
920 (gen_rtx_SET (operand_subword (dest
, !reverse
, TRUE
, mode
),
921 operand_subword (src
, !reverse
, TRUE
, mode
)));
923 else if (src_code
== MEM
)
925 rtx addr
= XEXP (src
, 0);
926 rtx dest0
= operand_subword (dest
, 0, TRUE
, mode
);
927 rtx dest1
= operand_subword (dest
, 1, TRUE
, mode
);
930 gcc_assert (GET_CODE (addr
) == REG
);
932 /* Copy the address before clobbering it. See PR 34174. */
933 emit_insn (gen_rtx_SET (dest1
, addr
));
934 emit_insn (gen_rtx_SET (dest0
, adjust_address (src
, SImode
, 0)));
935 emit_insn (gen_rtx_SET (dest1
, plus_constant (SImode
, dest1
,
938 new_mem
= gen_rtx_MEM (SImode
, dest1
);
939 MEM_COPY_ATTRIBUTES (new_mem
, src
);
941 emit_insn (gen_rtx_SET (dest1
, new_mem
));
943 else if (src_code
== CONST_INT
|| src_code
== CONST_DOUBLE
)
946 split_double (src
, &words
[0], &words
[1]);
947 emit_insn (gen_rtx_SET (operand_subword (dest
, 0, TRUE
, mode
),
950 emit_insn (gen_rtx_SET (operand_subword (dest
, 1, TRUE
, mode
),
954 else if (src_code
== REG
&& dest_code
== MEM
)
956 rtx addr
= XEXP (dest
, 0);
960 gcc_assert (GET_CODE (addr
) == REG
);
962 src0
= operand_subword (src
, 0, TRUE
, mode
);
963 src1
= operand_subword (src
, 1, TRUE
, mode
);
965 emit_move_insn (adjust_address (dest
, SImode
, 0), src0
);
967 if (REGNO (addr
) == STACK_POINTER_REGNUM
968 || REGNO (addr
) == FRAME_POINTER_REGNUM
)
969 emit_insn (gen_rtx_SET (adjust_address (dest
, SImode
, UNITS_PER_WORD
),
974 rtx scratch_reg_r0
= gen_rtx_REG (SImode
, 0);
976 /* We need a scratch register to hold the value of 'address + 4'.
977 We use r0 for this purpose. It is used for example for long
978 jumps and is already marked to not be used by normal register
980 emit_insn (gen_movsi_internal (scratch_reg_r0
, addr
));
981 emit_insn (gen_addsi_small_int (scratch_reg_r0
, scratch_reg_r0
,
982 GEN_INT (UNITS_PER_WORD
)));
983 new_mem
= gen_rtx_MEM (SImode
, scratch_reg_r0
);
984 MEM_COPY_ATTRIBUTES (new_mem
, dest
);
985 emit_move_insn (new_mem
, src1
);
986 emit_insn (gen_blockage ());
990 /* This should have been prevented by the constraints on movdi_insn. */
999 /* Implement TARGET_FRAME_POINTER_REQUIRED. */
1002 fr30_frame_pointer_required (void)
1004 return (flag_omit_frame_pointer
== 0 || crtl
->args
.pretend_args_size
> 0);
1008 /*{{{ Trampoline Output Routines */
1010 /* Implement TARGET_ASM_TRAMPOLINE_TEMPLATE.
1011 On the FR30, the trampoline is:
1019 The no-ops are to guarantee that the static chain and final
1020 target are 32 bit aligned within the trampoline. That allows us to
1021 initialize those locations with simple SImode stores. The alternative
1022 would be to use HImode stores. */
1025 fr30_asm_trampoline_template (FILE *f
)
1027 fprintf (f
, "\tnop\n");
1028 fprintf (f
, "\tldi:32\t#0, %s\n", reg_names
[STATIC_CHAIN_REGNUM
]);
1029 fprintf (f
, "\tnop\n");
1030 fprintf (f
, "\tldi:32\t#0, %s\n", reg_names
[COMPILER_SCRATCH_REGISTER
]);
1031 fprintf (f
, "\tjmp\t@%s\n", reg_names
[COMPILER_SCRATCH_REGISTER
]);
1034 /* Implement TARGET_TRAMPOLINE_INIT. */
1037 fr30_trampoline_init (rtx m_tramp
, tree fndecl
, rtx chain_value
)
1039 rtx fnaddr
= XEXP (DECL_RTL (fndecl
), 0);
1042 emit_block_move (m_tramp
, assemble_trampoline_template (),
1043 GEN_INT (TRAMPOLINE_SIZE
), BLOCK_OP_NORMAL
);
1045 mem
= adjust_address (m_tramp
, SImode
, 4);
1046 emit_move_insn (mem
, chain_value
);
1047 mem
= adjust_address (m_tramp
, SImode
, 12);
1048 emit_move_insn (mem
, fnaddr
);
1052 /* Local Variables: */
1053 /* folded-file: t */