1 /* FR30 specific functions.
2 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004
3 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 2, 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 COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
27 #include "coretypes.h"
31 #include "hard-reg-set.h"
33 #include "insn-config.h"
34 #include "conditions.h"
35 #include "insn-attr.h"
47 #include "target-def.h"
50 /*{{{ Function Prologues & Epilogues */
52 /* Define the information needed to generate branch and scc insns. This is
53 stored from the compare operation. */
55 struct rtx_def
* fr30_compare_op0
;
56 struct rtx_def
* fr30_compare_op1
;
58 /* The FR30 stack looks like this:
60 Before call After call
62 +-----------------------+ +-----------------------+ high
64 | local variables, | | local variables, |
65 | reg save area, etc. | | reg save area, etc. |
67 +-----------------------+ +-----------------------+
69 | args to the func that | | args to this func. |
70 | is being called that | | |
71 SP ->| do not fit in regs | | |
72 +-----------------------+ +-----------------------+
73 | args that used to be | \
74 | in regs; only created | | pretend_size
75 AP-> | for vararg funcs | /
76 +-----------------------+
78 | register save area | |
80 +-----------------------+ | reg_size
82 +-----------------------+ |
83 FP ->| previous frame ptr | /
84 +-----------------------+
86 | local variables | | var_size
88 +-----------------------+
90 low | room for args to | |
91 memory | other funcs called | | args_size
94 +-----------------------+
96 Note, AP is a fake hard register. It will be eliminated in favor of
97 SP or FP as appropriate.
99 Note, Some or all of the stack sections above may be omitted if they
102 /* Structure to be filled in by fr30_compute_frame_size() with register
103 save masks, and offsets for the current function. */
104 struct fr30_frame_info
106 unsigned int total_size
; /* # Bytes that the entire frame takes up. */
107 unsigned int pretend_size
; /* # Bytes we push and pretend caller did. */
108 unsigned int args_size
; /* # Bytes that outgoing arguments take up. */
109 unsigned int reg_size
; /* # Bytes needed to store regs. */
110 unsigned int var_size
; /* # Bytes that variables take up. */
111 unsigned int frame_size
; /* # Bytes in current frame. */
112 unsigned int gmask
; /* Mask of saved registers. */
113 unsigned int save_fp
; /* Nonzero if frame pointer must be saved. */
114 unsigned int save_rp
; /* Nonzero if return pointer must be saved. */
115 int initialised
; /* Nonzero if frame size already calculated. */
118 /* Current frame information calculated by fr30_compute_frame_size(). */
119 static struct fr30_frame_info current_frame_info
;
121 /* Zero structure to initialize current_frame_info. */
122 static struct fr30_frame_info zero_frame_info
;
124 static void fr30_setup_incoming_varargs (CUMULATIVE_ARGS
*, enum machine_mode
,
126 static rtx
fr30_pass_by_reference (tree
, tree
);
127 static rtx
fr30_pass_by_value (tree
, tree
);
129 #define FRAME_POINTER_MASK (1 << (FRAME_POINTER_REGNUM))
130 #define RETURN_POINTER_MASK (1 << (RETURN_POINTER_REGNUM))
132 /* Tell prologue and epilogue if register REGNO should be saved / restored.
133 The return address and frame pointer are treated separately.
134 Don't consider them here. */
135 #define MUST_SAVE_REGISTER(regno) \
136 ( (regno) != RETURN_POINTER_REGNUM \
137 && (regno) != FRAME_POINTER_REGNUM \
138 && regs_ever_live [regno] \
139 && ! call_used_regs [regno] )
141 #define MUST_SAVE_FRAME_POINTER (regs_ever_live [FRAME_POINTER_REGNUM] || frame_pointer_needed)
142 #define MUST_SAVE_RETURN_POINTER (regs_ever_live [RETURN_POINTER_REGNUM] || current_function_profile)
144 #if UNITS_PER_WORD == 4
145 #define WORD_ALIGN(SIZE) (((SIZE) + 3) & ~3)
148 /* Initialize the GCC target structure. */
149 #undef TARGET_ASM_ALIGNED_HI_OP
150 #define TARGET_ASM_ALIGNED_HI_OP "\t.hword\t"
151 #undef TARGET_ASM_ALIGNED_SI_OP
152 #define TARGET_ASM_ALIGNED_SI_OP "\t.word\t"
154 #undef TARGET_PROMOTE_PROTOTYPES
155 #define TARGET_PROMOTE_PROTOTYPES hook_bool_tree_true
157 #undef TARGET_SETUP_INCOMING_VARARGS
158 #define TARGET_SETUP_INCOMING_VARARGS fr30_setup_incoming_varargs
160 struct gcc_target targetm
= TARGET_INITIALIZER
;
162 /* Returns the number of bytes offset between FROM_REG and TO_REG
163 for the current function. As a side effect it fills in the
164 current_frame_info structure, if the data is available. */
166 fr30_compute_frame_size (int from_reg
, int to_reg
)
169 unsigned int return_value
;
170 unsigned int var_size
;
171 unsigned int args_size
;
172 unsigned int pretend_size
;
173 unsigned int reg_size
;
176 var_size
= WORD_ALIGN (get_frame_size ());
177 args_size
= WORD_ALIGN (current_function_outgoing_args_size
);
178 pretend_size
= current_function_pretend_args_size
;
183 /* Calculate space needed for registers. */
184 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
186 if (MUST_SAVE_REGISTER (regno
))
188 reg_size
+= UNITS_PER_WORD
;
193 current_frame_info
.save_fp
= MUST_SAVE_FRAME_POINTER
;
194 current_frame_info
.save_rp
= MUST_SAVE_RETURN_POINTER
;
196 reg_size
+= (current_frame_info
.save_fp
+ current_frame_info
.save_rp
)
199 /* Save computed information. */
200 current_frame_info
.pretend_size
= pretend_size
;
201 current_frame_info
.var_size
= var_size
;
202 current_frame_info
.args_size
= args_size
;
203 current_frame_info
.reg_size
= reg_size
;
204 current_frame_info
.frame_size
= args_size
+ var_size
;
205 current_frame_info
.total_size
= args_size
+ var_size
+ reg_size
+ pretend_size
;
206 current_frame_info
.gmask
= gmask
;
207 current_frame_info
.initialised
= reload_completed
;
209 /* Calculate the required distance. */
212 if (to_reg
== STACK_POINTER_REGNUM
)
213 return_value
+= args_size
+ var_size
;
215 if (from_reg
== ARG_POINTER_REGNUM
)
216 return_value
+= reg_size
;
221 /* Called after register allocation to add any instructions needed for the
222 prologue. Using a prologue insn is favored compared to putting all of the
223 instructions in output_function_prologue(), since it allows the scheduler
224 to intermix instructions with the saves of the caller saved registers. In
225 some cases, it might be necessary to emit a barrier instruction as the last
226 insn to prevent such scheduling. */
229 fr30_expand_prologue (void)
234 if (! current_frame_info
.initialised
)
235 fr30_compute_frame_size (0, 0);
237 /* This cases shouldn't happen. Catch it now. */
238 if (current_frame_info
.total_size
== 0
239 && current_frame_info
.gmask
)
242 /* Allocate space for register arguments if this is a variadic function. */
243 if (current_frame_info
.pretend_size
)
245 int regs_to_save
= current_frame_info
.pretend_size
/ UNITS_PER_WORD
;
247 /* Push argument registers into the pretend arg area. */
248 for (regno
= FIRST_ARG_REGNUM
+ FR30_NUM_ARG_REGS
; regno
--, regs_to_save
--;)
250 insn
= emit_insn (gen_movsi_push (gen_rtx_REG (Pmode
, regno
)));
251 RTX_FRAME_RELATED_P (insn
) = 1;
255 if (current_frame_info
.gmask
)
257 /* Save any needed call-saved regs. */
258 for (regno
= STACK_POINTER_REGNUM
; regno
--;)
260 if ((current_frame_info
.gmask
& (1 << regno
)) != 0)
262 insn
= emit_insn (gen_movsi_push (gen_rtx_REG (Pmode
, regno
)));
263 RTX_FRAME_RELATED_P (insn
) = 1;
268 /* Save return address if necessary. */
269 if (current_frame_info
.save_rp
)
271 insn
= emit_insn (gen_movsi_push (gen_rtx_REG (Pmode
,
272 RETURN_POINTER_REGNUM
)));
273 RTX_FRAME_RELATED_P (insn
) = 1;
276 /* Save old frame pointer and create new one, if necessary. */
277 if (current_frame_info
.save_fp
)
279 if (current_frame_info
.frame_size
< ((1 << 10) - UNITS_PER_WORD
))
281 int enter_size
= current_frame_info
.frame_size
+ UNITS_PER_WORD
;
284 insn
= emit_insn (gen_enter_func (GEN_INT (enter_size
)));
285 RTX_FRAME_RELATED_P (insn
) = 1;
287 pattern
= PATTERN (insn
);
289 /* Also mark all 3 subexpressions as RTX_FRAME_RELATED_P. */
290 if (GET_CODE (pattern
) == PARALLEL
)
293 for (x
= XVECLEN (pattern
, 0); x
--;)
295 rtx part
= XVECEXP (pattern
, 0, x
);
297 /* One of the insns in the ENTER pattern updates the
298 frame pointer. If we do not actually need the frame
299 pointer in this function then this is a side effect
300 rather than a desired effect, so we do not mark that
301 insn as being related to the frame set up. Doing this
302 allows us to compile the crash66.C test file in the
304 if (! frame_pointer_needed
305 && GET_CODE (part
) == SET
306 && REGNO (SET_DEST (part
)) == HARD_FRAME_POINTER_REGNUM
)
307 RTX_FRAME_RELATED_P (part
) = 0;
309 RTX_FRAME_RELATED_P (part
) = 1;
315 insn
= emit_insn (gen_movsi_push (frame_pointer_rtx
));
316 RTX_FRAME_RELATED_P (insn
) = 1;
318 if (frame_pointer_needed
)
320 insn
= emit_insn (gen_movsi (frame_pointer_rtx
, stack_pointer_rtx
));
321 RTX_FRAME_RELATED_P (insn
) = 1;
326 /* Allocate the stack frame. */
327 if (current_frame_info
.frame_size
== 0)
328 ; /* Nothing to do. */
329 else if (current_frame_info
.save_fp
330 && current_frame_info
.frame_size
< ((1 << 10) - UNITS_PER_WORD
))
331 ; /* Nothing to do. */
332 else if (current_frame_info
.frame_size
<= 512)
334 insn
= emit_insn (gen_add_to_stack (GEN_INT (- current_frame_info
.frame_size
)));
335 RTX_FRAME_RELATED_P (insn
) = 1;
339 rtx tmp
= gen_rtx_REG (Pmode
, PROLOGUE_TMP_REGNUM
);
340 insn
= emit_insn (gen_movsi (tmp
, GEN_INT (current_frame_info
.frame_size
)));
341 RTX_FRAME_RELATED_P (insn
) = 1;
342 insn
= emit_insn (gen_subsi3 (stack_pointer_rtx
, stack_pointer_rtx
, tmp
));
343 RTX_FRAME_RELATED_P (insn
) = 1;
346 if (current_function_profile
)
347 emit_insn (gen_blockage ());
350 /* Called after register allocation to add any instructions needed for the
351 epilogue. Using an epilogue insn is favored compared to putting all of the
352 instructions in output_function_epilogue(), since it allows the scheduler
353 to intermix instructions with the restores of the caller saved registers.
354 In some cases, it might be necessary to emit a barrier instruction as the
355 first insn to prevent such scheduling. */
357 fr30_expand_epilogue (void)
361 /* Perform the inversion operations of the prologue. */
362 if (! current_frame_info
.initialised
)
365 /* Pop local variables and arguments off the stack.
366 If frame_pointer_needed is TRUE then the frame pointer register
367 has actually been used as a frame pointer, and we can recover
368 the stack pointer from it, otherwise we must unwind the stack
370 if (current_frame_info
.frame_size
> 0)
372 if (current_frame_info
.save_fp
&& frame_pointer_needed
)
374 emit_insn (gen_leave_func ());
375 current_frame_info
.save_fp
= 0;
377 else if (current_frame_info
.frame_size
<= 508)
378 emit_insn (gen_add_to_stack
379 (GEN_INT (current_frame_info
.frame_size
)));
382 rtx tmp
= gen_rtx_REG (Pmode
, PROLOGUE_TMP_REGNUM
);
383 emit_insn (gen_movsi (tmp
, GEN_INT (current_frame_info
.frame_size
)));
384 emit_insn (gen_addsi3 (stack_pointer_rtx
, stack_pointer_rtx
, tmp
));
388 if (current_frame_info
.save_fp
)
389 emit_insn (gen_movsi_pop (frame_pointer_rtx
));
391 /* Pop all the registers that were pushed. */
392 if (current_frame_info
.save_rp
)
393 emit_insn (gen_movsi_pop (gen_rtx_REG (Pmode
, RETURN_POINTER_REGNUM
)));
395 for (regno
= 0; regno
< STACK_POINTER_REGNUM
; regno
++)
396 if (current_frame_info
.gmask
& (1 << regno
))
397 emit_insn (gen_movsi_pop (gen_rtx_REG (Pmode
, regno
)));
399 if (current_frame_info
.pretend_size
)
400 emit_insn (gen_add_to_stack (GEN_INT (current_frame_info
.pretend_size
)));
402 /* Reset state info for each function. */
403 current_frame_info
= zero_frame_info
;
405 emit_jump_insn (gen_return_from_func ());
408 /* Do any needed setup for a variadic function. We must create a register
409 parameter block, and then copy any anonymous arguments, plus the last
410 named argument, from registers into memory. * copying actually done in
411 fr30_expand_prologue().
413 ARG_REGS_USED_SO_FAR has *not* been updated for the last named argument
414 which has type TYPE and mode MODE, and we rely on this fact. */
416 fr30_setup_incoming_varargs (CUMULATIVE_ARGS
*arg_regs_used_so_far
,
417 enum machine_mode mode
,
418 tree type ATTRIBUTE_UNUSED
,
420 int second_time ATTRIBUTE_UNUSED
)
424 /* All BLKmode values are passed by reference. */
428 /* ??? This run-time test as well as the code inside the if
429 statement is probably unnecessary. */
430 if (targetm
.calls
.strict_argument_naming (arg_regs_used_so_far
))
431 /* If TARGET_STRICT_ARGUMENT_NAMING returns true, then the last named
432 arg must not be treated as an anonymous arg. */
433 arg_regs_used_so_far
+= fr30_num_arg_regs (mode
, type
);
435 size
= FR30_NUM_ARG_REGS
- (* arg_regs_used_so_far
);
440 * pretend_size
= (size
* UNITS_PER_WORD
);
444 /*{{{ Printing operands */
446 /* Print a memory address as an operand to reference that memory location. */
449 fr30_print_operand_address (FILE *stream
, rtx address
)
451 switch (GET_CODE (address
))
454 output_addr_const (stream
, address
);
458 fprintf (stderr
, "code = %x\n", GET_CODE (address
));
460 output_operand_lossage ("fr30_print_operand_address: unhandled address");
465 /* Print an operand. */
468 fr30_print_operand (FILE *file
, rtx x
, int code
)
475 /* Output a :D if this instruction is delayed. */
476 if (dbr_sequence_length () != 0)
481 /* Compute the register name of the second register in a hi/lo
483 if (GET_CODE (x
) != REG
)
484 output_operand_lossage ("fr30_print_operand: unrecognized %%p code");
486 fprintf (file
, "r%d", REGNO (x
) + 1);
490 /* Convert GCC's comparison operators into FR30 comparison codes. */
491 switch (GET_CODE (x
))
493 case EQ
: fprintf (file
, "eq"); break;
494 case NE
: fprintf (file
, "ne"); break;
495 case LT
: fprintf (file
, "lt"); break;
496 case LE
: fprintf (file
, "le"); break;
497 case GT
: fprintf (file
, "gt"); break;
498 case GE
: fprintf (file
, "ge"); break;
499 case LTU
: fprintf (file
, "c"); break;
500 case LEU
: fprintf (file
, "ls"); break;
501 case GTU
: fprintf (file
, "hi"); break;
502 case GEU
: fprintf (file
, "nc"); break;
504 output_operand_lossage ("fr30_print_operand: unrecognized %%b code");
510 /* Convert GCC's comparison operators into the complimentary FR30
512 switch (GET_CODE (x
))
514 case EQ
: fprintf (file
, "ne"); break;
515 case NE
: fprintf (file
, "eq"); break;
516 case LT
: fprintf (file
, "ge"); break;
517 case LE
: fprintf (file
, "gt"); break;
518 case GT
: fprintf (file
, "le"); break;
519 case GE
: fprintf (file
, "lt"); break;
520 case LTU
: fprintf (file
, "nc"); break;
521 case LEU
: fprintf (file
, "hi"); break;
522 case GTU
: fprintf (file
, "ls"); break;
523 case GEU
: fprintf (file
, "c"); break;
525 output_operand_lossage ("fr30_print_operand: unrecognized %%B code");
531 /* Print a signed byte value as an unsigned value. */
532 if (GET_CODE (x
) != CONST_INT
)
533 output_operand_lossage ("fr30_print_operand: invalid operand to %%A code");
542 fprintf (file
, HOST_WIDE_INT_PRINT_DEC
, val
);
547 if (GET_CODE (x
) != CONST_INT
550 output_operand_lossage ("fr30_print_operand: invalid %%x code");
552 fprintf (file
, HOST_WIDE_INT_PRINT_DEC
, INTVAL (x
) - 16);
556 if (GET_CODE (x
) != CONST_DOUBLE
)
557 output_operand_lossage ("fr30_print_operand: invalid %%F code");
562 real_to_decimal (str
, CONST_DOUBLE_REAL_VALUE (x
),
573 fprintf (stderr
, "unknown code = %x\n", code
);
574 output_operand_lossage ("fr30_print_operand: unknown code");
578 switch (GET_CODE (x
))
581 fputs (reg_names
[REGNO (x
)], file
);
587 switch (GET_CODE (x0
))
590 if ((unsigned) REGNO (x0
) >= ARRAY_SIZE (reg_names
))
592 fprintf (file
, "@%s", reg_names
[REGNO (x0
)]);
596 if (GET_CODE (XEXP (x0
, 0)) != REG
597 || REGNO (XEXP (x0
, 0)) < FRAME_POINTER_REGNUM
598 || REGNO (XEXP (x0
, 0)) > STACK_POINTER_REGNUM
599 || GET_CODE (XEXP (x0
, 1)) != CONST_INT
)
601 fprintf (stderr
, "bad INDEXed address:");
603 output_operand_lossage ("fr30_print_operand: unhandled MEM");
605 else if (REGNO (XEXP (x0
, 0)) == FRAME_POINTER_REGNUM
)
607 HOST_WIDE_INT val
= INTVAL (XEXP (x0
, 1));
608 if (val
< -(1 << 9) || val
> ((1 << 9) - 4))
610 fprintf (stderr
, "frame INDEX out of range:");
612 output_operand_lossage ("fr30_print_operand: unhandled MEM");
614 fprintf (file
, "@(r14, #" HOST_WIDE_INT_PRINT_DEC
")", val
);
618 HOST_WIDE_INT val
= INTVAL (XEXP (x0
, 1));
619 if (val
< 0 || val
> ((1 << 6) - 4))
621 fprintf (stderr
, "stack INDEX out of range:");
623 output_operand_lossage ("fr30_print_operand: unhandled MEM");
625 fprintf (file
, "@(r15, #" HOST_WIDE_INT_PRINT_DEC
")", val
);
634 fprintf (stderr
, "bad MEM code = %x\n", GET_CODE (x0
));
636 output_operand_lossage ("fr30_print_operand: unhandled MEM");
642 /* We handle SFmode constants here as output_addr_const doesn't. */
643 if (GET_MODE (x
) == SFmode
)
648 REAL_VALUE_FROM_CONST_DOUBLE (d
, x
);
649 REAL_VALUE_TO_TARGET_SINGLE (d
, l
);
650 fprintf (file
, "0x%08lx", l
);
654 /* Fall through. Let output_addr_const deal with it. */
656 output_addr_const (file
, x
);
664 /*{{{ Function arguments */
666 /* Compute the number of word sized registers needed to hold a
667 function argument of mode INT_MODE and tree type TYPE. */
669 fr30_num_arg_regs (enum machine_mode mode
, tree type
)
673 if (MUST_PASS_IN_STACK (mode
, type
))
676 if (type
&& mode
== BLKmode
)
677 size
= int_size_in_bytes (type
);
679 size
= GET_MODE_SIZE (mode
);
681 return (size
+ UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
684 /* Implements the FUNCTION_ARG_PARTIAL_NREGS macro.
685 Returns the number of argument registers required to hold *part* of
686 a parameter of machine mode MODE and tree type TYPE (which may be
687 NULL if the type is not known). If the argument fits entirely in
688 the argument registers, or entirely on the stack, then 0 is returned.
689 CUM is the number of argument registers already used by earlier
690 parameters to the function. */
693 fr30_function_arg_partial_nregs (CUMULATIVE_ARGS cum
, enum machine_mode mode
,
694 tree type
, int named
)
696 /* Unnamed arguments, ie those that are prototyped as ...
697 are always passed on the stack.
698 Also check here to see if all the argument registers are full. */
699 if (named
== 0 || cum
>= FR30_NUM_ARG_REGS
)
702 /* Work out how many argument registers would be needed if this
703 parameter were to be passed entirely in registers. If there
704 are sufficient argument registers available (or if no registers
705 are needed because the parameter must be passed on the stack)
706 then return zero, as this parameter does not require partial
707 register, partial stack stack space. */
708 if (cum
+ fr30_num_arg_regs (mode
, type
) <= FR30_NUM_ARG_REGS
)
711 /* Otherwise return the number of registers that would be used. */
712 return FR30_NUM_ARG_REGS
- cum
;
716 fr30_pass_by_reference (tree valist
, tree type
)
722 type_ptr
= build_pointer_type (type
);
723 type_ptr_ptr
= build_pointer_type (type_ptr
);
725 t
= build (POSTINCREMENT_EXPR
, va_list_type_node
, valist
, build_int_2 (UNITS_PER_WORD
, 0));
726 TREE_SIDE_EFFECTS (t
) = 1;
727 t
= build1 (NOP_EXPR
, type_ptr_ptr
, t
);
728 TREE_SIDE_EFFECTS (t
) = 1;
729 t
= build1 (INDIRECT_REF
, type_ptr
, t
);
731 return expand_expr (t
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
735 fr30_pass_by_value (tree valist
, tree type
)
737 HOST_WIDE_INT size
= int_size_in_bytes (type
);
742 if ((size
% UNITS_PER_WORD
) == 0)
744 t
= build (POSTINCREMENT_EXPR
, va_list_type_node
, valist
, build_int_2 (size
, 0));
745 TREE_SIDE_EFFECTS (t
) = 1;
747 return expand_expr (t
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
750 rsize
= (size
+ UNITS_PER_WORD
- 1) & - UNITS_PER_WORD
;
752 /* Care for bigendian correction on the aligned address. */
753 t
= build (PLUS_EXPR
, ptr_type_node
, valist
, build_int_2 (rsize
- size
, 0));
754 addr_rtx
= expand_expr (t
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
755 addr_rtx
= copy_to_reg (addr_rtx
);
758 t
= build (PLUS_EXPR
, va_list_type_node
, valist
, build_int_2 (rsize
, 0));
759 t
= build (MODIFY_EXPR
, va_list_type_node
, valist
, t
);
760 TREE_SIDE_EFFECTS (t
) = 1;
761 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
766 /* Implement `va_arg'. */
769 fr30_va_arg (tree valist
, tree type
)
773 if (AGGREGATE_TYPE_P (type
))
774 return fr30_pass_by_reference (valist
, type
);
776 size
= int_size_in_bytes (type
);
778 if ((size
% sizeof (int)) == 0
780 return fr30_pass_by_value (valist
, type
);
782 return fr30_pass_by_reference (valist
, type
);
786 /*{{{ Operand predicates */
789 #define Mmode enum machine_mode
792 /* Returns true if OPERAND is an integer value suitable for use in
793 an ADDSP instruction. */
795 stack_add_operand (rtx operand
, Mmode mode ATTRIBUTE_UNUSED
)
798 (GET_CODE (operand
) == CONST_INT
799 && INTVAL (operand
) >= -512
800 && INTVAL (operand
) <= 508
801 && ((INTVAL (operand
) & 3) == 0));
804 /* Returns true if OPERAND is an integer value suitable for use in
805 an ADD por ADD2 instruction, or if it is a register. */
807 add_immediate_operand (rtx operand
, Mmode mode ATTRIBUTE_UNUSED
)
810 (GET_CODE (operand
) == REG
811 || (GET_CODE (operand
) == CONST_INT
812 && INTVAL (operand
) >= -16
813 && INTVAL (operand
) <= 15));
816 /* Returns true if OPERAND is hard register in the range 8 - 15. */
818 high_register_operand (rtx operand
, Mmode mode ATTRIBUTE_UNUSED
)
821 (GET_CODE (operand
) == REG
822 && REGNO (operand
) <= 15
823 && REGNO (operand
) >= 8);
826 /* Returns true if OPERAND is hard register in the range 0 - 7. */
828 low_register_operand (rtx operand
, Mmode mode ATTRIBUTE_UNUSED
)
831 (GET_CODE (operand
) == REG
832 && REGNO (operand
) <= 7);
835 /* Returns true if OPERAND is suitable for use in a CALL insn. */
837 call_operand (rtx operand
, Mmode mode ATTRIBUTE_UNUSED
)
839 return (GET_CODE (operand
) == MEM
840 && (GET_CODE (XEXP (operand
, 0)) == SYMBOL_REF
841 || GET_CODE (XEXP (operand
, 0)) == REG
));
844 /* Returns TRUE if OP is a valid operand of a DImode operation. */
846 di_operand (rtx op
, Mmode mode
)
848 if (register_operand (op
, mode
))
851 if (mode
!= VOIDmode
&& GET_MODE (op
) != VOIDmode
&& GET_MODE (op
) != DImode
)
854 if (GET_CODE (op
) == SUBREG
)
855 op
= SUBREG_REG (op
);
857 switch (GET_CODE (op
))
864 return memory_address_p (DImode
, XEXP (op
, 0));
871 /* Returns TRUE if OP is a DImode register or MEM. */
873 nonimmediate_di_operand (rtx op
, Mmode mode
)
875 if (register_operand (op
, mode
))
878 if (mode
!= VOIDmode
&& GET_MODE (op
) != VOIDmode
&& GET_MODE (op
) != DImode
)
881 if (GET_CODE (op
) == SUBREG
)
882 op
= SUBREG_REG (op
);
884 if (GET_CODE (op
) == MEM
)
885 return memory_address_p (DImode
, XEXP (op
, 0));
890 /* Returns true iff all the registers in the operands array
891 are in descending or ascending order. */
893 fr30_check_multiple_regs (rtx
*operands
, int num_operands
, int descending
)
897 unsigned int prev_regno
= 0;
899 while (num_operands
--)
901 if (GET_CODE (operands
[num_operands
]) != REG
)
904 if (REGNO (operands
[num_operands
]) < prev_regno
)
907 prev_regno
= REGNO (operands
[num_operands
]);
912 unsigned int prev_regno
= CONDITION_CODE_REGNUM
;
914 while (num_operands
--)
916 if (GET_CODE (operands
[num_operands
]) != REG
)
919 if (REGNO (operands
[num_operands
]) > prev_regno
)
922 prev_regno
= REGNO (operands
[num_operands
]);
930 fr30_const_double_is_zero (rtx operand
)
934 if (operand
== NULL
|| GET_CODE (operand
) != CONST_DOUBLE
)
937 REAL_VALUE_FROM_CONST_DOUBLE (d
, operand
);
939 return REAL_VALUES_EQUAL (d
, dconst0
);
943 /*{{{ Instruction Output Routines */
945 /* Output a double word move.
946 It must be REG<-REG, REG<-MEM, MEM<-REG or REG<-CONST.
947 On the FR30 we are constrained by the fact that it does not
948 support offsetable addresses, and so we have to load the
949 address of the secnd word into the second destination register
950 before we can use it. */
953 fr30_move_double (rtx
* operands
)
955 rtx src
= operands
[1];
956 rtx dest
= operands
[0];
957 enum rtx_code src_code
= GET_CODE (src
);
958 enum rtx_code dest_code
= GET_CODE (dest
);
959 enum machine_mode mode
= GET_MODE (dest
);
964 if (dest_code
== REG
)
968 int reverse
= (REGNO (dest
) == REGNO (src
) + 1);
970 /* We normally copy the low-numbered register first. However, if
971 the first register of operand 0 is the same as the second register
972 of operand 1, we must copy in the opposite order. */
973 emit_insn (gen_rtx_SET (VOIDmode
,
974 operand_subword (dest
, reverse
, TRUE
, mode
),
975 operand_subword (src
, reverse
, TRUE
, mode
)));
977 emit_insn (gen_rtx_SET (VOIDmode
,
978 operand_subword (dest
, !reverse
, TRUE
, mode
),
979 operand_subword (src
, !reverse
, TRUE
, mode
)));
981 else if (src_code
== MEM
)
983 rtx addr
= XEXP (src
, 0);
984 int dregno
= REGNO (dest
);
989 /* If the high-address word is used in the address, we
990 must load it last. Otherwise, load it first. */
991 int reverse
= (refers_to_regno_p (dregno
, dregno
+ 1, addr
, 0) != 0);
993 if (GET_CODE (addr
) != REG
)
996 dest0
= operand_subword (dest
, reverse
, TRUE
, mode
);
997 dest1
= operand_subword (dest
, !reverse
, TRUE
, mode
);
1001 emit_insn (gen_rtx_SET (VOIDmode
, dest1
,
1002 adjust_address (src
, SImode
, 0)));
1003 emit_insn (gen_rtx_SET (SImode
, dest0
,
1004 gen_rtx_REG (SImode
, REGNO (addr
))));
1005 emit_insn (gen_rtx_SET (SImode
, dest0
,
1006 plus_constant (dest0
, UNITS_PER_WORD
)));
1008 new_mem
= gen_rtx_MEM (SImode
, dest0
);
1009 MEM_COPY_ATTRIBUTES (new_mem
, src
);
1011 emit_insn (gen_rtx_SET (VOIDmode
, dest0
, new_mem
));
1015 emit_insn (gen_rtx_SET (VOIDmode
, dest0
,
1016 adjust_address (src
, SImode
, 0)));
1017 emit_insn (gen_rtx_SET (SImode
, dest1
,
1018 gen_rtx_REG (SImode
, REGNO (addr
))));
1019 emit_insn (gen_rtx_SET (SImode
, dest1
,
1020 plus_constant (dest1
, UNITS_PER_WORD
)));
1022 new_mem
= gen_rtx_MEM (SImode
, dest1
);
1023 MEM_COPY_ATTRIBUTES (new_mem
, src
);
1025 emit_insn (gen_rtx_SET (VOIDmode
, dest1
, new_mem
));
1028 else if (src_code
== CONST_INT
|| src_code
== CONST_DOUBLE
)
1031 split_double (src
, &words
[0], &words
[1]);
1032 emit_insn (gen_rtx_SET (VOIDmode
,
1033 operand_subword (dest
, 0, TRUE
, mode
),
1036 emit_insn (gen_rtx_SET (VOIDmode
,
1037 operand_subword (dest
, 1, TRUE
, mode
),
1041 else if (src_code
== REG
&& dest_code
== MEM
)
1043 rtx addr
= XEXP (dest
, 0);
1047 if (GET_CODE (addr
) != REG
)
1050 src0
= operand_subword (src
, 0, TRUE
, mode
);
1051 src1
= operand_subword (src
, 1, TRUE
, mode
);
1053 emit_insn (gen_rtx_SET (VOIDmode
, adjust_address (dest
, SImode
, 0),
1056 if (REGNO (addr
) == STACK_POINTER_REGNUM
1057 || REGNO (addr
) == FRAME_POINTER_REGNUM
)
1058 emit_insn (gen_rtx_SET (VOIDmode
,
1059 adjust_address (dest
, SImode
, UNITS_PER_WORD
),
1065 /* We need a scratch register to hold the value of 'address + 4'.
1066 We ought to allow gcc to find one for us, but for now, just
1067 push one of the source registers. */
1068 emit_insn (gen_movsi_push (src0
));
1069 emit_insn (gen_movsi_internal (src0
, addr
));
1070 emit_insn (gen_addsi_small_int (src0
, src0
, GEN_INT (UNITS_PER_WORD
)));
1072 new_mem
= gen_rtx_MEM (SImode
, src0
);
1073 MEM_COPY_ATTRIBUTES (new_mem
, dest
);
1075 emit_insn (gen_rtx_SET (VOIDmode
, new_mem
, src1
));
1076 emit_insn (gen_movsi_pop (src0
));
1080 /* This should have been prevented by the constraints on movdi_insn. */
1089 /* Local Variables: */
1090 /* folded-file: t */